// GENERATED CODE - DO NOT MODIFY BY HAND

part of '../state.dart';

// **************************************************************************
// RiverpodGenerator
// **************************************************************************

// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint, type=warning

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

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

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

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

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

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

String _$currentGroupsStateHash() =>
    r'dbf8f02606a31486c99d7b89d19914cd5a1fc496';

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

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

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

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

  @override
  NavigationItemsState create(Ref ref) {
    return navigationItemsState(ref);
  }

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

String _$navigationItemsStateHash() =>
    r'1fc37c14d129f9725b0e62fd53f6b25382f51102';

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

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

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

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

  @override
  NavigationItemsState create(Ref ref) {
    return currentNavigationItemsState(ref);
  }

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

String _$currentNavigationItemsStateHash() =>
    r'06fbdc194f4527b945695fe3b72b16e0585fa440';

@ProviderFor(updateParams)
const updateParamsProvider = UpdateParamsProvider._();

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

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

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

  @override
  UpdateParams create(Ref ref) {
    return updateParams(ref);
  }

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

String _$updateParamsHash() => r'012df72ab0e769a51c573f4692031506d7b1f1b4';

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

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

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

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

  @override
  ProxyState create(Ref ref) {
    return proxyState(ref);
  }

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

String _$proxyStateHash() => r'3df11daa70bd06de32da43e9b3e09a74389264b2';

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

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

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

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

  @override
  TrayState create(Ref ref) {
    return trayState(ref);
  }

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

String _$trayStateHash() => r'b03770ae2eb7fe1a73372f1128af3b38fdebb818';

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

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

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

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

  @override
  TrayTitleState create(Ref ref) {
    return trayTitleState(ref);
  }

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

String _$trayTitleStateHash() => r'5f868aaf70480b00bfdc2de18684ee646a93fd12';

@ProviderFor(vpnState)
const vpnStateProvider = VpnStateProvider._();

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

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

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

  @override
  VpnState create(Ref ref) {
    return vpnState(ref);
  }

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

String _$vpnStateHash() => r'128ddad03ce045ad1f8204e47aec3cb6cfa29f6e';

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

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

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

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

  @override
  NavigationState create(Ref ref) {
    return navigationState(ref);
  }

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

String _$navigationStateHash() => r'657dc47ecc35ba0807b58cb37e7f1baa14f6c2f9';

@ProviderFor(contentWidth)
const contentWidthProvider = ContentWidthProvider._();

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

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

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

  @override
  double create(Ref ref) {
    return contentWidth(ref);
  }

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

String _$contentWidthHash() => r'4710fee8f91b08dc88520798fb6b1d4f61f090e6';

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

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

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

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

  @override
  DashboardState create(Ref ref) {
    return dashboardState(ref);
  }

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

String _$dashboardStateHash() => r'e8616e327c1b96658d917e4e4950f70ecb099d85';

@ProviderFor(proxiesActionsState)
const proxiesActionsStateProvider = ProxiesActionsStateProvider._();

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

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

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

  @override
  ProxiesActionsState create(Ref ref) {
    return proxiesActionsState(ref);
  }

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

String _$proxiesActionsStateHash() =>
    r'84f8a94706233ff5d4b8a456291a4e66c1381c62';

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

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

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

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

  @override
  ProfilesState create(Ref ref) {
    return profilesState(ref);
  }

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

String _$profilesStateHash() => r'8b07eeacb83b9002ba7e6283ff7a7f451a0845a6';

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

