// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'network_info.dart';

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

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

@ProviderFor(connectivity)
const connectivityProvider = ConnectivityProvider._();

/// Provider for Connectivity instance

final class ConnectivityProvider
    extends $FunctionalProvider<Connectivity, Connectivity, Connectivity>
    with $Provider<Connectivity> {
  /// Provider for Connectivity instance
  const ConnectivityProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'connectivityProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  Connectivity create(Ref ref) {
    return connectivity(ref);
  }

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

String _$connectivityHash() => r'6d67af0ea4110f6ee0246dd332f90f8901380eda';

/// Provider for NetworkInfo instance

@ProviderFor(networkInfo)
const networkInfoProvider = NetworkInfoProvider._();

/// Provider for NetworkInfo instance

final class NetworkInfoProvider
    extends $FunctionalProvider<NetworkInfo, NetworkInfo, NetworkInfo>
    with $Provider<NetworkInfo> {
  /// Provider for NetworkInfo instance
  const NetworkInfoProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'networkInfoProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  NetworkInfo create(Ref ref) {
    return networkInfo(ref);
  }

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

String _$networkInfoHash() => r'aee276b1536c8c994273dbed1909a2c24a7c71d2';

/// Provider for current network connection status (boolean)

@ProviderFor(isConnected)
const isConnectedProvider = IsConnectedProvider._();

/// Provider for current network connection status (boolean)

final class IsConnectedProvider
    extends $FunctionalProvider<AsyncValue<bool>, bool, FutureOr<bool>>
    with $FutureModifier<bool>, $FutureProvider<bool> {
  /// Provider for current network connection status (boolean)
  const IsConnectedProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'isConnectedProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  FutureOr<bool> create(Ref ref) {
    return isConnected(ref);
  }
}

String _$isConnectedHash() => r'c9620cadbcdee8e738f865e747dd57262236782d';

/// Provider for current network connection type

@ProviderFor(connectionType)
const connectionTypeProvider = ConnectionTypeProvider._();

/// Provider for current network connection type

final class ConnectionTypeProvider
    extends
        $FunctionalProvider<
          AsyncValue<NetworkConnectionType>,
          NetworkConnectionType,
          FutureOr<NetworkConnectionType>
        >
    with
        $FutureModifier<NetworkConnectionType>,
        $FutureProvider<NetworkConnectionType> {
  /// Provider for current network connection type
  const ConnectionTypeProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'connectionTypeProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  FutureOr<NetworkConnectionType> create(Ref ref) {
    return connectionType(ref);
  }
}

String _$connectionTypeHash() => r'413aead6c4ff6f2c1476e4795934fddb76b797e6';

/// Stream provider for network status changes

@ProviderFor(networkStatusStream)
const networkStatusStreamProvider = NetworkStatusStreamProvider._();

/// Stream provider for network status changes

final class NetworkStatusStreamProvider
    extends
        $FunctionalProvider<
          AsyncValue<NetworkStatus>,
          NetworkStatus,
          Stream<NetworkStatus>
        >
    with $FutureModifier<NetworkStatus>, $StreamProvider<NetworkStatus> {
  /// Stream provider for network status changes
  const NetworkStatusStreamProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'networkStatusStreamProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

  @$internal
  @override
  $StreamProviderElement<NetworkStatus> $createElement(
    $ProviderPointer pointer,
  ) => $StreamProviderElement(pointer);

  @override
  Stream<NetworkStatus> create(Ref ref) {
    return networkStatusStream(ref);
  }
}

String _$networkStatusStreamHash() =>
    r'bdff8d93b214ebc290e81ab72fb8d51d8bfb27b1';

/// Provider for current network status

@ProviderFor(NetworkStatusNotifier)
const networkStatusProvider = NetworkStatusNotifierProvider._();

/// Provider for current network status
final class NetworkStatusNotifierProvider
    extends $AsyncNotifierProvider<NetworkStatusNotifier, NetworkStatus> {
  /// Provider for current network status
  const NetworkStatusNotifierProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'networkStatusProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

  @$internal
  @override
  NetworkStatusNotifier create() => NetworkStatusNotifier();
}

String _$networkStatusNotifierHash() =>
    r'628e313a66129282cd06dfdd561af3f0a4517b4f';

/// Provider for current network status

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