// 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(updateParams)
final updateParamsProvider = UpdateParamsProvider._();

final class UpdateParamsProvider
    extends $FunctionalProvider<UpdateParams, UpdateParams, UpdateParams>
    with $Provider<UpdateParams> {
  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'e46998c222b0902ef6a76c25fe83c094a6369036';

@ProviderFor(setupPatch)
final setupPatchProvider = SetupPatchProvider._();

final class SetupPatchProvider
    extends
        $FunctionalProvider<
          ({
            bool appendSystemDns,
            bool bypassPrivateRoute,
            PatchClashConfig patchConfig,
          }),
          ({
            bool appendSystemDns,
            bool bypassPrivateRoute,
            PatchClashConfig patchConfig,
          }),
          ({
            bool appendSystemDns,
            bool bypassPrivateRoute,
            PatchClashConfig patchConfig,
          })
        >
    with
        $Provider<
          ({
            bool appendSystemDns,
            bool bypassPrivateRoute,
            PatchClashConfig patchConfig,
          })
        > {
  SetupPatchProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'setupPatchProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$setupPatchHash();

  @$internal
  @override
  $ProviderElement<
    ({
      bool appendSystemDns,
      bool bypassPrivateRoute,
      PatchClashConfig patchConfig,
    })
  >
  $createElement($ProviderPointer pointer) => $ProviderElement(pointer);

  @override
  ({
    bool appendSystemDns,
    bool bypassPrivateRoute,
    PatchClashConfig patchConfig,
  })
  create(Ref ref) {
    return setupPatch(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(
    ({
      bool appendSystemDns,
      bool bypassPrivateRoute,
      PatchClashConfig patchConfig,
    })
    value,
  ) {
    return $ProviderOverride(
      origin: this,
      providerOverride:
          $SyncValueProvider<
            ({
              bool appendSystemDns,
              bool bypassPrivateRoute,
              PatchClashConfig patchConfig,
            })
          >(value),
    );
  }
}

String _$setupPatchHash() => r'd09fb41d40ced4cd47c9131fe55e983e35128724';

@ProviderFor(trayState)
final trayStateProvider = TrayStateProvider._();

final class TrayStateProvider
    extends $FunctionalProvider<TrayState, TrayState, TrayState>
    with $Provider<TrayState> {
  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'b7da57e41143cd8c284260d33b368b1be044bd01';

/// Measured delays of the proxies the tray lists, by group and then proxy
/// name. Resolved like a proxy card, so a nested group shows its selection.

@ProviderFor(trayDelays)
final trayDelaysProvider = TrayDelaysProvider._();

/// Measured delays of the proxies the tray lists, by group and then proxy
/// name. Resolved like a proxy card, so a nested group shows its selection.

final class TrayDelaysProvider
    extends
        $FunctionalProvider<
          Map<String, Map<String, int>>,
          Map<String, Map<String, int>>,
          Map<String, Map<String, int>>
        >
    with $Provider<Map<String, Map<String, int>>> {
  /// Measured delays of the proxies the tray lists, by group and then proxy
  /// name. Resolved like a proxy card, so a nested group shows its selection.
  TrayDelaysProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'trayDelaysProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$trayDelaysHash();

  @$internal
  @override
  $ProviderElement<Map<String, Map<String, int>>> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  Map<String, Map<String, int>> create(Ref ref) {
    return trayDelays(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(Map<String, Map<String, int>> value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<Map<String, Map<String, int>>>(
        value,
      ),
    );
  }
}

String _$trayDelaysHash() => r'266ed418b13319a7fcc6a3d8307b6786f6ce89bf';

@ProviderFor(trayTitleState)
final trayTitleStateProvider = TrayTitleStateProvider._();

final class TrayTitleStateProvider
    extends $FunctionalProvider<TrayTitleState, TrayTitleState, TrayTitleState>
    with $Provider<TrayTitleState> {
  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'aacf3779c879f7f1144484a80043679020bf8424';

@ProviderFor(getHotKeyAction)
final getHotKeyActionProvider = GetHotKeyActionFamily._();

final class GetHotKeyActionProvider
    extends $FunctionalProvider<HotKeyAction, HotKeyAction, HotKeyAction>
    with $Provider<HotKeyAction> {
  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> {
  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(shouldPatchSystemDns)
final shouldPatchSystemDnsProvider = ShouldPatchSystemDnsProvider._();

final class ShouldPatchSystemDnsProvider
    extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  ShouldPatchSystemDnsProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'shouldPatchSystemDnsProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$shouldPatchSystemDnsHash();

  @$internal
  @override
  $ProviderElement<bool> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  bool create(Ref ref) {
    return shouldPatchSystemDns(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(bool value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<bool>(value),
    );
  }
}

String _$shouldPatchSystemDnsHash() =>
    r'f74bcdbae504e9528b2e960b8620d097c27f3ca9';

@ProviderFor(sharedState)
final sharedStateProvider = SharedStateProvider._();

final class SharedStateProvider
    extends $FunctionalProvider<SharedState, SharedState, SharedState>
    with $Provider<SharedState> {
  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'1aeb51f6a7b6082f5df2a1942f45ec6c2abce606';

@ProviderFor(vpnRouteAddress)
final vpnRouteAddressProvider = VpnRouteAddressProvider._();

final class VpnRouteAddressProvider
    extends
        $FunctionalProvider<
          AsyncValue<List<String>>,
          List<String>,
          FutureOr<List<String>>
        >
    with $FutureModifier<List<String>>, $FutureProvider<List<String>> {
  VpnRouteAddressProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'vpnRouteAddressProvider',
        isAutoDispose: false,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$vpnRouteAddressHash();

  @$internal
  @override
  $FutureProviderElement<List<String>> $createElement(
    $ProviderPointer pointer,
  ) => $FutureProviderElement(pointer);

  @override
  FutureOr<List<String>> create(Ref ref) {
    return vpnRouteAddress(ref);
  }
}

String _$vpnRouteAddressHash() => r'bae2530b73b71ecff16aadfc395e60996d739d41';

@ProviderFor(vpnOptions)
final vpnOptionsProvider = VpnOptionsProvider._();

final class VpnOptionsProvider
    extends
        $FunctionalProvider<
          AsyncValue<VpnOptions>,
          VpnOptions,
          FutureOr<VpnOptions>
        >
    with $FutureModifier<VpnOptions>, $FutureProvider<VpnOptions> {
  VpnOptionsProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'vpnOptionsProvider',
        isAutoDispose: false,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$vpnOptionsHash();

  @$internal
  @override
  $FutureProviderElement<VpnOptions> $createElement($ProviderPointer pointer) =>
      $FutureProviderElement(pointer);

  @override
  FutureOr<VpnOptions> create(Ref ref) {
    return vpnOptions(ref);
  }
}

String _$vpnOptionsHash() => r'c00e87278b32dd8977ed136aace10dccfe05508d';

@ProviderFor(AccessControlState)
final accessControlStateProvider = AccessControlStateProvider._();

final class AccessControlStateProvider
    extends $NotifierProvider<AccessControlState, AccessControlProps> {
  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'a496770f99975b1bcd7f3f50c55f50726971c749';

abstract class _$AccessControlState extends $Notifier<AccessControlProps> {
  AccessControlProps build();
  @$mustCallSuper
  @override
  WhenComplete runBuild() {
    final ref = this.ref as $Ref<AccessControlProps, AccessControlProps>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<AccessControlProps, AccessControlProps>,
              AccessControlProps,
              Object?,
              Object?
            >;
    return element.handleCreate(ref, build);
  }
}

@ProviderFor(suspend)
final suspendProvider = SuspendProvider._();

final class SuspendProvider extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  SuspendProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'suspendProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$suspendHash();

  @$internal
  @override
  $ProviderElement<bool> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  bool create(Ref ref) {
    return suspend(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(bool value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<bool>(value),
    );
  }
}

String _$suspendHash() => r'9ab9210f4f3c70f63d9858d492a9c09b3fb24bf1';

@ProviderFor(DynamicColor)
final dynamicColorProvider = DynamicColorProvider._();

final class DynamicColorProvider
    extends $NotifierProvider<DynamicColor, DynamicColorSeeds> {
  DynamicColorProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'dynamicColorProvider',
        isAutoDispose: false,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$dynamicColorHash();

  @$internal
  @override
  DynamicColor create() => DynamicColor();

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(DynamicColorSeeds value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<DynamicColorSeeds>(value),
    );
  }
}

String _$dynamicColorHash() => r'6706bed0ee92072cc5b2847d5504be55d3d51f10';

abstract class _$DynamicColor extends $Notifier<DynamicColorSeeds> {
  DynamicColorSeeds build();
  @$mustCallSuper
  @override
  WhenComplete runBuild() {
    final ref = this.ref as $Ref<DynamicColorSeeds, DynamicColorSeeds>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<DynamicColorSeeds, DynamicColorSeeds>,
              DynamicColorSeeds,
              Object?,
              Object?
            >;
    return element.handleCreate(ref, build);
  }
}

@ProviderFor(genColorScheme)
final genColorSchemeProvider = GenColorSchemeFamily._();

final class GenColorSchemeProvider
    extends $FunctionalProvider<ColorScheme, ColorScheme, ColorScheme>
    with $Provider<ColorScheme> {
  GenColorSchemeProvider._({
    required GenColorSchemeFamily super.from,
    required (Brightness, {Color? color, bool ignoreConfig, bool? pureBlack})
    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, bool? pureBlack});
    return genColorScheme(
      ref,
      argument.$1,
      color: argument.color,
      ignoreConfig: argument.ignoreConfig,
      pureBlack: argument.pureBlack,
    );
  }

  /// {@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'c6838e224d41780617f7338c5e56173a7620cd87';

final class GenColorSchemeFamily extends $Family
    with
        $FunctionalFamilyOverride<
          ColorScheme,
          (Brightness, {Color? color, bool ignoreConfig, bool? pureBlack})
        > {
  GenColorSchemeFamily._()
    : super(
        retry: null,
        name: r'genColorSchemeProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  GenColorSchemeProvider call(
    Brightness brightness, {
    Color? color,
    bool ignoreConfig = false,
    bool? pureBlack,
  }) => GenColorSchemeProvider._(
    argument: (
      brightness,
      color: color,
      ignoreConfig: ignoreConfig,
      pureBlack: pureBlack,
    ),
    from: this,
  );

  @override
  String toString() => r'genColorSchemeProvider';
}

@ProviderFor(windowBlurRequest)
final windowBlurRequestProvider = WindowBlurRequestProvider._();

final class WindowBlurRequestProvider
    extends
        $FunctionalProvider<
          WindowBlurRequest,
          WindowBlurRequest,
          WindowBlurRequest
        >
    with $Provider<WindowBlurRequest> {
  WindowBlurRequestProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'windowBlurRequestProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$windowBlurRequestHash();

  @$internal
  @override
  $ProviderElement<WindowBlurRequest> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  WindowBlurRequest create(Ref ref) {
    return windowBlurRequest(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(WindowBlurRequest value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<WindowBlurRequest>(value),
    );
  }
}

String _$windowBlurRequestHash() => r'e22ea22957373c5b864e3fb80af56a2d08646666';

@ProviderFor(currentBrightness)
final currentBrightnessProvider = CurrentBrightnessProvider._();

final class CurrentBrightnessProvider
    extends $FunctionalProvider<Brightness, Brightness, Brightness>
    with $Provider<Brightness> {
  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(appProviderNames)
final appProviderNamesProvider = AppProviderNamesFamily._();

final class AppProviderNamesProvider
    extends $FunctionalProvider<Set<String>, Set<String>, Set<String>>
    with $Provider<Set<String>> {
  AppProviderNamesProvider._({
    required AppProviderNamesFamily super.from,
    required ProviderKind super.argument,
  }) : super(
         retry: null,
         name: r'appProviderNamesProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$appProviderNamesHash();

  @override
  String toString() {
    return r'appProviderNamesProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $ProviderElement<Set<String>> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  Set<String> create(Ref ref) {
    final argument = this.argument as ProviderKind;
    return appProviderNames(ref, argument);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(Set<String> value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<Set<String>>(value),
    );
  }

  @override
  bool operator ==(Object other) {
    return other is AppProviderNamesProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$appProviderNamesHash() => r'f4c925a4d3c8f0c613a1b84eaba4ad7e6a1b7a35';

final class AppProviderNamesFamily extends $Family
    with $FunctionalFamilyOverride<Set<String>, ProviderKind> {
  AppProviderNamesFamily._()
    : super(
        retry: null,
        name: r'appProviderNamesProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  AppProviderNamesProvider call(ProviderKind kind) =>
      AppProviderNamesProvider._(argument: kind, from: this);

  @override
  String toString() => r'appProviderNamesProvider';
}

/// Null until every source loads, so no check reads a loading one as empty.

@ProviderFor(customProfileData)
final customProfileDataProvider = CustomProfileDataFamily._();

/// Null until every source loads, so no check reads a loading one as empty.

final class CustomProfileDataProvider
    extends
        $FunctionalProvider<
          CustomProfileData?,
          CustomProfileData?,
          CustomProfileData?
        >
    with $Provider<CustomProfileData?> {
  /// Null until every source loads, so no check reads a loading one as empty.
  CustomProfileDataProvider._({
    required CustomProfileDataFamily super.from,
    required int super.argument,
  }) : super(
         retry: null,
         name: r'customProfileDataProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$customProfileDataHash();

  @override
  String toString() {
    return r'customProfileDataProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $ProviderElement<CustomProfileData?> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  CustomProfileData? create(Ref ref) {
    final argument = this.argument as int;
    return customProfileData(ref, argument);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(CustomProfileData? value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<CustomProfileData?>(value),
    );
  }

  @override
  bool operator ==(Object other) {
    return other is CustomProfileDataProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$customProfileDataHash() => r'ac6ab2c3e19ae2724704bfbda1b8751867219e2b';

/// Null until every source loads, so no check reads a loading one as empty.

final class CustomProfileDataFamily extends $Family
    with $FunctionalFamilyOverride<CustomProfileData?, int> {
  CustomProfileDataFamily._()
    : super(
        retry: null,
        name: r'customProfileDataProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  /// Null until every source loads, so no check reads a loading one as empty.

  CustomProfileDataProvider call(int profileId) =>
      CustomProfileDataProvider._(argument: profileId, from: this);

  @override
  String toString() => r'customProfileDataProvider';
}

@ProviderFor(customProfileTargetIsValid)
final customProfileTargetIsValidProvider = CustomProfileTargetIsValidFamily._();

final class CustomProfileTargetIsValidProvider
    extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  CustomProfileTargetIsValidProvider._({
    required CustomProfileTargetIsValidFamily super.from,
    required (int, String?) super.argument,
  }) : super(
         retry: null,
         name: r'customProfileTargetIsValidProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$customProfileTargetIsValidHash();

  @override
  String toString() {
    return r'customProfileTargetIsValidProvider'
        ''
        '$argument';
  }

  @$internal
  @override
  $ProviderElement<bool> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  bool create(Ref ref) {
    final argument = this.argument as (int, String?);
    return customProfileTargetIsValid(ref, argument.$1, argument.$2);
  }

  /// {@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 CustomProfileTargetIsValidProvider &&
        other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$customProfileTargetIsValidHash() =>
    r'f4326b61db17dca240a70a4251e66e90bbbaa68a';

final class CustomProfileTargetIsValidFamily extends $Family
    with $FunctionalFamilyOverride<bool, (int, String?)> {
  CustomProfileTargetIsValidFamily._()
    : super(
        retry: null,
        name: r'customProfileTargetIsValidProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  CustomProfileTargetIsValidProvider call(int profileId, String? target) =>
      CustomProfileTargetIsValidProvider._(
        argument: (profileId, target),
        from: this,
      );

  @override
  String toString() => r'customProfileTargetIsValidProvider';
}

@ProviderFor(customProfileProxyProviderIsValid)
final customProfileProxyProviderIsValidProvider =
    CustomProfileProxyProviderIsValidFamily._();

final class CustomProfileProxyProviderIsValidProvider
    extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  CustomProfileProxyProviderIsValidProvider._({
    required CustomProfileProxyProviderIsValidFamily super.from,
    required (int, String?) super.argument,
  }) : super(
         retry: null,
         name: r'customProfileProxyProviderIsValidProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() =>
      _$customProfileProxyProviderIsValidHash();

  @override
  String toString() {
    return r'customProfileProxyProviderIsValidProvider'
        ''
        '$argument';
  }

  @$internal
  @override
  $ProviderElement<bool> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  bool create(Ref ref) {
    final argument = this.argument as (int, String?);
    return customProfileProxyProviderIsValid(ref, argument.$1, argument.$2);
  }

  /// {@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 CustomProfileProxyProviderIsValidProvider &&
        other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$customProfileProxyProviderIsValidHash() =>
    r'85354503656de3faa3ecddfc0e3fcdecc8062eeb';

final class CustomProfileProxyProviderIsValidFamily extends $Family
    with $FunctionalFamilyOverride<bool, (int, String?)> {
  CustomProfileProxyProviderIsValidFamily._()
    : super(
        retry: null,
        name: r'customProfileProxyProviderIsValidProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  CustomProfileProxyProviderIsValidProvider call(
    int profileId,
    String? providerName,
  ) => CustomProfileProxyProviderIsValidProvider._(
    argument: (profileId, providerName),
    from: this,
  );

  @override
  String toString() => r'customProfileProxyProviderIsValidProvider';
}

@ProviderFor(customProfileRuleProviderIsValid)
final customProfileRuleProviderIsValidProvider =
    CustomProfileRuleProviderIsValidFamily._();

final class CustomProfileRuleProviderIsValidProvider
    extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  CustomProfileRuleProviderIsValidProvider._({
    required CustomProfileRuleProviderIsValidFamily super.from,
    required (int, String?) super.argument,
  }) : super(
         retry: null,
         name: r'customProfileRuleProviderIsValidProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$customProfileRuleProviderIsValidHash();

  @override
  String toString() {
    return r'customProfileRuleProviderIsValidProvider'
        ''
        '$argument';
  }

  @$internal
  @override
  $ProviderElement<bool> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  bool create(Ref ref) {
    final argument = this.argument as (int, String?);
    return customProfileRuleProviderIsValid(ref, argument.$1, argument.$2);
  }

  /// {@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 CustomProfileRuleProviderIsValidProvider &&
        other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$customProfileRuleProviderIsValidHash() =>
    r'723492065473a91be8349283a0517044e91928f4';

final class CustomProfileRuleProviderIsValidFamily extends $Family
    with $FunctionalFamilyOverride<bool, (int, String?)> {
  CustomProfileRuleProviderIsValidFamily._()
    : super(
        retry: null,
        name: r'customProfileRuleProviderIsValidProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  CustomProfileRuleProviderIsValidProvider call(
    int profileId,
    String? providerName,
  ) => CustomProfileRuleProviderIsValidProvider._(
    argument: (profileId, providerName),
    from: this,
  );

  @override
  String toString() => r'customProfileRuleProviderIsValidProvider';
}

/// Lives with the list, as a verdict can rest on a file such as an ssh key.

@ProviderFor(customProxyVerdicts)
final customProxyVerdictsProvider = CustomProxyVerdictsProvider._();

/// Lives with the list, as a verdict can rest on a file such as an ssh key.

final class CustomProxyVerdictsProvider
    extends
        $FunctionalProvider<
          Map<Map<String, dynamic>, String>,
          Map<Map<String, dynamic>, String>,
          Map<Map<String, dynamic>, String>
        >
    with $Provider<Map<Map<String, dynamic>, String>> {
  /// Lives with the list, as a verdict can rest on a file such as an ssh key.
  CustomProxyVerdictsProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'customProxyVerdictsProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$customProxyVerdictsHash();

  @$internal
  @override
  $ProviderElement<Map<Map<String, dynamic>, String>> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  Map<Map<String, dynamic>, String> create(Ref ref) {
    return customProxyVerdicts(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(Map<Map<String, dynamic>, String> value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<Map<Map<String, dynamic>, String>>(
        value,
      ),
    );
  }
}

String _$customProxyVerdictsHash() =>
    r'786c59c6c38427fb043ef4cba2889e54d4cbca58';

@ProviderFor(customProxyCoreErrors)
final customProxyCoreErrorsProvider = CustomProxyCoreErrorsProvider._();

final class CustomProxyCoreErrorsProvider
    extends
        $FunctionalProvider<
          AsyncValue<Map<int, String>>,
          Map<int, String>,
          FutureOr<Map<int, String>>
        >
    with $FutureModifier<Map<int, String>>, $FutureProvider<Map<int, String>> {
  CustomProxyCoreErrorsProvider._()
    : super(
        from: null,
        argument: null,
        retry: _noRetry,
        name: r'customProxyCoreErrorsProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$customProxyCoreErrorsHash();

  @$internal
  @override
  $FutureProviderElement<Map<int, String>> $createElement(
    $ProviderPointer pointer,
  ) => $FutureProviderElement(pointer);

  @override
  FutureOr<Map<int, String>> create(Ref ref) {
    return customProxyCoreErrors(ref);
  }
}

String _$customProxyCoreErrorsHash() =>
    r'a5d5015b5e8ed8d7591bca190a5c242073020a70';

@ProviderFor(customProxyListIssues)
final customProxyListIssuesProvider = CustomProxyListIssuesProvider._();

final class CustomProxyListIssuesProvider
    extends
        $FunctionalProvider<
          Map<int, List<CustomIssue>>,
          Map<int, List<CustomIssue>>,
          Map<int, List<CustomIssue>>
        >
    with $Provider<Map<int, List<CustomIssue>>> {
  CustomProxyListIssuesProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'customProxyListIssuesProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$customProxyListIssuesHash();

  @$internal
  @override
  $ProviderElement<Map<int, List<CustomIssue>>> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  Map<int, List<CustomIssue>> create(Ref ref) {
    return customProxyListIssues(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(Map<int, List<CustomIssue>> value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<Map<int, List<CustomIssue>>>(value),
    );
  }
}

String _$customProxyListIssuesHash() =>
    r'6395fed58b3706e97243ec974bbb7d8a6ab5496f';

@ProviderFor(customProfileIssues)
final customProfileIssuesProvider = CustomProfileIssuesFamily._();

final class CustomProfileIssuesProvider
    extends
        $FunctionalProvider<
          CustomProfileIssues,
          CustomProfileIssues,
          CustomProfileIssues
        >
    with $Provider<CustomProfileIssues> {
  CustomProfileIssuesProvider._({
    required CustomProfileIssuesFamily super.from,
    required int super.argument,
  }) : super(
         retry: null,
         name: r'customProfileIssuesProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$customProfileIssuesHash();

  @override
  String toString() {
    return r'customProfileIssuesProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $ProviderElement<CustomProfileIssues> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  CustomProfileIssues create(Ref ref) {
    final argument = this.argument as int;
    return customProfileIssues(ref, argument);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(CustomProfileIssues value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<CustomProfileIssues>(value),
    );
  }

  @override
  bool operator ==(Object other) {
    return other is CustomProfileIssuesProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$customProfileIssuesHash() =>
    r'39501e79bff4c6dad1d454d5becbecd8bfaaa462';

final class CustomProfileIssuesFamily extends $Family
    with $FunctionalFamilyOverride<CustomProfileIssues, int> {
  CustomProfileIssuesFamily._()
    : super(
        retry: null,
        name: r'customProfileIssuesProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  CustomProfileIssuesProvider call(int profileId) =>
      CustomProfileIssuesProvider._(argument: profileId, from: this);

  @override
  String toString() => r'customProfileIssuesProvider';
}

@ProviderFor(ProxyGroupProvider)
final proxyGroupProvider = ProxyGroupProviderProvider._();

final class ProxyGroupProviderProvider
    extends $NotifierProvider<ProxyGroupProvider, ProxyGroup> {
  ProxyGroupProviderProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'proxyGroupProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$proxyGroupProviderHash();

  @$internal
  @override
  ProxyGroupProvider create() => ProxyGroupProvider();

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(ProxyGroup value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<ProxyGroup>(value),
    );
  }
}

String _$proxyGroupProviderHash() =>
    r'26169a4a0ce5bbe3f0a51f7e79326ce29ec8c5bb';

abstract class _$ProxyGroupProvider extends $Notifier<ProxyGroup> {
  ProxyGroup build();
  @$mustCallSuper
  @override
  WhenComplete runBuild() {
    final ref = this.ref as $Ref<ProxyGroup, ProxyGroup>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<ProxyGroup, ProxyGroup>,
              ProxyGroup,
              Object?,
              Object?
            >;
    return element.handleCreate(ref, build);
  }
}

@ProviderFor(CustomProxyProvider)
final customProxyProvider = CustomProxyProviderProvider._();

final class CustomProxyProviderProvider
    extends $NotifierProvider<CustomProxyProvider, CustomProxy> {
  CustomProxyProviderProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'customProxyProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$customProxyProviderHash();

  @$internal
  @override
  CustomProxyProvider create() => CustomProxyProvider();

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(CustomProxy value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<CustomProxy>(value),
    );
  }
}

String _$customProxyProviderHash() =>
    r'1c6023c816671f343956d5d23423dfcb921e1eab';

abstract class _$CustomProxyProvider extends $Notifier<CustomProxy> {
  CustomProxy build();
  @$mustCallSuper
  @override
  WhenComplete runBuild() {
    final ref = this.ref as $Ref<CustomProxy, CustomProxy>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<CustomProxy, CustomProxy>,
              CustomProxy,
              Object?,
              Object?
            >;
    return element.handleCreate(ref, build);
  }
}

@ProviderFor(ProxyProviderOptionsProvider)
final proxyProviderOptionsProvider = ProxyProviderOptionsProviderProvider._();

final class ProxyProviderOptionsProviderProvider
    extends
        $NotifierProvider<ProxyProviderOptionsProvider, ProxyProviderOptions> {
  ProxyProviderOptionsProviderProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'proxyProviderOptionsProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$proxyProviderOptionsProviderHash();

  @$internal
  @override
  ProxyProviderOptionsProvider create() => ProxyProviderOptionsProvider();

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(ProxyProviderOptions value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<ProxyProviderOptions>(value),
    );
  }
}

String _$proxyProviderOptionsProviderHash() =>
    r'24b5e2be43820d83cc0b99c2bf0f468cdc9906a5';

abstract class _$ProxyProviderOptionsProvider
    extends $Notifier<ProxyProviderOptions> {
  ProxyProviderOptions build();
  @$mustCallSuper
  @override
  WhenComplete runBuild() {
    final ref = this.ref as $Ref<ProxyProviderOptions, ProxyProviderOptions>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<ProxyProviderOptions, ProxyProviderOptions>,
              ProxyProviderOptions,
              Object?,
              Object?
            >;
    return element.handleCreate(ref, build);
  }
}

@ProviderFor(RuleProvider)
final ruleProvider = RuleProviderProvider._();

final class RuleProviderProvider extends $NotifierProvider<RuleProvider, Rule> {
  RuleProviderProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'ruleProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$ruleProviderHash();

  @$internal
  @override
  RuleProvider create() => RuleProvider();

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(Rule value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<Rule>(value),
    );
  }
}

String _$ruleProviderHash() => r'e5917672a4a22745719f3b6b6726fb1135f6a19e';

abstract class _$RuleProvider extends $Notifier<Rule> {
  Rule build();
  @$mustCallSuper
  @override
  WhenComplete runBuild() {
    final ref = this.ref as $Ref<Rule, Rule>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<Rule, Rule>,
              Rule,
              Object?,
              Object?
            >;
    return element.handleCreate(ref, build);
  }
}

@ProviderFor(currentGroupsState)
final currentGroupsStateProvider = CurrentGroupsStateProvider._();

final class CurrentGroupsStateProvider
    extends $FunctionalProvider<GroupsState, GroupsState, GroupsState>
    with $Provider<GroupsState> {
  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'd4ea3c3271a77d8bd791f94c697cc94a41fff38f';

@ProviderFor(proxyState)
final proxyStateProvider = ProxyStateProvider._();

final class ProxyStateProvider
    extends $FunctionalProvider<ProxyState, ProxyState, ProxyState>
    with $Provider<ProxyState> {
  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'76a71ab5da07dca9aeb351282c5c03ab222d0760';

/// Watching the delay map instead would drop nodes one probe at a time, and
/// reading it on any other rebuild would drop them whenever something
/// unrelated changed mid-test.

@ProviderFor(delaysAtLastTestBatch)
final delaysAtLastTestBatchProvider = DelaysAtLastTestBatchProvider._();

/// Watching the delay map instead would drop nodes one probe at a time, and
/// reading it on any other rebuild would drop them whenever something
/// unrelated changed mid-test.

final class DelaysAtLastTestBatchProvider
    extends $FunctionalProvider<DelayMap, DelayMap, DelayMap>
    with $Provider<DelayMap> {
  /// Watching the delay map instead would drop nodes one probe at a time, and
  /// reading it on any other rebuild would drop them whenever something
  /// unrelated changed mid-test.
  DelaysAtLastTestBatchProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'delaysAtLastTestBatchProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$delaysAtLastTestBatchHash();

  @$internal
  @override
  $ProviderElement<DelayMap> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  DelayMap create(Ref ref) {
    return delaysAtLastTestBatch(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(DelayMap value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<DelayMap>(value),
    );
  }
}

String _$delaysAtLastTestBatchHash() =>
    r'830e4b670d6a0ffa5ea8edc112a1d591a5adfaec';

@ProviderFor(visibleGroupsState)
final visibleGroupsStateProvider = VisibleGroupsStateProvider._();

final class VisibleGroupsStateProvider
    extends $FunctionalProvider<GroupsState, GroupsState, GroupsState>
    with $Provider<GroupsState> {
  VisibleGroupsStateProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'visibleGroupsStateProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$visibleGroupsStateHash();

  @$internal
  @override
  $ProviderElement<GroupsState> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  GroupsState create(Ref ref) {
    return visibleGroupsState(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(GroupsState value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<GroupsState>(value),
    );
  }
}

String _$visibleGroupsStateHash() =>
    r'b9f560285e114ebb98625daeb3fe418926e2e9c2';

/// Searches before hiding, so a group whose matches all timed out keeps them,
/// and with them its delay test, instead of dropping out of the results.

@ProviderFor(filterGroupsState)
final filterGroupsStateProvider = FilterGroupsStateFamily._();

/// Searches before hiding, so a group whose matches all timed out keeps them,
/// and with them its delay test, instead of dropping out of the results.

final class FilterGroupsStateProvider
    extends $FunctionalProvider<GroupsState, GroupsState, GroupsState>
    with $Provider<GroupsState> {
  /// Searches before hiding, so a group whose matches all timed out keeps them,
  /// and with them its delay test, instead of dropping out of the results.
  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'd27c043b7647ce7f6182f2e5d4a880d987d2d5af';

/// Searches before hiding, so a group whose matches all timed out keeps them,
/// and with them its delay test, instead of dropping out of the results.

final class FilterGroupsStateFamily extends $Family
    with $FunctionalFamilyOverride<GroupsState, String> {
  FilterGroupsStateFamily._()
    : super(
        retry: null,
        name: r'filterGroupsStateProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  /// Searches before hiding, so a group whose matches all timed out keeps them,
  /// and with them its delay test, instead of dropping out of the results.

  FilterGroupsStateProvider call(String query) =>
      FilterGroupsStateProvider._(argument: query, from: this);

  @override
  String toString() => r'filterGroupsStateProvider';
}

@ProviderFor(proxiesListState)
final proxiesListStateProvider = ProxiesListStateProvider._();

final class ProxiesListStateProvider
    extends
        $FunctionalProvider<
          ProxiesListState,
          ProxiesListState,
          ProxiesListState
        >
    with $Provider<ProxiesListState> {
  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'212d21f79e9c149076e13d1d19ccd83ccb4b471b';

@ProviderFor(proxiesTabState)
final proxiesTabStateProvider = ProxiesTabStateProvider._();

final class ProxiesTabStateProvider
    extends
        $FunctionalProvider<ProxiesTabState, ProxiesTabState, ProxiesTabState>
    with $Provider<ProxiesTabState> {
  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'e4eccd77c3848489c8ec620f4e515cec7cdd5a31';

@ProviderFor(isStart)
final isStartProvider = IsStartProvider._();

final class IsStartProvider extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  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)
final proxiesTabControllerStateProvider = ProxiesTabControllerStateProvider._();

final class ProxiesTabControllerStateProvider
    extends
        $FunctionalProvider<
          ProxiesTabControllerState,
          ProxiesTabControllerState,
          ProxiesTabControllerState
        >
    with $Provider<ProxiesTabControllerState> {
  ProxiesTabControllerStateProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'proxiesTabControllerStateProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$proxiesTabControllerStateHash();

  @$internal
  @override
  $ProviderElement<ProxiesTabControllerState> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  ProxiesTabControllerState create(Ref ref) {
    return proxiesTabControllerState(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(ProxiesTabControllerState value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<ProxiesTabControllerState>(value),
    );
  }
}

String _$proxiesTabControllerStateHash() =>
    r'548db61efef2c47c2694c855436276fcd3529956';

@ProviderFor(realTestUrl)
final realTestUrlProvider = RealTestUrlFamily._();

final class RealTestUrlProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  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?> {
  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(delay)
final delayProvider = DelayFamily._();

final class DelayProvider extends $FunctionalProvider<int?, int?, int?>
    with $Provider<int?> {
  DelayProvider._({
    required DelayFamily super.from,
    required ({String proxyName, String? testUrl}) super.argument,
  }) : super(
         retry: null,
         name: r'delayProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$delayHash();

  @override
  String toString() {
    return r'delayProvider'
        ''
        '$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 delay(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 DelayProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$delayHash() => r'3cbaa758ea602519d2958a4e413c705b062bce32';

final class DelayFamily extends $Family
    with
        $FunctionalFamilyOverride<int?, ({String proxyName, String? testUrl})> {
  DelayFamily._()
    : super(
        retry: null,
        name: r'delayProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  DelayProvider call({required String proxyName, String? testUrl}) =>
      DelayProvider._(
        argument: (proxyName: proxyName, testUrl: testUrl),
        from: this,
      );

  @override
  String toString() => r'delayProvider';
}

@ProviderFor(delayTestPhase)
final delayTestPhaseProvider = DelayTestPhaseFamily._();

final class DelayTestPhaseProvider
    extends
        $FunctionalProvider<DelayTestPhase?, DelayTestPhase?, DelayTestPhase?>
    with $Provider<DelayTestPhase?> {
  DelayTestPhaseProvider._({
    required DelayTestPhaseFamily super.from,
    required ({String proxyName, String? testUrl}) super.argument,
  }) : super(
         retry: null,
         name: r'delayTestPhaseProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$delayTestPhaseHash();

  @override
  String toString() {
    return r'delayTestPhaseProvider'
        ''
        '$argument';
  }

  @$internal
  @override
  $ProviderElement<DelayTestPhase?> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  DelayTestPhase? create(Ref ref) {
    final argument = this.argument as ({String proxyName, String? testUrl});
    return delayTestPhase(
      ref,
      proxyName: argument.proxyName,
      testUrl: argument.testUrl,
    );
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(DelayTestPhase? value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<DelayTestPhase?>(value),
    );
  }

  @override
  bool operator ==(Object other) {
    return other is DelayTestPhaseProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$delayTestPhaseHash() => r'e757e70a0e180c01a4e660e1f16ce77a4547f4cf';

final class DelayTestPhaseFamily extends $Family
    with
        $FunctionalFamilyOverride<
          DelayTestPhase?,
          ({String proxyName, String? testUrl})
        > {
  DelayTestPhaseFamily._()
    : super(
        retry: null,
        name: r'delayTestPhaseProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  DelayTestPhaseProvider call({required String proxyName, String? testUrl}) =>
      DelayTestPhaseProvider._(
        argument: (proxyName: proxyName, testUrl: testUrl),
        from: this,
      );

  @override
  String toString() => r'delayTestPhaseProvider';
}

@ProviderFor(selectedMap)
final selectedMapProvider = SelectedMapProvider._();

final class SelectedMapProvider
    extends
        $FunctionalProvider<
          Map<String, String>,
          Map<String, String>,
          Map<String, String>
        >
    with $Provider<Map<String, String>> {
  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)
final unfoldSetProvider = UnfoldSetProvider._();

final class UnfoldSetProvider
    extends $FunctionalProvider<Set<String>, Set<String>, Set<String>>
    with $Provider<Set<String>> {
  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(realSelectedProxyState)
final realSelectedProxyStateProvider = RealSelectedProxyStateFamily._();

final class RealSelectedProxyStateProvider
    extends
        $FunctionalProvider<
          SelectedProxyState,
          SelectedProxyState,
          SelectedProxyState
        >
    with $Provider<SelectedProxyState> {
  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> {
  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(proxyName)
final proxyNameProvider = ProxyNameFamily._();

final class ProxyNameProvider
    extends $FunctionalProvider<String?, String?, String?>
    with $Provider<String?> {
  ProxyNameProvider._({
    required ProxyNameFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'proxyNameProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$proxyNameHash();

  @override
  String toString() {
    return r'proxyNameProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $ProviderElement<String?> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  String? create(Ref ref) {
    final argument = this.argument as String;
    return proxyName(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 ProxyNameProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$proxyNameHash() => r'a34d43762ff87d7ccd504a7e9ab66a25396b529f';

final class ProxyNameFamily extends $Family
    with $FunctionalFamilyOverride<String?, String> {
  ProxyNameFamily._()
    : super(
        retry: null,
        name: r'proxyNameProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  ProxyNameProvider call(String groupName) =>
      ProxyNameProvider._(argument: groupName, from: this);

  @override
  String toString() => r'proxyNameProvider';
}

@ProviderFor(selectedProxyName)
final selectedProxyNameProvider = SelectedProxyNameFamily._();

final class SelectedProxyNameProvider
    extends $FunctionalProvider<String?, String?, String?>
    with $Provider<String?> {
  SelectedProxyNameProvider._({
    required SelectedProxyNameFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'selectedProxyNameProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$selectedProxyNameHash();

  @override
  String toString() {
    return r'selectedProxyNameProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $ProviderElement<String?> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  String? create(Ref ref) {
    final argument = this.argument as String;
    return selectedProxyName(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 SelectedProxyNameProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$selectedProxyNameHash() => r'417c99385108d630b7cc8aaa3e94abd7011cbc58';

final class SelectedProxyNameFamily extends $Family
    with $FunctionalFamilyOverride<String?, String> {
  SelectedProxyNameFamily._()
    : super(
        retry: null,
        name: r'selectedProxyNameProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  SelectedProxyNameProvider call(String groupName) =>
      SelectedProxyNameProvider._(argument: groupName, from: this);

  @override
  String toString() => r'selectedProxyNameProvider';
}

@ProviderFor(needUpdateGroups)
final needUpdateGroupsProvider = NeedUpdateGroupsProvider._();

final class NeedUpdateGroupsProvider
    extends
        $FunctionalProvider<
          ({bool isProxies, int sortNum, ProxiesSortType sortType}),
          ({bool isProxies, int sortNum, ProxiesSortType sortType}),
          ({bool isProxies, int sortNum, ProxiesSortType sortType})
        >
    with $Provider<({bool isProxies, int sortNum, ProxiesSortType sortType})> {
  NeedUpdateGroupsProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'needUpdateGroupsProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$needUpdateGroupsHash();

  @$internal
  @override
  $ProviderElement<({bool isProxies, int sortNum, ProxiesSortType sortType})>
  $createElement($ProviderPointer pointer) => $ProviderElement(pointer);

  @override
  ({bool isProxies, int sortNum, ProxiesSortType sortType}) create(Ref ref) {
    return needUpdateGroups(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(
    ({bool isProxies, int sortNum, ProxiesSortType sortType}) value,
  ) {
    return $ProviderOverride(
      origin: this,
      providerOverride:
          $SyncValueProvider<
            ({bool isProxies, int sortNum, ProxiesSortType sortType})
          >(value),
    );
  }
}

String _$needUpdateGroupsHash() => r'90b7cb35c96bda157cf436e32f251e58721ef757';

@ProviderFor(navigationItemsState)
final navigationItemsStateProvider = NavigationItemsStateProvider._();

final class NavigationItemsStateProvider
    extends
        $FunctionalProvider<
          NavigationItemsState,
          NavigationItemsState,
          NavigationItemsState
        >
    with $Provider<NavigationItemsState> {
  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'3c633d4f3e5f2e80b7cfd166a46397f9a207bb1e';

@ProviderFor(currentNavigationItemsState)
final currentNavigationItemsStateProvider =
    CurrentNavigationItemsStateProvider._();

final class CurrentNavigationItemsStateProvider
    extends
        $FunctionalProvider<
          NavigationItemsState,
          NavigationItemsState,
          NavigationItemsState
        >
    with $Provider<NavigationItemsState> {
  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(shownPageLabel)
final shownPageLabelProvider = ShownPageLabelProvider._();

final class ShownPageLabelProvider
    extends $FunctionalProvider<PageLabel, PageLabel, PageLabel>
    with $Provider<PageLabel> {
  ShownPageLabelProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'shownPageLabelProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$shownPageLabelHash();

  @$internal
  @override
  $ProviderElement<PageLabel> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  PageLabel create(Ref ref) {
    return shownPageLabel(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(PageLabel value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<PageLabel>(value),
    );
  }
}

String _$shownPageLabelHash() => r'1378d52f1b4cb8fc3291b3e76f2ce2c4e23bfe0e';

@ProviderFor(navigationState)
final navigationStateProvider = NavigationStateProvider._();

final class NavigationStateProvider
    extends
        $FunctionalProvider<NavigationState, NavigationState, NavigationState>
    with $Provider<NavigationState> {
  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'9c9beae404c98419430f83922c5d9aa1dbe3a64a';

@ProviderFor(dashboardState)
final dashboardStateProvider = DashboardStateProvider._();

final class DashboardStateProvider
    extends $FunctionalProvider<DashboardState, DashboardState, DashboardState>
    with $Provider<DashboardState> {
  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'33838f85f2b6a0ab601891aa2f26adc8870302b6';

@ProviderFor(moreToolsSelectorState)
final moreToolsSelectorStateProvider = MoreToolsSelectorStateProvider._();

final class MoreToolsSelectorStateProvider
    extends
        $FunctionalProvider<
          MoreToolsSelectorState,
          MoreToolsSelectorState,
          MoreToolsSelectorState
        >
    with $Provider<MoreToolsSelectorState> {
  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'c47987547d0e59da10ec4bbd9c8cf1416f8477f3';

@ProviderFor(overlayTopOffset)
final overlayTopOffsetProvider = OverlayTopOffsetProvider._();

final class OverlayTopOffsetProvider
    extends $FunctionalProvider<double, double, double>
    with $Provider<double> {
  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'44c3b3c9f8f3af5e10ba91e0f2514f52f3c6ddac';

@ProviderFor(profilesState)
final profilesStateProvider = ProfilesStateProvider._();

final class ProfilesStateProvider
    extends $FunctionalProvider<ProfilesState, ProfilesState, ProfilesState>
    with $Provider<ProfilesState> {
  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'6bcfd61de84c930251ade72b9fe804c4f5ac2be9';

@ProviderFor(currentProfile)
final currentProfileProvider = CurrentProfileProvider._();

final class CurrentProfileProvider
    extends $FunctionalProvider<Profile?, Profile?, Profile?>
    with $Provider<Profile?> {
  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(profile)
final profileProvider = ProfileFamily._();

final class ProfileProvider
    extends $FunctionalProvider<Profile?, Profile?, Profile?>
    with $Provider<Profile?> {
  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?> {
  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(extendType)
final extendTypeProvider = ExtendTypeFamily._();

final class ExtendTypeProvider
    extends $FunctionalProvider<ExtendType, ExtendType, ExtendType>
    with $Provider<ExtendType> {
  ExtendTypeProvider._({
    required ExtendTypeFamily super.from,
    required int? super.argument,
  }) : super(
         retry: null,
         name: r'extendTypeProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$extendTypeHash();

  @override
  String toString() {
    return r'extendTypeProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $ProviderElement<ExtendType> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  ExtendType create(Ref ref) {
    final argument = this.argument as int?;
    return extendType(ref, argument);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(ExtendType value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<ExtendType>(value),
    );
  }

  @override
  bool operator ==(Object other) {
    return other is ExtendTypeProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$extendTypeHash() => r'166b866a116caa0e93de80b9a59e23697508d219';

final class ExtendTypeFamily extends $Family
    with $FunctionalFamilyOverride<ExtendType, int?> {
  ExtendTypeFamily._()
    : super(
        retry: null,
        name: r'extendTypeProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  ExtendTypeProvider call(int? profileId) =>
      ExtendTypeProvider._(argument: profileId, from: this);

  @override
  String toString() => r'extendTypeProvider';
}

@ProviderFor(clashConfig)
final clashConfigProvider = ClashConfigFamily._();

final class ClashConfigProvider
    extends
        $FunctionalProvider<
          AsyncValue<ClashConfig>,
          ClashConfig,
          FutureOr<ClashConfig>
        >
    with $FutureModifier<ClashConfig>, $FutureProvider<ClashConfig> {
  ClashConfigProvider._({
    required ClashConfigFamily super.from,
    required int super.argument,
  }) : super(
         retry: null,
         name: r'clashConfigProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

  @override
  String debugGetCreateSourceHash() => _$clashConfigHash();

  @override
  String toString() {
    return r'clashConfigProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  $FutureProviderElement<ClashConfig> $createElement(
    $ProviderPointer pointer,
  ) => $FutureProviderElement(pointer);

  @override
  FutureOr<ClashConfig> create(Ref ref) {
    final argument = this.argument as int;
    return clashConfig(ref, argument);
  }

  @override
  bool operator ==(Object other) {
    return other is ClashConfigProvider && other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$clashConfigHash() => r'ed8cfcf34801fae6f54b28ddcf5ea31bc49ad0ba';

final class ClashConfigFamily extends $Family
    with $FunctionalFamilyOverride<FutureOr<ClashConfig>, int> {
  ClashConfigFamily._()
    : super(
        retry: null,
        name: r'clashConfigProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  ClashConfigProvider call(int profileId) =>
      ClashConfigProvider._(argument: profileId, from: this);

  @override
  String toString() => r'clashConfigProvider';
}

@ProviderFor(setupState)
final setupStateProvider = SetupStateFamily._();

final class SetupStateProvider
    extends
        $FunctionalProvider<
          AsyncValue<SetupState>,
          SetupState,
          FutureOr<SetupState>
        >
    with $FutureModifier<SetupState>, $FutureProvider<SetupState> {
  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'eef9f0d2ec0ecb6196c699b1e2c2a73d922f8964';

final class SetupStateFamily extends $Family
    with $FunctionalFamilyOverride<FutureOr<SetupState>, int?> {
  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';
}

/// Subscription profiles double as proxy providers for custom profiles.

@ProviderFor(profileProviders)
final profileProvidersProvider = ProfileProvidersProvider._();

/// Subscription profiles double as proxy providers for custom profiles.

final class ProfileProvidersProvider
    extends
        $FunctionalProvider<
          Map<String, int>,
          Map<String, int>,
          Map<String, int>
        >
    with $Provider<Map<String, int>> {
  /// Subscription profiles double as proxy providers for custom profiles.
  ProfileProvidersProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'profileProvidersProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$profileProvidersHash();

  @$internal
  @override
  $ProviderElement<Map<String, int>> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  Map<String, int> create(Ref ref) {
    return profileProviders(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(Map<String, int> value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<Map<String, int>>(value),
    );
  }
}

String _$profileProvidersHash() => r'689856f32a4b40e6a26b1eedd16db418d140371a';