final class FilterGroupsStateProvider
    extends $FunctionalProvider<GroupsState, GroupsState, GroupsState>
    with $Provider<GroupsState> {
  const FilterGroupsStateProvider._({
    required FilterGroupsStateFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'filterGroupsStateProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  GroupsState create(Ref ref) {
    final argument = this.argument as String;
    return filterGroupsState(ref, argument);
  }

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

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

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

String _$filterGroupsStateHash() => r'7de7a4603ca5ed7c39a00351af43144eb6c21404';

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

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

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

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

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

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

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

  @override
  ProxiesListState create(Ref ref) {
    return proxiesListState(ref);
  }

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

String _$proxiesListStateHash() => r'b16ad96516ece78f6cb22f558a0535000b784317';

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

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

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

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

  @override
  ProxiesTabState create(Ref ref) {
    return proxiesTabState(ref);
  }

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

String _$proxiesTabStateHash() => r'143b106d74da618327cbac48af15078efd8cabee';

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

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

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

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

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

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

String _$isStartHash() => r'f8bcefa8515c44fbe14876a5fc6676110508e9b2';

@ProviderFor(proxiesTabControllerState)
const proxiesTabControllerStateProvider = ProxiesTabControllerStateProvider._();

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

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

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

  @override
  VM2<List<String>, String?> create(Ref ref) {
    return proxiesTabControllerState(ref);
  }

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

String _$proxiesTabControllerStateHash() =>
    r'd9c4eb6771262b2a989b053ce6ad94c307cf43fb';

@ProviderFor(proxyGroupSelectorState)
const proxyGroupSelectorStateProvider = ProxyGroupSelectorStateFamily._();

final class ProxyGroupSelectorStateProvider
    extends
        $FunctionalProvider<
          ProxyGroupSelectorState,
          ProxyGroupSelectorState,
          ProxyGroupSelectorState
        >
    with $Provider<ProxyGroupSelectorState> {
  const ProxyGroupSelectorStateProvider._({
    required ProxyGroupSelectorStateFamily super.from,
    required (String, String) super.argument,
  }) : super(
         retry: null,
         name: r'proxyGroupSelectorStateProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  ProxyGroupSelectorState create(Ref ref) {
    final argument = this.argument as (String, String);
    return proxyGroupSelectorState(ref, argument.$1, argument.$2);
  }

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

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

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

String _$proxyGroupSelectorStateHash() =>
    r'c2a059873a38907071a2664409bacfe21b7d6c3c';

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

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

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

@ProviderFor(packageListSelectorState)
const packageListSelectorStateProvider = PackageListSelectorStateProvider._();

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

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

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

  @override
  PackageListSelectorState create(Ref ref) {
    return packageListSelectorState(ref);
  }

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

String _$packageListSelectorStateHash() =>
    r'1fa2bebbd8ee07910aa8d6e9c5d5d6128df5c13b';

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

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

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

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

  @override
  MoreToolsSelectorState create(Ref ref) {
    return moreToolsSelectorState(ref);
  }

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

String _$moreToolsSelectorStateHash() =>
    r'6329d92652135e2af009dddeac590b4369d2fa04';

@ProviderFor(isCurrentPage)
const isCurrentPageProvider = IsCurrentPageFamily._();

final class IsCurrentPageProvider extends $FunctionalProvider<bool, bool, bool>
    with $Provider<bool> {
  const IsCurrentPageProvider._({
    required IsCurrentPageFamily super.from,
    required (
      PageLabel, {
      bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
    })
    super.argument,
  }) : super(
         retry: null,
         name: r'isCurrentPageProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  bool create(Ref ref) {
    final argument =
        this.argument
            as (
              PageLabel, {
              bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
            });
    return isCurrentPage(ref, argument.$1, handler: argument.handler);
  }

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

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

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

String _$isCurrentPageHash() => r'7c300770aef90da23109d9fcfc3bf26140d8cd08';

final class IsCurrentPageFamily extends $Family
    with
        $FunctionalFamilyOverride<
          bool,
          (
            PageLabel, {
            bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
          })
        > {
  const IsCurrentPageFamily._()
    : super(
        retry: null,
        name: r'isCurrentPageProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  IsCurrentPageProvider call(
    PageLabel pageLabel, {
    bool Function(PageLabel pageLabel, ViewMode viewMode)? handler,
  }) => IsCurrentPageProvider._(
    argument: (pageLabel, handler: handler),
    from: this,
  );

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

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

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

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

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

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

  @override
  String create(Ref ref) {
    final argument = this.argument as String?;
    return realTestUrl(ref, argument);
  }

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

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

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

String _$realTestUrlHash() => r'6d68caa7a526b6788e3e4899d3ec8ad1c065b15e';

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

  RealTestUrlProvider call([String? testUrl]) =>
      RealTestUrlProvider._(argument: testUrl, from: this);

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

@ProviderFor(getDelay)
const getDelayProvider = GetDelayFamily._();

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

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

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

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

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

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

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

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

String _$getDelayHash() => r'ee2df2db2b12d599794f77519a9ac518f42245a7';

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

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

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

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

final class SelectedMapProvider
    extends
        $FunctionalProvider<
          Map<String, String>,
          Map<String, String>,
          Map<String, String>
        >
    with $Provider<Map<String, String>> {
  const SelectedMapProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'selectedMapProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

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

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

String _$selectedMapHash() => r'd4438d8d87d0c7ec7d9c5d02f577cdba6ba2a785';

@ProviderFor(unfoldSet)
const unfoldSetProvider = UnfoldSetProvider._();

final class UnfoldSetProvider
    extends $FunctionalProvider<Set<String>, Set<String>, Set<String>>
    with $Provider<Set<String>> {
  const UnfoldSetProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'unfoldSetProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  Set<String> create(Ref ref) {
    return unfoldSet(ref);
  }

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

String _$unfoldSetHash() => r'59a5b417611533069462ddf31eca080ab2f74ac9';

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

final class GetHotKeyActionProvider
    extends $FunctionalProvider<HotKeyAction, HotKeyAction, HotKeyAction>
    with $Provider<HotKeyAction> {
  const GetHotKeyActionProvider._({
    required GetHotKeyActionFamily super.from,
    required HotAction super.argument,
  }) : super(
         retry: null,
         name: r'getHotKeyActionProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  HotKeyAction create(Ref ref) {
    final argument = this.argument as HotAction;
    return getHotKeyAction(ref, argument);
  }

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

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

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

String _$getHotKeyActionHash() => r'4dc74ea7ffb25624ce70c7c8214806f3ef022223';

final class GetHotKeyActionFamily extends $Family
    with $FunctionalFamilyOverride<HotKeyAction, HotAction> {
  const GetHotKeyActionFamily._()
    : super(
        retry: null,
        name: r'getHotKeyActionProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  GetHotKeyActionProvider call(HotAction hotAction) =>
      GetHotKeyActionProvider._(argument: hotAction, from: this);

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

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

final class CurrentProfileProvider
    extends $FunctionalProvider<Profile?, Profile?, Profile?>
    with $Provider<Profile?> {
  const CurrentProfileProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'currentProfileProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  Profile? create(Ref ref) {
    return currentProfile(ref);
  }

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

String _$currentProfileHash() => r'55f3cb9570a0aa6b9e0b83a36693b69d52e753ab';

@ProviderFor(getProxiesColumns)
const getProxiesColumnsProvider = GetProxiesColumnsProvider._();

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

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

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

  @override
  int create(Ref ref) {
    return getProxiesColumns(ref);
  }

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

String _$getProxiesColumnsHash() => r'd5340932d4812727caa670065bce30450f1c4da5';

@ProviderFor(realSelectedProxyState)
const realSelectedProxyStateProvider = RealSelectedProxyStateFamily._();

final class RealSelectedProxyStateProvider
    extends
        $FunctionalProvider<
          SelectedProxyState,
          SelectedProxyState,
          SelectedProxyState
        >
    with $Provider<SelectedProxyState> {
  const RealSelectedProxyStateProvider._({
    required RealSelectedProxyStateFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'realSelectedProxyStateProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  SelectedProxyState create(Ref ref) {
    final argument = this.argument as String;
    return realSelectedProxyState(ref, argument);
  }

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

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

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

String _$realSelectedProxyStateHash() =>
    r'42fa131419f0a26e30c4f5269bf020893b7f828c';

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

  RealSelectedProxyStateProvider call(String proxyName) =>
      RealSelectedProxyStateProvider._(argument: proxyName, from: this);

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

@ProviderFor(getProxyName)
const getProxyNameProvider = GetProxyNameFamily._();

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

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

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

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

  @override
  String? create(Ref ref) {
    final argument = this.argument as String;
    return getProxyName(ref, argument);
  }

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

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

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

String _$getProxyNameHash() => r'204a477ea18c8e1eeef55b3efd3d47e45b0d2350';

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

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

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

@ProviderFor(getSelectedProxyName)
const getSelectedProxyNameProvider = GetSelectedProxyNameFamily._();

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

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

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

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

  @override
  String? create(Ref ref) {
    final argument = this.argument as String;
    return getSelectedProxyName(ref, argument);
  }

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

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

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

String _$getSelectedProxyNameHash() =>
    r'13aeae1fede234983d262d824a85c7375f9e4e78';

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

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

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

@ProviderFor(getProxyDesc)
const getProxyDescProvider = GetProxyDescFamily._();

final class GetProxyDescProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  const GetProxyDescProvider._({
    required GetProxyDescFamily super.from,
    required Proxy super.argument,
  }) : super(
         retry: null,
         name: r'getProxyDescProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  String create(Ref ref) {
    final argument = this.argument as Proxy;
    return getProxyDesc(ref, argument);
  }

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

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

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

String _$getProxyDescHash() => r'4579b55bf7e9fbcfdf91b91619bd0320c585f23d';

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

  GetProxyDescProvider call(Proxy proxy) =>
      GetProxyDescProvider._(argument: proxy, from: this);

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

@ProviderFor(checkIp)
const checkIpProvider = CheckIpProvider._();

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

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

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

  @override
  VM3<bool, int, bool> create(Ref ref) {
    return checkIp(ref);
  }

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

String _$checkIpHash() => r'7d8be66f0e8164bcf20c32659da2a4bea9893596';

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

final class GenColorSchemeProvider
    extends $FunctionalProvider<ColorScheme, ColorScheme, ColorScheme>
    with $Provider<ColorScheme> {
  const GenColorSchemeProvider._({
    required GenColorSchemeFamily super.from,
    required (Brightness, {Color? color, bool ignoreConfig}) super.argument,
  }) : super(
         retry: null,
         name: r'genColorSchemeProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  ColorScheme create(Ref ref) {
    final argument =
        this.argument as (Brightness, {Color? color, bool ignoreConfig});
    return genColorScheme(
      ref,
      argument.$1,
      color: argument.color,
      ignoreConfig: argument.ignoreConfig,
    );
  }

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

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

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

String _$genColorSchemeHash() => r'25f648db7c33ac00e7152f3d304da372a4de9fdd';

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

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

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

@ProviderFor(currentSetupState)
const currentSetupStateProvider = CurrentSetupStateProvider._();

final class CurrentSetupStateProvider
    extends $FunctionalProvider<SetupState?, SetupState?, SetupState?>
    with $Provider<SetupState?> {
  const CurrentSetupStateProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'currentSetupStateProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  SetupState? create(Ref ref) {
    return currentSetupState(ref);
  }

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

String _$currentSetupStateHash() => r'd687b0563ea8cc8eb1ca345fdfeee3411d67ad47';

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

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

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

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

  @override
  Brightness create(Ref ref) {
    return currentBrightness(ref);
  }

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

String _$currentBrightnessHash() => r'ab56c47af4fcae773c8f9f81c91800c1e1890b70';

@ProviderFor(autoSetSystemDnsState)
const autoSetSystemDnsStateProvider = AutoSetSystemDnsStateProvider._();

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

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

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

  @override
  VM2<bool, bool> create(Ref ref) {
    return autoSetSystemDnsState(ref);
  }

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

String _$autoSetSystemDnsStateHash() =>
    r'a8805965efe78241613bfde55f4ea8fa12a6ea32';

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

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

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

  @$internal
  @override
  $ProviderElement<VM3<bool, int, ProxiesSortType>> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  VM3<bool, int, ProxiesSortType> create(Ref ref) {
    return needUpdateGroups(ref);
  }

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

String _$needUpdateGroupsHash() => r'7913b7b74caf9f2c72fd32729d52b7c6ac9258e8';

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

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

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

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

  @override
  SharedState create(Ref ref) {
    return sharedState(ref);
  }

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

String _$sharedStateHash() => r'864fdf3f750fb6d1beadcb5f9226a614a9cb2caa';

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

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

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

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

  @override
  double create(Ref ref) {
    return overlayTopOffset(ref);
  }

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

String _$overlayTopOffsetHash() => r'b2462f67acbd88b7a881dfe4c6353e68ba49961d';

@ProviderFor(profile)
const profileProvider = ProfileFamily._();

final class ProfileProvider
    extends $FunctionalProvider<Profile?, Profile?, Profile?>
    with $Provider<Profile?> {
  const ProfileProvider._({
    required ProfileFamily super.from,
    required int? super.argument,
  }) : super(
         retry: null,
         name: r'profileProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

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

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

String _$profileHash() => r'8de429dc0844c6b6155032ad3c9546231e08cead';

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

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

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

@ProviderFor(overwriteType)
const overwriteTypeProvider = OverwriteTypeFamily._();

final class OverwriteTypeProvider
    extends $FunctionalProvider<OverwriteType, OverwriteType, OverwriteType>
    with $Provider<OverwriteType> {
  const OverwriteTypeProvider._({
    required OverwriteTypeFamily super.from,
    required int? super.argument,
  }) : super(
         retry: null,
         name: r'overwriteTypeProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

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

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

String _$overwriteTypeHash() => r'03a8ab8ddec76935da5fa231270b65baa70fd727';

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

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

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

@ProviderFor(script)
const scriptProvider = ScriptFamily._();

final class ScriptProvider
    extends $FunctionalProvider<AsyncValue<Script?>, Script?, FutureOr<Script?>>
    with $FutureModifier<Script?>, $FutureProvider<Script?> {
  const ScriptProvider._({
    required ScriptFamily super.from,
    required int? super.argument,
  }) : super(
         retry: null,
         name: r'scriptProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

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

String _$scriptHash() => r'b12a6dbe34e08cb1232afafa8b0b0f5363d28bc0';

final class ScriptFamily extends $Family
    with $FunctionalFamilyOverride<FutureOr<Script?>, int?> {
  const ScriptFamily._()
    : super(
        retry: null,
        name: r'scriptProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  ScriptProvider call(int? scriptId) =>
      ScriptProvider._(argument: scriptId, from: this);

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

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

final class SetupStateProvider
    extends
        $FunctionalProvider<
          AsyncValue<SetupState>,
          SetupState,
          FutureOr<SetupState>
        >
    with $FutureModifier<SetupState>, $FutureProvider<SetupState> {
  const SetupStateProvider._({
    required SetupStateFamily super.from,
    required int? super.argument,
  }) : super(
         retry: null,
         name: r'setupStateProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

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

String _$setupStateHash() => r'8e0c849fa1a51ee15f8b40be94e3094182325b58';

final class SetupStateFamily extends $Family
    with $FunctionalFamilyOverride<FutureOr<SetupState>, int?> {
  const SetupStateFamily._()
    : super(
        retry: null,
        name: r'setupStateProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

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

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

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

final class AccessControlStateProvider
    extends $NotifierProvider<AccessControlState, AccessControlProps> {
  const AccessControlStateProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'accessControlStateProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

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

String _$accessControlStateHash() =>
    r'08fda2e342d027c1bdd49c1ef9a13f2e775db204';

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