// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'provider_examples.dart';

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

// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint, type=warning
/// ============================================================================
/// RIVERPOD 3.0 PROVIDER EXAMPLES WITH CODE GENERATION
/// ============================================================================
/// This file contains comprehensive examples of Riverpod 3.0 patterns
/// using the @riverpod annotation and code generation.
///
/// Key Changes in Riverpod 3.0:
/// - Unified Ref type (no more FutureProviderRef, StreamProviderRef, etc.)
/// - Simplified Notifier classes (no more separate AutoDisposeNotifier)
/// - Automatic retry for failed providers
/// - ref.mounted check after async operations
/// - Improved family parameters (just function parameters!)
/// ============================================================================
// ============================================================================
// 1. SIMPLE IMMUTABLE VALUE PROVIDER
// ============================================================================
/// Simple provider that returns an immutable value
/// Use this for constants, configurations, or computed values

@ProviderFor(appVersion)
const appVersionProvider = AppVersionProvider._();

/// ============================================================================
/// RIVERPOD 3.0 PROVIDER EXAMPLES WITH CODE GENERATION
/// ============================================================================
/// This file contains comprehensive examples of Riverpod 3.0 patterns
/// using the @riverpod annotation and code generation.
///
/// Key Changes in Riverpod 3.0:
/// - Unified Ref type (no more FutureProviderRef, StreamProviderRef, etc.)
/// - Simplified Notifier classes (no more separate AutoDisposeNotifier)
/// - Automatic retry for failed providers
/// - ref.mounted check after async operations
/// - Improved family parameters (just function parameters!)
/// ============================================================================
// ============================================================================
// 1. SIMPLE IMMUTABLE VALUE PROVIDER
// ============================================================================
/// Simple provider that returns an immutable value
/// Use this for constants, configurations, or computed values

final class AppVersionProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  /// ============================================================================
  /// RIVERPOD 3.0 PROVIDER EXAMPLES WITH CODE GENERATION
  /// ============================================================================
  /// This file contains comprehensive examples of Riverpod 3.0 patterns
  /// using the @riverpod annotation and code generation.
  ///
  /// Key Changes in Riverpod 3.0:
  /// - Unified Ref type (no more FutureProviderRef, StreamProviderRef, etc.)
  /// - Simplified Notifier classes (no more separate AutoDisposeNotifier)
  /// - Automatic retry for failed providers
  /// - ref.mounted check after async operations
  /// - Improved family parameters (just function parameters!)
  /// ============================================================================
  // ============================================================================
  // 1. SIMPLE IMMUTABLE VALUE PROVIDER
  // ============================================================================
  /// Simple provider that returns an immutable value
  /// Use this for constants, configurations, or computed values
  const AppVersionProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'appVersionProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  String create(Ref ref) {
    return appVersion(ref);
  }

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

String _$appVersionHash() => r'0c30e6c7150456c44f403b85070b580ece180d49';

/// Provider with computation

@ProviderFor(pointsMultiplier)
const pointsMultiplierProvider = PointsMultiplierProvider._();

/// Provider with computation

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

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

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

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

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

String _$pointsMultiplierHash() => r'18c7271aca98b3352644383f5fb67aba330382a0';

/// Async provider for fetching data once
/// Automatically handles loading and error states via AsyncValue

@ProviderFor(userData)
const userDataProvider = UserDataProvider._();

/// Async provider for fetching data once
/// Automatically handles loading and error states via AsyncValue

