worker/lib/core/providers/connectivity_provider.g.dart

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'connectivity_provider.dart';

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

// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint, type=warning
/// Provider for the Connectivity instance
/// This is a simple provider that returns a singleton instance

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

/// Provider for the Connectivity instance
/// This is a simple provider that returns a singleton instance

final class ConnectivityProvider
    extends $FunctionalProvider<Connectivity, Connectivity, Connectivity>
    with $Provider<Connectivity> {
  /// Provider for the Connectivity instance
  /// This is a simple provider that returns a singleton 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';

/// Stream provider that monitors real-time connectivity changes
/// This automatically updates whenever the device connectivity changes
///
/// Usage:
/// ```dart
/// final connectivityState = ref.watch(connectivityStreamProvider);
/// connectivityState.when(
///   data: (status) => Text('Status: $status'),
///   loading: () => const CustomLoadingIndicator(),
///   error: (error, _) => Text('Error: $error'),
/// );
/// ```

@ProviderFor(connectivityStream)
const connectivityStreamProvider = ConnectivityStreamProvider._();

/// Stream provider that monitors real-time connectivity changes
/// This automatically updates whenever the device connectivity changes
///
/// Usage:
/// ```dart
/// final connectivityState = ref.watch(connectivityStreamProvider);
/// connectivityState.when(
///   data: (status) => Text('Status: $status'),
///   loading: () => const CustomLoadingIndicator(),
///   error: (error, _) => Text('Error: $error'),
/// );
/// ```

final class ConnectivityStreamProvider
    extends
        $FunctionalProvider<
          AsyncValue<ConnectivityStatus>,
          ConnectivityStatus,
          Stream<ConnectivityStatus>
        >
    with
        $FutureModifier<ConnectivityStatus>,
        $StreamProvider<ConnectivityStatus> {
  /// Stream provider that monitors real-time connectivity changes
  /// This automatically updates whenever the device connectivity changes
  ///
  /// Usage:
  /// ```dart
  /// final connectivityState = ref.watch(connectivityStreamProvider);
  /// connectivityState.when(
  ///   data: (status) => Text('Status: $status'),
  ///   loading: () => const CustomLoadingIndicator(),
  ///   error: (error, _) => Text('Error: $error'),
  /// );
  /// ```
  const ConnectivityStreamProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'connectivityStreamProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  Stream<ConnectivityStatus> create(Ref ref) {
    return connectivityStream(ref);
  }
}

String _$connectivityStreamHash() =>
    r'207d7c426c0182225f4d1fd2014b9bc6c667fd67';

/// Provider that checks current connectivity status once
/// This is useful for one-time checks without listening to changes
///
/// Usage:
/// ```dart
/// final status = await ref.read(currentConnectivityProvider.future);
/// if (status == ConnectivityStatus.offline) {
///   showOfflineDialog();
/// }
/// ```

@ProviderFor(currentConnectivity)
const currentConnectivityProvider = CurrentConnectivityProvider._();

/// Provider that checks current connectivity status once
/// This is useful for one-time checks without listening to changes
///
/// Usage:
/// ```dart
/// final status = await ref.read(currentConnectivityProvider.future);
/// if (status == ConnectivityStatus.offline) {
///   showOfflineDialog();
/// }
/// ```

final class CurrentConnectivityProvider
    extends
        $FunctionalProvider<
          AsyncValue<ConnectivityStatus>,
          ConnectivityStatus,
          FutureOr<ConnectivityStatus>
        >
    with
        $FutureModifier<ConnectivityStatus>,
        $FutureProvider<ConnectivityStatus> {
  /// Provider that checks current connectivity status once
  /// This is useful for one-time checks without listening to changes
  ///
  /// Usage:
  /// ```dart
  /// final status = await ref.read(currentConnectivityProvider.future);
  /// if (status == ConnectivityStatus.offline) {
  ///   showOfflineDialog();
  /// }
  /// ```
  const CurrentConnectivityProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'currentConnectivityProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  FutureOr<ConnectivityStatus> create(Ref ref) {
    return currentConnectivity(ref);
  }
}

String _$currentConnectivityHash() =>
    r'bf11d5eef553f9476a8b667e68572268bc25c9fb';

/// Provider that returns whether the device is currently online
/// Convenient boolean check for connectivity
///
/// Usage:
/// ```dart
/// final isOnlineAsync = ref.watch(isOnlineProvider);
/// isOnlineAsync.when(
///   data: (isOnline) => isOnline ? Text('Online') : Text('Offline'),
///   loading: () => const CustomLoadingIndicator(),
///   error: (error, _) => Text('Error: $error'),
/// );
/// ```

@ProviderFor(isOnline)
const isOnlineProvider = IsOnlineProvider._();

/// Provider that returns whether the device is currently online
/// Convenient boolean check for connectivity
///
/// Usage:
/// ```dart
/// final isOnlineAsync = ref.watch(isOnlineProvider);
/// isOnlineAsync.when(
///   data: (isOnline) => isOnline ? Text('Online') : Text('Offline'),
///   loading: () => const CustomLoadingIndicator(),
///   error: (error, _) => Text('Error: $error'),
/// );
/// ```

final class IsOnlineProvider
    extends $FunctionalProvider<AsyncValue<bool>, bool, Stream<bool>>
    with $FutureModifier<bool>, $StreamProvider<bool> {
  /// Provider that returns whether the device is currently online
  /// Convenient boolean check for connectivity
  ///
  /// Usage:
  /// ```dart
  /// final isOnlineAsync = ref.watch(isOnlineProvider);
  /// isOnlineAsync.when(
  ///   data: (isOnline) => isOnline ? Text('Online') : Text('Offline'),
  ///   loading: () => const CustomLoadingIndicator(),
  ///   error: (error, _) => Text('Error: $error'),
  /// );
  /// ```
  const IsOnlineProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'isOnlineProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  Stream<bool> create(Ref ref) {
    return isOnline(ref);
  }
}

String _$isOnlineHash() => r'09f68fd322b995ffdc28fab6249d8b80108512c4';