2447 lines
62 KiB
Dart
2447 lines
62 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(configState)
|
|
const configStateProvider = ConfigStateProvider._();
|
|
|
|
final class ConfigStateProvider
|
|
extends $FunctionalProvider<Config, Config, Config>
|
|
with $Provider<Config> {
|
|
const ConfigStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'configStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$configStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<Config> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
Config create(Ref ref) {
|
|
return configState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(Config value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<Config>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$configStateHash() => r'1f4ea3cc8f6461ba734e7e0c5d7295bfa4fd5afb';
|
|
|
|
@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'6222c006e1970e7435268d32903b9019cf1a4351';
|
|
|
|
@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'22478fb593aaca11dfe2cf64472013190475a5bc';
|
|
|
|
@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'2237a7dbf8fd66a0618e3d9caf99667857e6fd4d';
|
|
|
|
@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(startButtonSelectorState)
|
|
const startButtonSelectorStateProvider = StartButtonSelectorStateProvider._();
|
|
|
|
final class StartButtonSelectorStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
StartButtonSelectorState,
|
|
StartButtonSelectorState,
|
|
StartButtonSelectorState
|
|
>
|
|
with $Provider<StartButtonSelectorState> {
|
|
const StartButtonSelectorStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'startButtonSelectorStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$startButtonSelectorStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<StartButtonSelectorState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
StartButtonSelectorState create(Ref ref) {
|
|
return startButtonSelectorState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(StartButtonSelectorState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<StartButtonSelectorState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$startButtonSelectorStateHash() =>
|
|
r'537aff93c98b0a689cf8cabd080c610c9c58e611';
|
|
|
|
@ProviderFor(profilesSelectorState)
|
|
const profilesSelectorStateProvider = ProfilesSelectorStateProvider._();
|
|
|
|
final class ProfilesSelectorStateProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
ProfilesSelectorState,
|
|
ProfilesSelectorState,
|
|
ProfilesSelectorState
|
|
>
|
|
with $Provider<ProfilesSelectorState> {
|
|
const ProfilesSelectorStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'profilesSelectorStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$profilesSelectorStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<ProfilesSelectorState> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
ProfilesSelectorState create(Ref ref) {
|
|
return profilesSelectorState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(ProfilesSelectorState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<ProfilesSelectorState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$profilesSelectorStateHash() =>
|
|
r'da4a4382d7054dfe4010e44e55368d31ec805536';
|
|
|
|
@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'c50aafbb50f98a66e21fc069d22031351d93a0ab';
|
|
|
|
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'05dba6f9b7fe99b84234540f56ba1bf53a2a5228';
|
|
|
|
@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'26ad58fec2cb0136ece373c7f3ec89b5aafd9324';
|
|
|
|
@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(getRealTestUrl)
|
|
const getRealTestUrlProvider = GetRealTestUrlFamily._();
|
|
|
|
final class GetRealTestUrlProvider
|
|
extends $FunctionalProvider<String, String, String>
|
|
with $Provider<String> {
|
|
const GetRealTestUrlProvider._({
|
|
required GetRealTestUrlFamily super.from,
|
|
required String? super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getRealTestUrlProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getRealTestUrlHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getRealTestUrlProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<String> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
String create(Ref ref) {
|
|
final argument = this.argument as String?;
|
|
return getRealTestUrl(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 GetRealTestUrlProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getRealTestUrlHash() => r'5c6513cabb53e5e6689cba5919f49aeaeff90247';
|
|
|
|
final class GetRealTestUrlFamily extends $Family
|
|
with $FunctionalFamilyOverride<String, String?> {
|
|
const GetRealTestUrlFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getRealTestUrlProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetRealTestUrlProvider call([String? testUrl]) =>
|
|
GetRealTestUrlProvider._(argument: testUrl, from: this);
|
|
|
|
@override
|
|
String toString() => r'getRealTestUrlProvider';
|
|
}
|
|
|
|
@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'15df90fb31665501b21ea671a72e35beaf32141b';
|
|
|
|
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<SelectedMap, SelectedMap, SelectedMap>
|
|
with $Provider<SelectedMap> {
|
|
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<SelectedMap> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
SelectedMap create(Ref ref) {
|
|
return selectedMap(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(SelectedMap value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<SelectedMap>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$selectedMapHash() => r'0d7a3610d9005e74e1a88595d7e22897dc8240a5';
|
|
|
|
@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(getProfileOverrideData)
|
|
const getProfileOverrideDataProvider = GetProfileOverrideDataFamily._();
|
|
|
|
final class GetProfileOverrideDataProvider
|
|
extends $FunctionalProvider<OverrideData?, OverrideData?, OverrideData?>
|
|
with $Provider<OverrideData?> {
|
|
const GetProfileOverrideDataProvider._({
|
|
required GetProfileOverrideDataFamily super.from,
|
|
required String super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'getProfileOverrideDataProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$getProfileOverrideDataHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'getProfileOverrideDataProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<OverrideData?> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
OverrideData? create(Ref ref) {
|
|
final argument = this.argument as String;
|
|
return getProfileOverrideData(ref, argument);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(OverrideData? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<OverrideData?>(value),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
return other is GetProfileOverrideDataProvider &&
|
|
other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$getProfileOverrideDataHash() =>
|
|
r'a17ec085f1733b63b123ac08aa7737588c048c5f';
|
|
|
|
final class GetProfileOverrideDataFamily extends $Family
|
|
with $FunctionalFamilyOverride<OverrideData?, String> {
|
|
const GetProfileOverrideDataFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'getProfileOverrideDataProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
GetProfileOverrideDataProvider call(String profileId) =>
|
|
GetProfileOverrideDataProvider._(argument: profileId, from: this);
|
|
|
|
@override
|
|
String toString() => r'getProfileOverrideDataProvider';
|
|
}
|
|
|
|
@ProviderFor(layoutChange)
|
|
const layoutChangeProvider = LayoutChangeProvider._();
|
|
|
|
final class LayoutChangeProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
VM2<dynamic, dynamic>?,
|
|
VM2<dynamic, dynamic>?,
|
|
VM2<dynamic, dynamic>?
|
|
>
|
|
with $Provider<VM2<dynamic, dynamic>?> {
|
|
const LayoutChangeProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'layoutChangeProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$layoutChangeHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VM2<dynamic, dynamic>?> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
VM2<dynamic, dynamic>? create(Ref ref) {
|
|
return layoutChange(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM2<dynamic, dynamic>? value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM2<dynamic, dynamic>?>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$layoutChangeHash() => r'f25182e1dfaf3c70000404d7635bb1e1db09efbb';
|
|
|
|
@ProviderFor(checkIp)
|
|
const checkIpProvider = CheckIpProvider._();
|
|
|
|
final class CheckIpProvider
|
|
extends $FunctionalProvider<VM2<int, bool>, VM2<int, bool>, VM2<int, bool>>
|
|
with $Provider<VM2<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<VM2<int, bool>> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
VM2<int, bool> create(Ref ref) {
|
|
return checkIp(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM2<int, bool> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM2<int, bool>>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$checkIpHash() => r'07ebf8d032349e2b3adda483e68b1936ffbed68d';
|
|
|
|
@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'b18f15c938a8132ee4ed02cdfc02f3b9f01724e2';
|
|
|
|
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(needSetup)
|
|
const needSetupProvider = NeedSetupProvider._();
|
|
|
|
final class NeedSetupProvider
|
|
extends
|
|
$FunctionalProvider<
|
|
VM4<String?, String?, Dns?, bool>,
|
|
VM4<String?, String?, Dns?, bool>,
|
|
VM4<String?, String?, Dns?, bool>
|
|
>
|
|
with $Provider<VM4<String?, String?, Dns?, bool>> {
|
|
const NeedSetupProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'needSetupProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$needSetupHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<VM4<String?, String?, Dns?, bool>> $createElement(
|
|
$ProviderPointer pointer,
|
|
) => $ProviderElement(pointer);
|
|
|
|
@override
|
|
VM4<String?, String?, Dns?, bool> create(Ref ref) {
|
|
return needSetup(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(VM4<String?, String?, Dns?, bool> value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<VM4<String?, String?, Dns?, bool>>(
|
|
value,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$needSetupHash() => r'25352164c340a5fb02add21246062dd1287595fb';
|
|
|
|
@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'2e0976e079100325b1ca797285df48a94c2c066c';
|
|
|
|
@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'1d1fbf135b4b5d2a2ee984e421ccffe7c4bb0a47';
|
|
|
|
@ProviderFor(androidState)
|
|
const androidStateProvider = AndroidStateProvider._();
|
|
|
|
final class AndroidStateProvider
|
|
extends $FunctionalProvider<AndroidState, AndroidState, AndroidState>
|
|
with $Provider<AndroidState> {
|
|
const AndroidStateProvider._()
|
|
: super(
|
|
from: null,
|
|
argument: null,
|
|
retry: null,
|
|
name: r'androidStateProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$androidStateHash();
|
|
|
|
@$internal
|
|
@override
|
|
$ProviderElement<AndroidState> $createElement($ProviderPointer pointer) =>
|
|
$ProviderElement(pointer);
|
|
|
|
@override
|
|
AndroidState create(Ref ref) {
|
|
return androidState(ref);
|
|
}
|
|
|
|
/// {@macro riverpod.override_with_value}
|
|
Override overrideWithValue(AndroidState value) {
|
|
return $ProviderOverride(
|
|
origin: this,
|
|
providerOverride: $SyncValueProvider<AndroidState>(value),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _$androidStateHash() => r'9f527fbb00c7e0c177f023e77d2f23458543d72f';
|
|
|
|
@ProviderFor(Query)
|
|
const queryProvider = QueryFamily._();
|
|
|
|
final class QueryProvider extends $NotifierProvider<Query, String> {
|
|
const QueryProvider._({
|
|
required QueryFamily super.from,
|
|
required QueryTag super.argument,
|
|
}) : super(
|
|
retry: null,
|
|
name: r'queryProvider',
|
|
isAutoDispose: true,
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
);
|
|
|
|
@override
|
|
String debugGetCreateSourceHash() => _$queryHash();
|
|
|
|
@override
|
|
String toString() {
|
|
return r'queryProvider'
|
|
''
|
|
'($argument)';
|
|
}
|
|
|
|
@$internal
|
|
@override
|
|
Query create() => Query();
|
|
|
|
/// {@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 QueryProvider && other.argument == argument;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
return argument.hashCode;
|
|
}
|
|
}
|
|
|
|
String _$queryHash() => r'64c25c898d6d63f468d7e36fd591d390621c5624';
|
|
|
|
final class QueryFamily extends $Family
|
|
with $ClassFamilyOverride<Query, String, String, String, QueryTag> {
|
|
const QueryFamily._()
|
|
: super(
|
|
retry: null,
|
|
name: r'queryProvider',
|
|
dependencies: null,
|
|
$allTransitiveDependencies: null,
|
|
isAutoDispose: true,
|
|
);
|
|
|
|
QueryProvider call(QueryTag id) => QueryProvider._(argument: id, from: this);
|
|
|
|
@override
|
|
String toString() => r'queryProvider';
|
|
}
|
|
|
|
abstract class _$Query extends $Notifier<String> {
|
|
late final _$args = ref.$arg as QueryTag;
|
|
QueryTag get id => _$args;
|
|
|
|
String build(QueryTag id);
|
|
@$mustCallSuper
|
|
@override
|
|
void runBuild() {
|
|
final created = build(_$args);
|
|
final ref = this.ref as $Ref<String, String>;
|
|
final element =
|
|
ref.element
|
|
as $ClassProviderElement<
|
|
AnyNotifier<String, String>,
|
|
String,
|
|
Object?,
|
|
Object?
|
|
>;
|
|
element.handleValue(ref, created);
|
|
}
|
|
}
|