final class UserDataProvider
    extends $FunctionalProvider<AsyncValue<String>, String, FutureOr<String>>
    with $FutureModifier<String>, $FutureProvider<String> {
  /// Async provider for fetching data once
  /// Automatically handles loading and error states via AsyncValue
  const UserDataProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'userDataProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

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

String _$userDataHash() => r'3df905d6ea9f81ce7ca8205bd785ad4d4376b399';

/// Async provider with parameters (Family pattern)
/// Parameters are just function parameters - much simpler than before!

@ProviderFor(userProfile)
const userProfileProvider = UserProfileFamily._();

/// Async provider with parameters (Family pattern)
/// Parameters are just function parameters - much simpler than before!

final class UserProfileProvider
    extends $FunctionalProvider<AsyncValue<String>, String, FutureOr<String>>
    with $FutureModifier<String>, $FutureProvider<String> {
  /// Async provider with parameters (Family pattern)
  /// Parameters are just function parameters - much simpler than before!
  const UserProfileProvider._({
    required UserProfileFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'userProfileProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

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

String _$userProfileHash() => r'd42ed517f41ce0dfde58d74b2beb3d8415b81a22';

/// Async provider with parameters (Family pattern)
/// Parameters are just function parameters - much simpler than before!

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

  /// Async provider with parameters (Family pattern)
  /// Parameters are just function parameters - much simpler than before!

  UserProfileProvider call(String userId) =>
      UserProfileProvider._(argument: userId, from: this);

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

/// Async provider with multiple parameters
/// Named parameters, optional parameters, defaults - all supported!

@ProviderFor(productList)
const productListProvider = ProductListFamily._();

/// Async provider with multiple parameters
/// Named parameters, optional parameters, defaults - all supported!

final class ProductListProvider
    extends
        $FunctionalProvider<
          AsyncValue<List<String>>,
          List<String>,
          FutureOr<List<String>>
        >
    with $FutureModifier<List<String>>, $FutureProvider<List<String>> {
  /// Async provider with multiple parameters
  /// Named parameters, optional parameters, defaults - all supported!
  const ProductListProvider._({
    required ProductListFamily super.from,
    required ({String category, int page, int limit, String? searchQuery})
    super.argument,
  }) : super(
         retry: null,
         name: r'productListProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

  @override
  FutureOr<List<String>> create(Ref ref) {
    final argument =
        this.argument
            as ({String category, int page, int limit, String? searchQuery});
    return productList(
      ref,
      category: argument.category,
      page: argument.page,
      limit: argument.limit,
      searchQuery: argument.searchQuery,
    );
  }

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

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

String _$productListHash() => r'aacee7761543692ccd59f0ecd2f290e1a7de203a';

/// Async provider with multiple parameters
/// Named parameters, optional parameters, defaults - all supported!

final class ProductListFamily extends $Family
    with
        $FunctionalFamilyOverride<
          FutureOr<List<String>>,
          ({String category, int page, int limit, String? searchQuery})
        > {
  const ProductListFamily._()
    : super(
        retry: null,
        name: r'productListProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  /// Async provider with multiple parameters
  /// Named parameters, optional parameters, defaults - all supported!

  ProductListProvider call({
    required String category,
    int page = 1,
    int limit = 20,
    String? searchQuery,
  }) => ProductListProvider._(
    argument: (
      category: category,
      page: page,
      limit: limit,
      searchQuery: searchQuery,
    ),
    from: this,
  );

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

/// Stream provider for real-time data
/// Use this for WebSocket connections, real-time updates, etc.

@ProviderFor(timer)
const timerProvider = TimerProvider._();

/// Stream provider for real-time data
/// Use this for WebSocket connections, real-time updates, etc.

final class TimerProvider
    extends $FunctionalProvider<AsyncValue<int>, int, Stream<int>>
    with $FutureModifier<int>, $StreamProvider<int> {
  /// Stream provider for real-time data
  /// Use this for WebSocket connections, real-time updates, etc.
  const TimerProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'timerProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  Stream<int> create(Ref ref) {
    return timer(ref);
  }
}

String _$timerHash() => r'07bead4a22fc812c185b5c9cf9cd1bd3226286a3';

/// Stream provider with parameters

@ProviderFor(chatMessages)
const chatMessagesProvider = ChatMessagesFamily._();

/// Stream provider with parameters

final class ChatMessagesProvider
    extends $FunctionalProvider<AsyncValue<String>, String, Stream<String>>
    with $FutureModifier<String>, $StreamProvider<String> {
  /// Stream provider with parameters
  const ChatMessagesProvider._({
    required ChatMessagesFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'chatMessagesProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

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

String _$chatMessagesHash() => r'c4b270618336d682c83f92d1597e21390fe7826c';

/// Stream provider with parameters

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

  /// Stream provider with parameters

  ChatMessagesProvider call(String roomId) =>
      ChatMessagesProvider._(argument: roomId, from: this);

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

/// Notifier for mutable state with methods
/// Use this when you need to expose methods to modify state
///
/// The @riverpod annotation generates:
/// - counterProvider: Access the state
/// - counterProvider.notifier: Access the notifier methods

@ProviderFor(Counter)
const counterProvider = CounterProvider._();

/// Notifier for mutable state with methods
/// Use this when you need to expose methods to modify state
///
/// The @riverpod annotation generates:
/// - counterProvider: Access the state
/// - counterProvider.notifier: Access the notifier methods
final class CounterProvider extends $NotifierProvider<Counter, int> {
  /// Notifier for mutable state with methods
  /// Use this when you need to expose methods to modify state
  ///
  /// The @riverpod annotation generates:
  /// - counterProvider: Access the state
  /// - counterProvider.notifier: Access the notifier methods
  const CounterProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'counterProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

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

String _$counterHash() => r'a3963e2a590a1fce6dc8567a60acde4671dd8fb4';

/// Notifier for mutable state with methods
/// Use this when you need to expose methods to modify state
///
/// The @riverpod annotation generates:
/// - counterProvider: Access the state
/// - counterProvider.notifier: Access the notifier methods

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

/// Notifier with parameters (Family pattern)

@ProviderFor(CartQuantity)
const cartQuantityProvider = CartQuantityFamily._();

/// Notifier with parameters (Family pattern)
final class CartQuantityProvider extends $NotifierProvider<CartQuantity, int> {
  /// Notifier with parameters (Family pattern)
  const CartQuantityProvider._({
    required CartQuantityFamily super.from,
    required String super.argument,
  }) : super(
         retry: null,
         name: r'cartQuantityProvider',
         isAutoDispose: true,
         dependencies: null,
         $allTransitiveDependencies: null,
       );

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

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

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

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

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

String _$cartQuantityHash() => r'814d6338fe0146a9ce7c44e1ebe53b0f856983c5';

/// Notifier with parameters (Family pattern)

final class CartQuantityFamily extends $Family
    with $ClassFamilyOverride<CartQuantity, int, int, int, String> {
  const CartQuantityFamily._()
    : super(
        retry: null,
        name: r'cartQuantityProvider',
        dependencies: null,
        $allTransitiveDependencies: null,
        isAutoDispose: true,
      );

  /// Notifier with parameters (Family pattern)

  CartQuantityProvider call(String productId) =>
      CartQuantityProvider._(argument: productId, from: this);

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

/// Notifier with parameters (Family pattern)

abstract class _$CartQuantity extends $Notifier<int> {
  late final _$args = ref.$arg as String;
  String get productId => _$args;

  int build(String productId);
  @$mustCallSuper
  @override
  void runBuild() {
    final created = build(_$args);
    final ref = this.ref as $Ref<int, int>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<int, int>,
              int,
              Object?,
              Object?
            >;
    element.handleValue(ref, created);
  }
}

/// AsyncNotifier for state that requires async initialization
/// Perfect for fetching data that can then be modified
///
/// State type: AsyncValue<UserProfile>
/// - AsyncValue.data(profile) when loaded
/// - AsyncValue.loading() when loading
/// - AsyncValue.error(error, stack) when error

@ProviderFor(UserProfileNotifier)
const userProfileProvider = UserProfileNotifierProvider._();

/// AsyncNotifier for state that requires async initialization
/// Perfect for fetching data that can then be modified
///
/// State type: AsyncValue<UserProfile>
/// - AsyncValue.data(profile) when loaded
/// - AsyncValue.loading() when loading
/// - AsyncValue.error(error, stack) when error
final class UserProfileNotifierProvider
    extends $AsyncNotifierProvider<UserProfileNotifier, UserProfileData> {
  /// AsyncNotifier for state that requires async initialization
  /// Perfect for fetching data that can then be modified
  ///
  /// State type: AsyncValue<UserProfile>
  /// - AsyncValue.data(profile) when loaded
  /// - AsyncValue.loading() when loading
  /// - AsyncValue.error(error, stack) when error
  const UserProfileNotifierProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'userProfileProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

String _$userProfileNotifierHash() =>
    r'87c9a9277552095a0ed0b768829e2930fa475c7f';

/// AsyncNotifier for state that requires async initialization
/// Perfect for fetching data that can then be modified
///
/// State type: AsyncValue<UserProfile>
/// - AsyncValue.data(profile) when loaded
/// - AsyncValue.loading() when loading
/// - AsyncValue.error(error, stack) when error

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

/// StreamNotifier for state that comes from a stream but can be modified
/// Use for WebSocket connections with additional actions

@ProviderFor(LiveChatNotifier)
const liveChatProvider = LiveChatNotifierProvider._();

/// StreamNotifier for state that comes from a stream but can be modified
/// Use for WebSocket connections with additional actions
final class LiveChatNotifierProvider
    extends $StreamNotifierProvider<LiveChatNotifier, List<String>> {
  /// StreamNotifier for state that comes from a stream but can be modified
  /// Use for WebSocket connections with additional actions
  const LiveChatNotifierProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'liveChatProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

String _$liveChatNotifierHash() => r'73a240ad5c606ea907b6bd756790f78534e05a2b';

/// StreamNotifier for state that comes from a stream but can be modified
/// Use for WebSocket connections with additional actions

abstract class _$LiveChatNotifier extends $StreamNotifier<List<String>> {
  Stream<List<String>> build();
  @$mustCallSuper
  @override
  void runBuild() {
    final created = build();
    final ref = this.ref as $Ref<AsyncValue<List<String>>, List<String>>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<AsyncValue<List<String>>, List<String>>,
              AsyncValue<List<String>>,
              Object?,
              Object?
            >;
    element.handleValue(ref, created);
  }
}

/// Provider that depends on other providers

@ProviderFor(dashboardData)
const dashboardDataProvider = DashboardDataProvider._();

/// Provider that depends on other providers

final class DashboardDataProvider
    extends $FunctionalProvider<AsyncValue<String>, String, FutureOr<String>>
    with $FutureModifier<String>, $FutureProvider<String> {
  /// Provider that depends on other providers
  const DashboardDataProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'dashboardDataProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

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

String _$dashboardDataHash() => r'978f1547d6f3d9c441e67eb3e8faefea4f2f7967';

/// Provider that selectively watches for optimization
/// Note: userProfileProvider is actually a Family provider (takes userId parameter)
/// In real code, you would use the generated AsyncNotifier provider

@ProviderFor(userDisplayName)
const userDisplayNameProvider = UserDisplayNameProvider._();

/// Provider that selectively watches for optimization
/// Note: userProfileProvider is actually a Family provider (takes userId parameter)
/// In real code, you would use the generated AsyncNotifier provider

final class UserDisplayNameProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  /// Provider that selectively watches for optimization
  /// Note: userProfileProvider is actually a Family provider (takes userId parameter)
  /// In real code, you would use the generated AsyncNotifier provider
  const UserDisplayNameProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'userDisplayNameProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  String create(Ref ref) {
    return userDisplayName(ref);
  }

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

String _$userDisplayNameHash() => r'758087b5550bc4f35516cd2bd44c930447a5ea06';

/// By default, generated providers are autoDispose
/// They clean up when no longer used

@ProviderFor(autoDisposeExample)
const autoDisposeExampleProvider = AutoDisposeExampleProvider._();

/// By default, generated providers are autoDispose
/// They clean up when no longer used

final class AutoDisposeExampleProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  /// By default, generated providers are autoDispose
  /// They clean up when no longer used
  const AutoDisposeExampleProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'autoDisposeExampleProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  String create(Ref ref) {
    return autoDisposeExample(ref);
  }

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

String _$autoDisposeExampleHash() =>
    r'4d31694aa3e5c3be555dd66feef27e069d802039';

/// Keep alive provider - never auto-disposes
/// Use for global state, singletons, services

@ProviderFor(keepAliveExample)
const keepAliveExampleProvider = KeepAliveExampleProvider._();

/// Keep alive provider - never auto-disposes
/// Use for global state, singletons, services

final class KeepAliveExampleProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  /// Keep alive provider - never auto-disposes
  /// Use for global state, singletons, services
  const KeepAliveExampleProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'keepAliveExampleProvider',
        isAutoDispose: false,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  String create(Ref ref) {
    return keepAliveExample(ref);
  }

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

String _$keepAliveExampleHash() => r'097410a95efd4315ce68dcf57615b86065628390';

/// Provider with lifecycle hooks

@ProviderFor(lifecycleExample)
const lifecycleExampleProvider = LifecycleExampleProvider._();

/// Provider with lifecycle hooks

final class LifecycleExampleProvider
    extends $FunctionalProvider<String, String, String>
    with $Provider<String> {
  /// Provider with lifecycle hooks
  const LifecycleExampleProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'lifecycleExampleProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

  @override
  String create(Ref ref) {
    return lifecycleExample(ref);
  }

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

String _$lifecycleExampleHash() => r'b75e9f589ff8dafa137be4c2b357786148641425';

/// Provider showing how to invalidate and refresh

@ProviderFor(DataManager)
const dataManagerProvider = DataManagerProvider._();

/// Provider showing how to invalidate and refresh
final class DataManagerProvider
    extends $AsyncNotifierProvider<DataManager, String> {
  /// Provider showing how to invalidate and refresh
  const DataManagerProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'dataManagerProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

String _$dataManagerHash() => r'606f4d7fc0ba846c203efae10770c98824bbd295';

/// Provider showing how to invalidate and refresh

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

/// Provider with comprehensive error handling

@ProviderFor(ErrorHandlingExample)
const errorHandlingExampleProvider = ErrorHandlingExampleProvider._();

/// Provider with comprehensive error handling
final class ErrorHandlingExampleProvider
    extends $AsyncNotifierProvider<ErrorHandlingExample, String> {
  /// Provider with comprehensive error handling
  const ErrorHandlingExampleProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'errorHandlingExampleProvider',
        isAutoDispose: true,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

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

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

String _$errorHandlingExampleHash() =>
    r'5e356b031ce80eb37cf8fbb225111e1f184026d5';

/// Provider with comprehensive error handling

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