2573 lines
65 KiB
Dart
2573 lines
65 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of '../state.dart';
|
|
|
|
// **************************************************************************
|
|
// RiverpodGenerator
|
|
// **************************************************************************
|
|
|
|
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
// ignore_for_file: type=lint, type=warning
|
|
|
|
@ProviderFor(currentGroupsState)
|
|
const currentGroupsStateProvider = CurrentGroupsStateProvider._();
|
|
|
|
final class CurrentGroupsStateProvider
|
|
extends $FunctionalProvider<GroupsState, GroupsState, GroupsState>
|
|
with $Provider<GroupsState> {
|
|
const CurrentGroupsStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'currentGroupsStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$currentGroupsStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<GroupsState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
GroupsState create(Ref ref) {
|
|
return currentGroupsState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(GroupsState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<GroupsState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$currentGroupsStateHash() =>
|
|
r'dbf8f02606a31486c99d7b89d19914cd5a1fc496';
|
|
|
|
@ProviderFor(navigationItemsState)
|
|
const navigationItemsStateProvider = NavigationItemsStateProvider._();
|
|
|
|
final class NavigationItemsStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
NavigationItemsState,
|
|
NavigationItemsState,
|
|
NavigationItemsState
|
|
>
|
|
with $Provider<NavigationItemsState> {
|
|
const NavigationItemsStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'navigationItemsStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$navigationItemsStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<NavigationItemsState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
NavigationItemsState create(Ref ref) {
|
|
return navigationItemsState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(NavigationItemsState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<NavigationItemsState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$navigationItemsStateHash() =>
|
|
r'1fc37c14d129f9725b0e62fd53f6b25382f51102';
|
|
|
|
@ProviderFor(currentNavigationItemsState)
|
|
const currentNavigationItemsStateProvider =
|
|
CurrentNavigationItemsStateProvider._();
|
|
|
|
final class CurrentNavigationItemsStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
NavigationItemsState,
|
|
NavigationItemsState,
|
|
NavigationItemsState
|
|
>
|
|
with $Provider<NavigationItemsState> {
|
|
const CurrentNavigationItemsStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'currentNavigationItemsStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$currentNavigationItemsStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<NavigationItemsState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
NavigationItemsState create(Ref ref) {
|
|
return currentNavigationItemsState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(NavigationItemsState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<NavigationItemsState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$currentNavigationItemsStateHash() =>
|
|
r'06fbdc194f4527b945695fe3b72b16e0585fa440';
|
|
|
|
@ProviderFor(updateParams)
|
|
const updateParamsProvider = UpdateParamsProvider._();
|
|
|
|
final class UpdateParamsProvider
|
|
extends $FunctionalProvider<UpdateParams, UpdateParams, UpdateParams>
|
|
with $Provider<UpdateParams> {
|
|
const UpdateParamsProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'updateParamsProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$updateParamsHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<UpdateParams> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
UpdateParams create(Ref ref) {
|
|
return updateParams(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(UpdateParams value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<UpdateParams>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$updateParamsHash() => r'012df72ab0e769a51c573f4692031506d7b1f1b4';
|
|
|
|
@ProviderFor(proxyState)
|
|
const proxyStateProvider = ProxyStateProvider._();
|
|
|
|
final class ProxyStateProvider
|
|
extends $FunctionalProvider<ProxyState, ProxyState, ProxyState>
|
|
with $Provider<ProxyState> {
|
|
const ProxyStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'proxyStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$proxyStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProxyState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
ProxyState create(Ref ref) {
|
|
return proxyState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProxyState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProxyState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$proxyStateHash() => r'3df11daa70bd06de32da43e9b3e09a74389264b2';
|
|
|
|
@ProviderFor(trayState)
|
|
const trayStateProvider = TrayStateProvider._();
|
|
|
|
final class TrayStateProvider
|
|
extends $FunctionalProvider<TrayState, TrayState, TrayState>
|
|
with $Provider<TrayState> {
|
|
const TrayStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'trayStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$trayStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<TrayState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
TrayState create(Ref ref) {
|
|
return trayState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(TrayState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<TrayState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$trayStateHash() => r'b03770ae2eb7fe1a73372f1128af3b38fdebb818';
|
|
|
|
@ProviderFor(trayTitleState)
|
|
const trayTitleStateProvider = TrayTitleStateProvider._();
|
|
|
|
final class TrayTitleStateProvider
|
|
extends $FunctionalProvider<TrayTitleState, TrayTitleState, TrayTitleState>
|
|
with $Provider<TrayTitleState> {
|
|
const TrayTitleStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'trayTitleStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$trayTitleStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<TrayTitleState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
TrayTitleState create(Ref ref) {
|
|
return trayTitleState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(TrayTitleState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<TrayTitleState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$trayTitleStateHash() => r'5f868aaf70480b00bfdc2de18684ee646a93fd12';
|
|
|
|
@ProviderFor(vpnState)
|
|
const vpnStateProvider = VpnStateProvider._();
|
|
|
|
final class VpnStateProvider
|
|
extends $FunctionalProvider<VpnState, VpnState, VpnState>
|
|
with $Provider<VpnState> {
|
|
const VpnStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'vpnStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$vpnStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VpnState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
VpnState create(Ref ref) {
|
|
return vpnState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VpnState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VpnState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$vpnStateHash() => r'128ddad03ce045ad1f8204e47aec3cb6cfa29f6e';
|
|
|
|
@ProviderFor(navigationState)
|
|
const navigationStateProvider = NavigationStateProvider._();
|
|
|
|
final class NavigationStateProvider
|
|
extends
|
|
$FunctionalProvider<NavigationState, NavigationState, NavigationState>
|
|
with $Provider<NavigationState> {
|
|
const NavigationStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'navigationStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$navigationStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<NavigationState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
NavigationState create(Ref ref) {
|
|
return navigationState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(NavigationState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<NavigationState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$navigationStateHash() => r'657dc47ecc35ba0807b58cb37e7f1baa14f6c2f9';
|
|
|
|
@ProviderFor(contentWidth)
|
|
const contentWidthProvider = ContentWidthProvider._();
|
|
|
|
final class ContentWidthProvider
|
|
extends $FunctionalProvider<double, double, double>
|
|
with $Provider<double> {
|
|
const ContentWidthProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'contentWidthProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$contentWidthHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<double> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
double create(Ref ref) {
|
|
return contentWidth(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(double value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<double>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$contentWidthHash() => r'4710fee8f91b08dc88520798fb6b1d4f61f090e6';
|
|
|
|
@ProviderFor(dashboardState)
|
|
const dashboardStateProvider = DashboardStateProvider._();
|
|
|
|
final class DashboardStateProvider
|
|
extends $FunctionalProvider<DashboardState, DashboardState, DashboardState>
|
|
with $Provider<DashboardState> {
|
|
const DashboardStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'dashboardStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$dashboardStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<DashboardState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
DashboardState create(Ref ref) {
|
|
return dashboardState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(DashboardState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<DashboardState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$dashboardStateHash() => r'e8616e327c1b96658d917e4e4950f70ecb099d85';
|
|
|
|
@ProviderFor(proxiesActionsState)
|
|
const proxiesActionsStateProvider = ProxiesActionsStateProvider._();
|
|
|
|
final class ProxiesActionsStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
ProxiesActionsState,
|
|
ProxiesActionsState,
|
|
ProxiesActionsState
|
|
>
|
|
with $Provider<ProxiesActionsState> {
|
|
const ProxiesActionsStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'proxiesActionsStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$proxiesActionsStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProxiesActionsState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
ProxiesActionsState create(Ref ref) {
|
|
return proxiesActionsState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProxiesActionsState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProxiesActionsState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$proxiesActionsStateHash() =>
|
|
r'84f8a94706233ff5d4b8a456291a4e66c1381c62';
|
|
|
|
@ProviderFor(profilesState)
|
|
const profilesStateProvider = ProfilesStateProvider._();
|
|
|
|
final class ProfilesStateProvider
|
|
extends $FunctionalProvider<ProfilesState, ProfilesState, ProfilesState>
|
|
with $Provider<ProfilesState> {
|
|
const ProfilesStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'profilesStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$profilesStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProfilesState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
ProfilesState create(Ref ref) {
|
|
return profilesState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProfilesState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProfilesState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$profilesStateHash() => r'8b07eeacb83b9002ba7e6283ff7a7f451a0845a6';
|
|
|
|
@ProviderFor(filterGroupsState)
|
|
const filterGroupsStateProvider = FilterGroupsStateFamily._();
|
|
|
|
final class FilterGroupsStateProvider
|
|
extends $FunctionalProvider<GroupsState, GroupsState, GroupsState>
|
|
with $Provider<GroupsState> {
|
|
const FilterGroupsStateProvider._({
|
|
required FilterGroupsStateFamily super.from,
|
|
required String super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'filterGroupsStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$filterGroupsStateHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'filterGroupsStateProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<GroupsState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
GroupsState create(Ref ref) {
|
|
final argument = this.argument as String;
|
|
return filterGroupsState(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(GroupsState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<GroupsState>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is FilterGroupsStateProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$filterGroupsStateHash() => r'7de7a4603ca5ed7c39a00351af43144eb6c21404';
|
|
|
|
final class FilterGroupsStateFamily extends $Family
|
|
with $FunctionalFamilyOverride<GroupsState, String> {
|
|
const FilterGroupsStateFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'filterGroupsStateProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
FilterGroupsStateProvider call(String query) =>
|
|
FilterGroupsStateProvider._(argument: query, from: this);
|
|
|
|
@override
|
|
String toString() => r'filterGroupsStateProvider';
|
|
}
|
|
|
|
@ProviderFor(proxiesListState)
|
|
const proxiesListStateProvider = ProxiesListStateProvider._();
|
|
|
|
final class ProxiesListStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
ProxiesListState,
|
|
ProxiesListState,
|
|
ProxiesListState
|
|
>
|
|
with $Provider<ProxiesListState> {
|
|
const ProxiesListStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'proxiesListStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$proxiesListStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProxiesListState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
ProxiesListState create(Ref ref) {
|
|
return proxiesListState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProxiesListState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProxiesListState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$proxiesListStateHash() => r'b16ad96516ece78f6cb22f558a0535000b784317';
|
|
|
|
@ProviderFor(proxiesTabState)
|
|
const proxiesTabStateProvider = ProxiesTabStateProvider._();
|
|
|
|
final class ProxiesTabStateProvider
|
|
extends
|
|
$FunctionalProvider<ProxiesTabState, ProxiesTabState, ProxiesTabState>
|
|
with $Provider<ProxiesTabState> {
|
|
const ProxiesTabStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'proxiesTabStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$proxiesTabStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProxiesTabState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
ProxiesTabState create(Ref ref) {
|
|
return proxiesTabState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProxiesTabState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProxiesTabState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$proxiesTabStateHash() => r'143b106d74da618327cbac48af15078efd8cabee';
|
|
|
|
@ProviderFor(isStart)
|
|
const isStartProvider = IsStartProvider._();
|
|
|
|
final class IsStartProvider extends $FunctionalProvider<bool, bool, bool>
|
|
with $Provider<bool> {
|
|
const IsStartProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'isStartProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$isStartHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<bool> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
bool create(Ref ref) {
|
|
return isStart(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(bool value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<bool>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$isStartHash() => r'f8bcefa8515c44fbe14876a5fc6676110508e9b2';
|
|
|
|
@ProviderFor(proxiesTabControllerState)
|
|
const proxiesTabControllerStateProvider = ProxiesTabControllerStateProvider._();
|
|
|
|
final class ProxiesTabControllerStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
VM2<List<String>, String?>,
|
|
VM2<List<String>, String?>,
|
|
VM2<List<String>, String?>
|
|
>
|
|
with $Provider<VM2<List<String>, String?>> {
|
|
const ProxiesTabControllerStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'proxiesTabControllerStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$proxiesTabControllerStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VM2<List<String>, String?>> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
VM2<List<String>, String?> create(Ref ref) {
|
|
return proxiesTabControllerState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM2<List<String>, String?> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM2<List<String>, String?>>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$proxiesTabControllerStateHash() =>
|
|
r'd9c4eb6771262b2a989b053ce6ad94c307cf43fb';
|
|
|
|
@ProviderFor(proxyGroupSelectorState)
|
|
const proxyGroupSelectorStateProvider = ProxyGroupSelectorStateFamily._();
|
|
|
|
final class ProxyGroupSelectorStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
ProxyGroupSelectorState,
|
|
ProxyGroupSelectorState,
|
|
ProxyGroupSelectorState
|
|
>
|
|
with $Provider<ProxyGroupSelectorState> {
|
|
const ProxyGroupSelectorStateProvider._({
|
|
required ProxyGroupSelectorStateFamily super.from,
|
|
required (String, String) super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'proxyGroupSelectorStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$proxyGroupSelectorStateHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'proxyGroupSelectorStateProvider'
|
|
''
|
|
'$argument';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProxyGroupSelectorState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
ProxyGroupSelectorState create(Ref ref) {
|
|
final argument = this.argument as (String, String);
|
|
return proxyGroupSelectorState(ref, argument.$1, argument.$2);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProxyGroupSelectorState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProxyGroupSelectorState>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is ProxyGroupSelectorStateProvider &&
|
|
other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$proxyGroupSelectorStateHash() =>
|
|
r'c2a059873a38907071a2664409bacfe21b7d6c3c';
|
|
|
|
final class ProxyGroupSelectorStateFamily extends $Family
|
|
with $FunctionalFamilyOverride<ProxyGroupSelectorState, (String, String)> {
|
|
const ProxyGroupSelectorStateFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'proxyGroupSelectorStateProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
ProxyGroupSelectorStateProvider call(String groupName, String query) =>
|
|
ProxyGroupSelectorStateProvider._(
|
|
argument: (groupName, query),
|
|
from: this,
|
|
);
|
|
|
|
@override
|
|
String toString() => r'proxyGroupSelectorStateProvider';
|
|
}
|
|
|
|
@ProviderFor(packageListSelectorState)
|
|
const packageListSelectorStateProvider = PackageListSelectorStateProvider._();
|
|
|
|
final class PackageListSelectorStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
PackageListSelectorState,
|
|
PackageListSelectorState,
|
|
PackageListSelectorState
|
|
>
|
|
with $Provider<PackageListSelectorState> {
|
|
const PackageListSelectorStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'packageListSelectorStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$packageListSelectorStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<PackageListSelectorState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
PackageListSelectorState create(Ref ref) {
|
|
return packageListSelectorState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(PackageListSelectorState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<PackageListSelectorState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$packageListSelectorStateHash() =>
|
|
r'1fa2bebbd8ee07910aa8d6e9c5d5d6128df5c13b';
|
|
|
|
@ProviderFor(moreToolsSelectorState)
|
|
const moreToolsSelectorStateProvider = MoreToolsSelectorStateProvider._();
|
|
|
|
final class MoreToolsSelectorStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
MoreToolsSelectorState,
|
|
MoreToolsSelectorState,
|
|
MoreToolsSelectorState
|
|
>
|
|
with $Provider<MoreToolsSelectorState> {
|
|
const MoreToolsSelectorStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'moreToolsSelectorStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$moreToolsSelectorStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<MoreToolsSelectorState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
MoreToolsSelectorState create(Ref ref) {
|
|
return moreToolsSelectorState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(MoreToolsSelectorState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<MoreToolsSelectorState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$moreToolsSelectorStateHash() =>
|
|
r'6329d92652135e2af009dddeac590b4369d2fa04';
|
|
|
|
@ProviderFor(isCurrentPage)
|
|
const isCurrentPageProvider = IsCurrentPageFamily._();
|
|
|
|
final class IsCurrentPageProvider extends $FunctionalProvider<bool, bool, bool>
|
|
with $Provider<bool> {
|
|
const IsCurrentPageProvider._({
|
|
required IsCurrentPageFamily super.from,
|
|
required (
|
|
PageLabel, {
|
|
bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
|
|
})
|
|
super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'isCurrentPageProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$isCurrentPageHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'isCurrentPageProvider'
|
|
''
|
|
'$argument';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<bool> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
bool create(Ref ref) {
|
|
final argument =
|
|
this.argument
|
|
as (
|
|
PageLabel, {
|
|
bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
|
|
});
|
|
return isCurrentPage(ref, argument.$1, handler: argument.handler);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(bool value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<bool>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is IsCurrentPageProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$isCurrentPageHash() => r'7c300770aef90da23109d9fcfc3bf26140d8cd08';
|
|
|
|
final class IsCurrentPageFamily extends $Family
|
|
with
|
|
$FunctionalFamilyOverride<
|
|
bool,
|
|
(
|
|
PageLabel, {
|
|
bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
|
|
})
|
|
> {
|
|
const IsCurrentPageFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'isCurrentPageProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
IsCurrentPageProvider call(
|
|
PageLabel pageLabel, {
|
|
bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
|
|
}) => IsCurrentPageProvider._(
|
|
argument: (pageLabel, handler: handler),
|
|
from: this,
|
|
);
|
|
|
|
@override
|
|
String toString() => r'isCurrentPageProvider';
|
|
}
|
|
|
|
@ProviderFor(realTestUrl)
|
|
const realTestUrlProvider = RealTestUrlFamily._();
|
|
|
|
final class RealTestUrlProvider
|
|
extends $FunctionalProvider<String, String, String>
|
|
with $Provider<String> {
|
|
const RealTestUrlProvider._({
|
|
required RealTestUrlFamily super.from,
|
|
required String? super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'realTestUrlProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$realTestUrlHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'realTestUrlProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<String> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
String create(Ref ref) {
|
|
final argument = this.argument as String?;
|
|
return realTestUrl(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(String value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<String>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is RealTestUrlProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$realTestUrlHash() => r'6d68caa7a526b6788e3e4899d3ec8ad1c065b15e';
|
|
|
|
final class RealTestUrlFamily extends $Family
|
|
with $FunctionalFamilyOverride<String, String?> {
|
|
const RealTestUrlFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'realTestUrlProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
RealTestUrlProvider call([String? testUrl]) =>
|
|
RealTestUrlProvider._(argument: testUrl, from: this);
|
|
|
|
@override
|
|
String toString() => r'realTestUrlProvider';
|
|
}
|
|
|
|
@ProviderFor(getDelay)
|
|
const getDelayProvider = GetDelayFamily._();
|
|
|
|
final class GetDelayProvider extends $FunctionalProvider<int?, int?, int?>
|
|
with $Provider<int?> {
|
|
const GetDelayProvider._({
|
|
required GetDelayFamily super.from,
|
|
required ({String proxyName, String? testUrl}) super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getDelayProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getDelayHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getDelayProvider'
|
|
''
|
|
'$argument';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<int?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
int? create(Ref ref) {
|
|
final argument = this.argument as ({String proxyName, String? testUrl});
|
|
return getDelay(
|
|
ref,
|
|
proxyName: argument.proxyName,
|
|
testUrl: argument.testUrl,
|
|
);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(int? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<int?>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GetDelayProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getDelayHash() => r'ee2df2db2b12d599794f77519a9ac518f42245a7';
|
|
|
|
final class GetDelayFamily extends $Family
|
|
with
|
|
$FunctionalFamilyOverride<int?, ({String proxyName, String? testUrl})> {
|
|
const GetDelayFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getDelayProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetDelayProvider call({required String proxyName, String? testUrl}) =>
|
|
GetDelayProvider._(
|
|
argument: (proxyName: proxyName, testUrl: testUrl),
|
|
from: this,
|
|
);
|
|
|
|
@override
|
|
String toString() => r'getDelayProvider';
|
|
}
|
|
|
|
@ProviderFor(selectedMap)
|
|
const selectedMapProvider = SelectedMapProvider._();
|
|
|
|
final class SelectedMapProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
Map<String, String>,
|
|
Map<String, String>,
|
|
Map<String, String>
|
|
>
|
|
with $Provider<Map<String, String>> {
|
|
const SelectedMapProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'selectedMapProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$selectedMapHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<Map<String, String>> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
Map<String, String> create(Ref ref) {
|
|
return selectedMap(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(Map<String, String> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<Map<String, String>>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$selectedMapHash() => r'd4438d8d87d0c7ec7d9c5d02f577cdba6ba2a785';
|
|
|
|
@ProviderFor(unfoldSet)
|
|
const unfoldSetProvider = UnfoldSetProvider._();
|
|
|
|
final class UnfoldSetProvider
|
|
extends $FunctionalProvider<Set<String>, Set<String>, Set<String>>
|
|
with $Provider<Set<String>> {
|
|
const UnfoldSetProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'unfoldSetProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$unfoldSetHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<Set<String>> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
Set<String> create(Ref ref) {
|
|
return unfoldSet(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(Set<String> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<Set<String>>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$unfoldSetHash() => r'59a5b417611533069462ddf31eca080ab2f74ac9';
|
|
|
|
@ProviderFor(getHotKeyAction)
|
|
const getHotKeyActionProvider = GetHotKeyActionFamily._();
|
|
|
|
final class GetHotKeyActionProvider
|
|
extends $FunctionalProvider<HotKeyAction, HotKeyAction, HotKeyAction>
|
|
with $Provider<HotKeyAction> {
|
|
const GetHotKeyActionProvider._({
|
|
required GetHotKeyActionFamily super.from,
|
|
required HotAction super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getHotKeyActionProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getHotKeyActionHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getHotKeyActionProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<HotKeyAction> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
HotKeyAction create(Ref ref) {
|
|
final argument = this.argument as HotAction;
|
|
return getHotKeyAction(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(HotKeyAction value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<HotKeyAction>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GetHotKeyActionProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getHotKeyActionHash() => r'4dc74ea7ffb25624ce70c7c8214806f3ef022223';
|
|
|
|
final class GetHotKeyActionFamily extends $Family
|
|
with $FunctionalFamilyOverride<HotKeyAction, HotAction> {
|
|
const GetHotKeyActionFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getHotKeyActionProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetHotKeyActionProvider call(HotAction hotAction) =>
|
|
GetHotKeyActionProvider._(argument: hotAction, from: this);
|
|
|
|
@override
|
|
String toString() => r'getHotKeyActionProvider';
|
|
}
|
|
|
|
@ProviderFor(currentProfile)
|
|
const currentProfileProvider = CurrentProfileProvider._();
|
|
|
|
final class CurrentProfileProvider
|
|
extends $FunctionalProvider<Profile?, Profile?, Profile?>
|
|
with $Provider<Profile?> {
|
|
const CurrentProfileProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'currentProfileProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$currentProfileHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<Profile?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
Profile? create(Ref ref) {
|
|
return currentProfile(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(Profile? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<Profile?>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$currentProfileHash() => r'55f3cb9570a0aa6b9e0b83a36693b69d52e753ab';
|
|
|
|
@ProviderFor(getProxiesColumns)
|
|
const getProxiesColumnsProvider = GetProxiesColumnsProvider._();
|
|
|
|
final class GetProxiesColumnsProvider extends $FunctionalProvider<int, int, int>
|
|
with $Provider<int> {
|
|
const GetProxiesColumnsProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'getProxiesColumnsProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getProxiesColumnsHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<int> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
int create(Ref ref) {
|
|
return getProxiesColumns(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(int value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<int>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$getProxiesColumnsHash() => r'd5340932d4812727caa670065bce30450f1c4da5';
|
|
|
|
@ProviderFor(realSelectedProxyState)
|
|
const realSelectedProxyStateProvider = RealSelectedProxyStateFamily._();
|
|
|
|
final class RealSelectedProxyStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
SelectedProxyState,
|
|
SelectedProxyState,
|
|
SelectedProxyState
|
|
>
|
|
with $Provider<SelectedProxyState> {
|
|
const RealSelectedProxyStateProvider._({
|
|
required RealSelectedProxyStateFamily super.from,
|
|
required String super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'realSelectedProxyStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$realSelectedProxyStateHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'realSelectedProxyStateProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<SelectedProxyState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
SelectedProxyState create(Ref ref) {
|
|
final argument = this.argument as String;
|
|
return realSelectedProxyState(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(SelectedProxyState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<SelectedProxyState>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is RealSelectedProxyStateProvider &&
|
|
other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$realSelectedProxyStateHash() =>
|
|
r'42fa131419f0a26e30c4f5269bf020893b7f828c';
|
|
|
|
final class RealSelectedProxyStateFamily extends $Family
|
|
with $FunctionalFamilyOverride<SelectedProxyState, String> {
|
|
const RealSelectedProxyStateFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'realSelectedProxyStateProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
RealSelectedProxyStateProvider call(String proxyName) =>
|
|
RealSelectedProxyStateProvider._(argument: proxyName, from: this);
|
|
|
|
@override
|
|
String toString() => r'realSelectedProxyStateProvider';
|
|
}
|
|
|
|
@ProviderFor(getProxyName)
|
|
const getProxyNameProvider = GetProxyNameFamily._();
|
|
|
|
final class GetProxyNameProvider
|
|
extends $FunctionalProvider<String?, String?, String?>
|
|
with $Provider<String?> {
|
|
const GetProxyNameProvider._({
|
|
required GetProxyNameFamily super.from,
|
|
required String super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getProxyNameProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getProxyNameHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getProxyNameProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<String?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
String? create(Ref ref) {
|
|
final argument = this.argument as String;
|
|
return getProxyName(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(String? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<String?>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GetProxyNameProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getProxyNameHash() => r'204a477ea18c8e1eeef55b3efd3d47e45b0d2350';
|
|
|
|
final class GetProxyNameFamily extends $Family
|
|
with $FunctionalFamilyOverride<String?, String> {
|
|
const GetProxyNameFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getProxyNameProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetProxyNameProvider call(String groupName) =>
|
|
GetProxyNameProvider._(argument: groupName, from: this);
|
|
|
|
@override
|
|
String toString() => r'getProxyNameProvider';
|
|
}
|
|
|
|
@ProviderFor(getSelectedProxyName)
|
|
const getSelectedProxyNameProvider = GetSelectedProxyNameFamily._();
|
|
|
|
final class GetSelectedProxyNameProvider
|
|
extends $FunctionalProvider<String?, String?, String?>
|
|
with $Provider<String?> {
|
|
const GetSelectedProxyNameProvider._({
|
|
required GetSelectedProxyNameFamily super.from,
|
|
required String super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getSelectedProxyNameProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getSelectedProxyNameHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getSelectedProxyNameProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<String?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
String? create(Ref ref) {
|
|
final argument = this.argument as String;
|
|
return getSelectedProxyName(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(String? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<String?>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GetSelectedProxyNameProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getSelectedProxyNameHash() =>
|
|
r'13aeae1fede234983d262d824a85c7375f9e4e78';
|
|
|
|
final class GetSelectedProxyNameFamily extends $Family
|
|
with $FunctionalFamilyOverride<String?, String> {
|
|
const GetSelectedProxyNameFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getSelectedProxyNameProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetSelectedProxyNameProvider call(String groupName) =>
|
|
GetSelectedProxyNameProvider._(argument: groupName, from: this);
|
|
|
|
@override
|
|
String toString() => r'getSelectedProxyNameProvider';
|
|
}
|
|
|
|
@ProviderFor(getProxyDesc)
|
|
const getProxyDescProvider = GetProxyDescFamily._();
|
|
|
|
final class GetProxyDescProvider
|
|
extends $FunctionalProvider<String, String, String>
|
|
with $Provider<String> {
|
|
const GetProxyDescProvider._({
|
|
required GetProxyDescFamily super.from,
|
|
required Proxy super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getProxyDescProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getProxyDescHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getProxyDescProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<String> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
String create(Ref ref) {
|
|
final argument = this.argument as Proxy;
|
|
return getProxyDesc(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(String value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<String>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GetProxyDescProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getProxyDescHash() => r'4579b55bf7e9fbcfdf91b91619bd0320c585f23d';
|
|
|
|
final class GetProxyDescFamily extends $Family
|
|
with $FunctionalFamilyOverride<String, Proxy> {
|
|
const GetProxyDescFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getProxyDescProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetProxyDescProvider call(Proxy proxy) =>
|
|
GetProxyDescProvider._(argument: proxy, from: this);
|
|
|
|
@override
|
|
String toString() => r'getProxyDescProvider';
|
|
}
|
|
|
|
@ProviderFor(checkIp)
|
|
const checkIpProvider = CheckIpProvider._();
|
|
|
|
final class CheckIpProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
VM3<bool, int, bool>,
|
|
VM3<bool, int, bool>,
|
|
VM3<bool, int, bool>
|
|
>
|
|
with $Provider<VM3<bool, int, bool>> {
|
|
const CheckIpProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'checkIpProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$checkIpHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VM3<bool, int, bool>> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
VM3<bool, int, bool> create(Ref ref) {
|
|
return checkIp(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM3<bool, int, bool> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM3<bool, int, bool>>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$checkIpHash() => r'7d8be66f0e8164bcf20c32659da2a4bea9893596';
|
|
|
|
@ProviderFor(genColorScheme)
|
|
const genColorSchemeProvider = GenColorSchemeFamily._();
|
|
|
|
final class GenColorSchemeProvider
|
|
extends $FunctionalProvider<ColorScheme, ColorScheme, ColorScheme>
|
|
with $Provider<ColorScheme> {
|
|
const GenColorSchemeProvider._({
|
|
required GenColorSchemeFamily super.from,
|
|
required (Brightness, {Color? color, bool ignoreConfig}) super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'genColorSchemeProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$genColorSchemeHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'genColorSchemeProvider'
|
|
''
|
|
'$argument';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ColorScheme> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
ColorScheme create(Ref ref) {
|
|
final argument =
|
|
this.argument as (Brightness, {Color? color, bool ignoreConfig});
|
|
return genColorScheme(
|
|
ref,
|
|
argument.$1,
|
|
color: argument.color,
|
|
ignoreConfig: argument.ignoreConfig,
|
|
);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ColorScheme value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ColorScheme>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GenColorSchemeProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$genColorSchemeHash() => r'25f648db7c33ac00e7152f3d304da372a4de9fdd';
|
|
|
|
final class GenColorSchemeFamily extends $Family
|
|
with
|
|
$FunctionalFamilyOverride<
|
|
ColorScheme,
|
|
(Brightness, {Color? color, bool ignoreConfig})
|
|
> {
|
|
const GenColorSchemeFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'genColorSchemeProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GenColorSchemeProvider call(
|
|
Brightness brightness, {
|
|
Color? color,
|
|
bool ignoreConfig = false,
|
|
}) => GenColorSchemeProvider._(
|
|
argument: (brightness, color: color, ignoreConfig: ignoreConfig),
|
|
from: this,
|
|
);
|
|
|
|
@override
|
|
String toString() => r'genColorSchemeProvider';
|
|
}
|
|
|
|
@ProviderFor(currentSetupState)
|
|
const currentSetupStateProvider = CurrentSetupStateProvider._();
|
|
|
|
final class CurrentSetupStateProvider
|
|
extends $FunctionalProvider<SetupState?, SetupState?, SetupState?>
|
|
with $Provider<SetupState?> {
|
|
const CurrentSetupStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'currentSetupStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$currentSetupStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<SetupState?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
SetupState? create(Ref ref) {
|
|
return currentSetupState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(SetupState? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<SetupState?>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$currentSetupStateHash() => r'd687b0563ea8cc8eb1ca345fdfeee3411d67ad47';
|
|
|
|
@ProviderFor(currentBrightness)
|
|
const currentBrightnessProvider = CurrentBrightnessProvider._();
|
|
|
|
final class CurrentBrightnessProvider
|
|
extends $FunctionalProvider<Brightness, Brightness, Brightness>
|
|
with $Provider<Brightness> {
|
|
const CurrentBrightnessProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'currentBrightnessProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$currentBrightnessHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<Brightness> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
Brightness create(Ref ref) {
|
|
return currentBrightness(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(Brightness value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<Brightness>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$currentBrightnessHash() => r'ab56c47af4fcae773c8f9f81c91800c1e1890b70';
|
|
|
|
@ProviderFor(autoSetSystemDnsState)
|
|
const autoSetSystemDnsStateProvider = AutoSetSystemDnsStateProvider._();
|
|
|
|
final class AutoSetSystemDnsStateProvider
|
|
extends
|
|
$FunctionalProvider<VM2<bool, bool>, VM2<bool, bool>, VM2<bool, bool>>
|
|
with $Provider<VM2<bool, bool>> {
|
|
const AutoSetSystemDnsStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'autoSetSystemDnsStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$autoSetSystemDnsStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VM2<bool, bool>> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
VM2<bool, bool> create(Ref ref) {
|
|
return autoSetSystemDnsState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM2<bool, bool> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM2<bool, bool>>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$autoSetSystemDnsStateHash() =>
|
|
r'a8805965efe78241613bfde55f4ea8fa12a6ea32';
|
|
|
|
@ProviderFor(needUpdateGroups)
|
|
const needUpdateGroupsProvider = NeedUpdateGroupsProvider._();
|
|
|
|
final class NeedUpdateGroupsProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
VM3<bool, int, ProxiesSortType>,
|
|
VM3<bool, int, ProxiesSortType>,
|
|
VM3<bool, int, ProxiesSortType>
|
|
>
|
|
with $Provider<VM3<bool, int, ProxiesSortType>> {
|
|
const NeedUpdateGroupsProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'needUpdateGroupsProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$needUpdateGroupsHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VM3<bool, int, ProxiesSortType>> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
VM3<bool, int, ProxiesSortType> create(Ref ref) {
|
|
return needUpdateGroups(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM3<bool, int, ProxiesSortType> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM3<bool, int, ProxiesSortType>>(
|
|
value,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$needUpdateGroupsHash() => r'7913b7b74caf9f2c72fd32729d52b7c6ac9258e8';
|
|
|
|
@ProviderFor(sharedState)
|
|
const sharedStateProvider = SharedStateProvider._();
|
|
|
|
final class SharedStateProvider
|
|
extends $FunctionalProvider<SharedState, SharedState, SharedState>
|
|
with $Provider<SharedState> {
|
|
const SharedStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'sharedStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$sharedStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<SharedState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
SharedState create(Ref ref) {
|
|
return sharedState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(SharedState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<SharedState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$sharedStateHash() => r'864fdf3f750fb6d1beadcb5f9226a614a9cb2caa';
|
|
|
|
@ProviderFor(overlayTopOffset)
|
|
const overlayTopOffsetProvider = OverlayTopOffsetProvider._();
|
|
|
|
final class OverlayTopOffsetProvider
|
|
extends $FunctionalProvider<double, double, double>
|
|
with $Provider<double> {
|
|
const OverlayTopOffsetProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'overlayTopOffsetProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$overlayTopOffsetHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<double> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
double create(Ref ref) {
|
|
return overlayTopOffset(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(double value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<double>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$overlayTopOffsetHash() => r'b2462f67acbd88b7a881dfe4c6353e68ba49961d';
|
|
|
|
@ProviderFor(profile)
|
|
const profileProvider = ProfileFamily._();
|
|
|
|
final class ProfileProvider
|
|
extends $FunctionalProvider<Profile?, Profile?, Profile?>
|
|
with $Provider<Profile?> {
|
|
const ProfileProvider._({
|
|
required ProfileFamily super.from,
|
|
required int? super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'profileProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$profileHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'profileProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<Profile?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
Profile? create(Ref ref) {
|
|
final argument = this.argument as int?;
|
|
return profile(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(Profile? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<Profile?>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is ProfileProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$profileHash() => r'8de429dc0844c6b6155032ad3c9546231e08cead';
|
|
|
|
final class ProfileFamily extends $Family
|
|
with $FunctionalFamilyOverride<Profile?, int?> {
|
|
const ProfileFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'profileProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
ProfileProvider call(int? profileId) =>
|
|
ProfileProvider._(argument: profileId, from: this);
|
|
|
|
@override
|
|
String toString() => r'profileProvider';
|
|
}
|
|
|
|
@ProviderFor(overwriteType)
|
|
const overwriteTypeProvider = OverwriteTypeFamily._();
|
|
|
|
final class OverwriteTypeProvider
|
|
extends $FunctionalProvider<OverwriteType, OverwriteType, OverwriteType>
|
|
with $Provider<OverwriteType> {
|
|
const OverwriteTypeProvider._({
|
|
required OverwriteTypeFamily super.from,
|
|
required int? super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'overwriteTypeProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$overwriteTypeHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'overwriteTypeProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<OverwriteType> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
OverwriteType create(Ref ref) {
|
|
final argument = this.argument as int?;
|
|
return overwriteType(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(OverwriteType value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<OverwriteType>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is OverwriteTypeProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$overwriteTypeHash() => r'03a8ab8ddec76935da5fa231270b65baa70fd727';
|
|
|
|
final class OverwriteTypeFamily extends $Family
|
|
with $FunctionalFamilyOverride<OverwriteType, int?> {
|
|
const OverwriteTypeFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'overwriteTypeProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
OverwriteTypeProvider call(int? profileId) =>
|
|
OverwriteTypeProvider._(argument: profileId, from: this);
|
|
|
|
@override
|
|
String toString() => r'overwriteTypeProvider';
|
|
}
|
|
|
|
@ProviderFor(script)
|
|
const scriptProvider = ScriptFamily._();
|
|
|
|
final class ScriptProvider
|
|
extends $FunctionalProvider<AsyncValue<Script?>, Script?, FutureOr<Script?>>
|
|
with $FutureModifier<Script?>, $FutureProvider<Script?> {
|
|
const ScriptProvider._({
|
|
required ScriptFamily super.from,
|
|
required int? super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'scriptProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$scriptHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'scriptProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$FutureProviderElement<Script?> $createElement($ProviderPointer pointer) =>
|
|
$FutureProviderElement(pointer);
|
|
|
|
@override
|
|
FutureOr<Script?> create(Ref ref) {
|
|
final argument = this.argument as int?;
|
|
return script(ref, argument);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is ScriptProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$scriptHash() => r'b12a6dbe34e08cb1232afafa8b0b0f5363d28bc0';
|
|
|
|
final class ScriptFamily extends $Family
|
|
with $FunctionalFamilyOverride<FutureOr<Script?>, int?> {
|
|
const ScriptFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'scriptProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
ScriptProvider call(int? scriptId) =>
|
|
ScriptProvider._(argument: scriptId, from: this);
|
|
|
|
@override
|
|
String toString() => r'scriptProvider';
|
|
}
|
|
|
|
@ProviderFor(setupState)
|
|
const setupStateProvider = SetupStateFamily._();
|
|
|
|
final class SetupStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
AsyncValue<SetupState>,
|
|
SetupState,
|
|
FutureOr<SetupState>
|
|
>
|
|
with $FutureModifier<SetupState>, $FutureProvider<SetupState> {
|
|
const SetupStateProvider._({
|
|
required SetupStateFamily super.from,
|
|
required int? super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'setupStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$setupStateHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'setupStateProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$FutureProviderElement<SetupState> $createElement($ProviderPointer pointer) =>
|
|
$FutureProviderElement(pointer);
|
|
|
|
@override
|
|
FutureOr<SetupState> create(Ref ref) {
|
|
final argument = this.argument as int?;
|
|
return setupState(ref, argument);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is SetupStateProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$setupStateHash() => r'8e0c849fa1a51ee15f8b40be94e3094182325b58';
|
|
|
|
final class SetupStateFamily extends $Family
|
|
with $FunctionalFamilyOverride<FutureOr<SetupState>, int?> {
|
|
const SetupStateFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'setupStateProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
SetupStateProvider call(int? profileId) =>
|
|
SetupStateProvider._(argument: profileId, from: this);
|
|
|
|
@override
|
|
String toString() => r'setupStateProvider';
|
|
}
|
|
|
|
@ProviderFor(AccessControlState)
|
|
const accessControlStateProvider = AccessControlStateProvider._();
|
|
|
|
final class AccessControlStateProvider
|
|
extends $NotifierProvider<AccessControlState, AccessControlProps> {
|
|
const AccessControlStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'accessControlStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$accessControlStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
AccessControlState create() => AccessControlState();
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(AccessControlProps value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<AccessControlProps>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$accessControlStateHash() =>
|
|
r'08fda2e342d027c1bdd49c1ef9a13f2e775db204';
|
|
|
|
abstract class _$AccessControlState extends $Notifier<AccessControlProps> {
|
|
AccessControlProps build();
|
|
@$mustCallSuper
|
|
@override
|
|
void runBuild() {
|
|
final created = build();
|
|
final ref = this.ref as $Ref<AccessControlProps, AccessControlProps>;
|
|
final element =
|
|
ref.element
|
|
as $ClassProviderElement<
|
|
AnyNotifier<AccessControlProps, AccessControlProps>,
|
|
AccessControlProps,
|
|
Object?,
|
|
Object?
|
|
>;
|
|
element.handleValue(ref, created);
|
|
}
|
|
}
|