coregen-cli 3.1.6__py3-none-any.whl

generators/static/templates/component/component_list_widget_template.jinja

@@ -0,0 +1,95 @@
+/*
+ * Component list template with full CRUD UI
+ * Generates a reusable component with:
+ * - BLoC integration for state management
+ * - List view showing all items
+ * - Add, edit, delete action buttons
+ * - Loading and error state handling
+ * 
+ * This component expects the BLoC to be provided by a parent widget.
+ */
+
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart' hide ErrorWidget;
+import 'package:flutter_bloc/flutter_bloc.dart';
+{% if not empty_component %}
+import 'package:[[project_name]]/[[domain_import_prefix]]/model/[[domain_model_name]].dart';
+import 'package:[[project_name]]/[[domain_import_prefix]]/model/[[domain_model_name]]_failure.dart';
+{% endif %}
+import 'package:[[project_name]]/[[component_import_prefix]]/application/[[component_name]]_bloc.dart';
+import 'package:[[project_name]]/widgets/common/error_widget.dart';
+import 'package:[[project_name]]/widgets/common/loading_widget.dart';
+import 'package:[[project_name]]/widgets/common/unknown_state_widget.dart';
+{% if not empty_component %}
+import 'package:[[project_name]]/core/errors/error_localizer.dart';
+{% endif %}
+
+class [[component_pascal]]Component extends StatelessWidget {
+  const [[component_pascal]]Component({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return BlocBuilder<[[component_pascal]]Bloc, [[component_pascal]]State>(
+      builder: (BuildContext context, [[component_pascal]]State state) {
+        return switch (state) {
+          Initial() => const Center(child: Text('Welcome')),
+          Loading() => const LoadingWidget(),
+{% if empty_component %}
+          Loaded() => const Center(child: Text('Carica completata')),
+{% else %}
+          Loaded(
+            items: final List<[[domain_model_pascal]]> items,
+            isReloading: final bool isReloading,
+          ) =>
+            Column(
+              children: <Widget>[
+                if (isReloading) CLinearProgressIndicator.primary(),
+                Expanded(
+                  child: ListView.builder(
+                    itemCount: items.length,
+                    itemBuilder: (BuildContext context, int index) {
+                      final [[domain_model_pascal]] item = items[index];
+                      return CTile.simple(
+                        title: item.toString(),
+                        trailing: Row(
+                          mainAxisSize: MainAxisSize.min,
+                          children: <Widget>[
+                              IconButton(
+                              icon: const Icon(Icons.edit),
+                              onPressed: () {
+                                  // Implement: Navigate to edit form
+                              },
+                              ),
+                              IconButton(
+                              icon: const Icon(Icons.delete),
+                              onPressed: () {
+                                  context.read<[[component_pascal]]Bloc>().add(
+                                  [[component_pascal]]Event.deleteRequested(item.id.getOrCrash()),
+                                  );
+                              },
+                            ),
+                          ],
+                        ),
+                      );
+                    },
+                  ),
+                ),
+              ],
+            ),
+{% endif %}
+{% if empty_component %}
+          Error(:final message) => ErrorWidget(message: 'Errore: $message'),
+{% else %}
+          Error(
+            failure: final [[failure_class]] failure,
+          ) =>
+            ErrorWidget(
+              message: ErrorLocalizer.localize[[failure_class]](context, failure),
+            ),
+{% endif %}
+          _ => const UnknownStateWidget(),
+        };
+      },
+    );
+  }
+}

generators/static/templates/component/component_state_template.jinja

@@ -0,0 +1,9 @@
+part of '[[feature_name]]_bloc.dart';
+
+@freezed
+abstract class [[feature_name.capitalize()]]State with _$[[feature_name.capitalize()]]State {
+  const factory [[feature_name.capitalize()]]State.initial() = Initial;
+  const factory [[feature_name.capitalize()]]State.loading() = Loading;
+  const factory [[feature_name.capitalize()]]State.loaded([[feature_name.capitalize()]] items) = Loaded;
+  const factory [[feature_name.capitalize()]]State.error(String message) = Error;
+}

generators/static/templates/component/component_widget_template.jinja

@@ -0,0 +1,113 @@
+/*
+ * Reusable component widget template
+ * Generates a StatelessWidget with BLoC integration for:
+ * - Reusable UI components across the app
+ * - State management through BLoC pattern
+ * - Clean separation of concerns
+ *
+ * Default handling for all BLoC states (Initial, Loading, Loaded, Error).
+ * Replace placeholder copy and layout with your real UI.
+ */
+
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart' hide ErrorWidget;
+import 'package:flutter_bloc/flutter_bloc.dart';
+[[bloc_import]]
+import 'package:[[project_name]]/widgets/common/error_widget.dart';
+import 'package:[[project_name]]/widgets/common/loading_widget.dart';
+import 'package:[[project_name]]/widgets/common/unknown_state_widget.dart';
+{% if failure_class %}
+import 'package:[[project_name]]/core/errors/error_localizer.dart';
+{% endif %}
+{% if failure_class and domain_model_name %}
+import 'package:[[project_name]]/[[domain_import_prefix]]/model/[[domain_model_name]].dart';
+import 'package:[[project_name]]/[[domain_import_prefix]]/model/[[domain_model_name]]_failure.dart';
+{% endif %}
+
+class [[pascal_name]]Component extends StatelessWidget {
+  const [[pascal_name]]Component({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return BlocBuilder<[[bloc_name]], [[state_name]]>(
+      builder: (BuildContext context, [[state_name]] state) {
+{% if failure_class and domain_model_name %}
+        return switch (state) {
+          Initial() => const Center(
+                child: Text('In attesa del primo caricamento'),
+              ),
+          Loading() => const LoadingWidget(),
+          Loaded(
+            item: final [[domain_model_pascal]] item,
+            isReloading: final bool isReloading,
+          ) =>
+            Stack(
+                alignment: Alignment.center,
+                children: <Widget>[
+                  Padding(
+                    padding: const EdgeInsets.all(16),
+                    child: Center(child: Text(item.toString())),
+                  ),
+                  if (isReloading)
+                    Positioned(
+                      top: 0,
+                      left: 0,
+                      right: 0,
+                      child: CLinearProgressIndicator.primary(),
+                    ),
+                ],
+              ),
+          Error(
+            failure: final [[failure_class]] failure,
+          ) =>
+            ErrorWidget(
+                message: ErrorLocalizer.localize[[failure_class]](context, failure),
+              ),
+          _ => const UnknownStateWidget(),
+        };
+{% elif failure_class %}
+        return switch (state) {
+          Initial() => const Center(
+                child: Text('In attesa del primo caricamento'),
+              ),
+          Loading() => const LoadingWidget(),
+          Loaded(:final item, :final isReloading) => Stack(
+                alignment: Alignment.center,
+                children: <Widget>[
+                  Padding(
+                    padding: const EdgeInsets.all(16),
+                    child: Center(child: Text(item.toString())),
+                  ),
+                  if (isReloading)
+                    Positioned(
+                      top: 0,
+                      left: 0,
+                      right: 0,
+                      child: CLinearProgressIndicator.primary(),
+                    ),
+                ],
+              ),
+          Error(:final failure) => ErrorWidget(
+                message: ErrorLocalizer.localize[[failure_class]](context, failure),
+              ),
+          _ => const UnknownStateWidget(),
+        };
+{% else %}
+        return switch (state) {
+          Initial() => const Center(
+                child: Text('In attesa del primo caricamento'),
+              ),
+          Loading() => const LoadingWidget(),
+          Loaded() => const Center(
+                child: Text('Contenuto caricato (sostituisci con la tua UI)'),
+              ),
+          Error(:final message) => ErrorWidget(
+                message: 'Errore: $message',
+              ),
+          _ => const UnknownStateWidget(),
+        };
+{% endif %}
+      },
+    );
+  }
+}

generators/static/templates/core/bloc/base_form_bloc_template.jinja

@@ -0,0 +1,32 @@
+import 'package:bloc/bloc.dart';
+import 'package:dartz/dartz.dart';
+
+/// Base BLoC per form con pattern comuni di submit.
+///
+/// Estende [Bloc] e fornisce helper methods specifici per gestire
+/// il submit di form con validazione e gestione errori.
+///
+/// **Pattern utilizzato**: Template Method Pattern
+///
+/// **Type Parameters**:
+/// - [Event]: Tipo degli eventi del BLoC
+/// - [State]: Tipo dello stato del BLoC
+/// - [Failure]: Tipo dei failure (da dartz Either)
+/// - [Success]: Tipo del valore di successo
+abstract class BaseFormBloc<Event, State, Failure, Success> extends Bloc<Event, State> {
+  BaseFormBloc(super.initialState);
+
+  /// Helper per gestire submit con Either<Failure, Success> direttamente nello stato.
+  /// Utile quando lo stato contiene Option<Either<Failure, Success>>.
+  Future<void> handleFormSubmitWithEither<SuccessType>(
+    Emitter<State> emit,
+    Future<Either<Failure, SuccessType>> operation,
+    State Function() getSubmittingState,
+    State Function(Either<Failure, SuccessType> result) getResultState,
+  ) async {
+    emit(getSubmittingState());
+
+    final Either<Failure, SuccessType> result = await operation;
+    emit(getResultState(result));
+  }
+}

generators/static/templates/core/errors/error_localizer_template.jinja

@@ -0,0 +1,61 @@
+/*
+ * ErrorLocalizer - Centralized error message handler
+ *
+ * This is the single point where all user-facing error messages are defined.
+ * Each domain failure type has a dedicated localize method with
+ * domain-customized messages.
+ *
+ * TO USE LOCALIZATION (l10n):
+ *   Import your AppLocalizations and replace the hardcoded strings, e.g.:
+ *     final l10n = AppLocalizations.of(context)!;
+ *     return switch (failure) {
+ *       Unexpected() => l10n.errorUnknown,
+ *       NotFound() => l10n.errorModelNotFound,
+ *       ...
+ *     };
+ */
+
+import 'package:flutter/material.dart';
+{% if has_login -%}
+import 'package:[[project_name]]/domain/auth/model/auth_failure.dart' as auth_failure;
+{% endif -%}
+{% for df in domain_failures -%}
+import 'package:[[df.import_path]]' as [[df.alias]];
+{% endfor %}
+class ErrorLocalizer {
+{%- if has_login %}
+
+  /// Map AuthFailure to user-friendly error message
+  static String localizeAuthFailure(BuildContext context, auth_failure.AuthFailure failure) {
+    return switch (failure) {
+      auth_failure.CancelledByUser() => 'Cancelled',
+      auth_failure.ServerError() => 'Server error',
+      auth_failure.EmailAlreadyInUse() => 'Email already in use',
+      auth_failure.InvalidEmailAndPasswordCombination() => 'Invalid email and password combination',
+      _ => failure.toString(),
+    };
+  }
+{% endif -%}
+{%- if domain_failures %}
+{% for df in domain_failures %}
+  /// Map [[df.failure_class]] to user-friendly error message
+  static String localize[[df.failure_class]](BuildContext context, [[df.alias]].[[df.failure_class]] failure) {
+    return switch (failure) {
+      [[df.alias]].Unexpected() => 'An unexpected error occurred',
+      [[df.alias]].InsufficientPermission() => 'Insufficient permissions',
+      [[df.alias]].UnableToUpdate() => '[[df.class_name]] update failed',
+      [[df.alias]].NotFound() => '[[df.class_name]] not found',
+      _ => failure.toString(),
+    };
+  }
+{% endfor -%}
+{%- elif not has_login %}
+  /// Maps a failure to a user-friendly error message.
+  ///
+  /// Domain-specific localize methods are added when new domain failures
+  /// are introduced (see integration-wiring subagent or docs/architecture/).
+  static String localizeFailure(BuildContext context, Object failure) {
+    return failure.toString();
+  }
+{% endif -%}
+}

generators/static/templates/core/infrastructure/base_mapper_template.jinja

@@ -0,0 +1,21 @@
+/// Base mapper that provides default implementations for common methods.
+/// Reduces boilerplate by eliminating duplication of toDomainList and toDtoList.
+abstract class BaseMapper<TDomain, TDto> {
+  /// Converts DTO to Domain Entity - must be implemented in each mapper
+  TDomain toDomain(TDto dto);
+
+  /// Converts Domain Entity to DTO - must be implemented in each mapper
+  TDto toDto(TDomain domain);
+
+  /// Converts a list of DTOs to a list of Domain Entities.
+  /// Default implementation delegates to [toDomain].
+  List<TDomain> toDomainList(List<TDto> dtos) {
+    return dtos.map((TDto dto) => toDomain(dto)).toList();
+  }
+
+  /// Converts a list of Domain Entities to a list of DTOs.
+  /// Default implementation delegates to [toDto].
+  List<TDto> toDtoList(List<TDomain> domains) {
+    return domains.map((TDomain domain) => toDto(domain)).toList();
+  }
+}

generators/static/templates/core/infrastructure/base_repository_mixin_template.jinja

@@ -0,0 +1,78 @@
+import 'package:dartz/dartz.dart';
+import 'package:[[project_name]]/core/infrastructure/repository_error_handler.dart';
+
+/// Mixin that provides common helper methods for repositories.
+///
+/// Eliminates duplicated code across repositories by implementing
+/// common patterns for API calls with centralized error handling.
+///
+/// **Type Parameter**:
+/// - [TFailure]: The failure type specific to the repository
+mixin BaseRepositoryMixin<TFailure> {
+  /// Helper for simple calls (service -> mapper -> domain).
+  ///
+  /// Handles:
+  /// - Service call execution
+  /// - DTO -> Domain mapping
+  /// - Error handling with conversion to [TFailure]
+  Future<Either<TFailure, TDomain>> handleSimpleCall<TDto, TDomain>({
+    required Future<TDto> Function() serviceCall,
+    required TDomain Function(TDto) mapToDomain,
+    required TFailure Function() onUnexpected,
+    required TFailure Function() onNotFound,
+    required TFailure Function() onInsufficientPermission,
+    TFailure Function()? onBadRequest,
+  }) {
+    return RepositoryErrorHandler.handleCall<TDomain, TFailure>(
+      call: () async {
+        final TDto dto = await serviceCall();
+        return mapToDomain(dto);
+      },
+      onUnexpected: onUnexpected,
+      onNotFound: onNotFound,
+      onInsufficientPermission: onInsufficientPermission,
+      onBadRequest: onBadRequest,
+    );
+  }
+
+  /// Helper for calls that return lists.
+  Future<Either<TFailure, List<TDomain>>> handleListCall<TDto, TDomain>({
+    required Future<List<TDto>> Function() serviceCall,
+    required List<TDomain> Function(List<TDto>) mapToDomainList,
+    required TFailure Function() onUnexpected,
+    required TFailure Function() onNotFound,
+    required TFailure Function() onInsufficientPermission,
+  }) {
+    return RepositoryErrorHandler.handleCall<List<TDomain>, TFailure>(
+      call: () async {
+        final List<TDto> dtos = await serviceCall();
+        return mapToDomainList(dtos);
+      },
+      onUnexpected: onUnexpected,
+      onNotFound: onNotFound,
+      onInsufficientPermission: onInsufficientPermission,
+    );
+  }
+
+  /// Helper for calls that return Unit (delete, update without response).
+  Future<Either<TFailure, Unit>> handleUnitCall({
+    required Future<void> Function() serviceCall,
+    required TFailure Function() onUnexpected,
+    required TFailure Function() onNotFound,
+    required TFailure Function() onInsufficientPermission,
+    TFailure Function()? onBadRequest,
+    TFailure Function()? onUnableToDelete,
+    TFailure Function()? onUnableToUpdate,
+  }) {
+    return RepositoryErrorHandler.handleCall<Unit, TFailure>(
+      call: () async {
+        await serviceCall();
+        return unit;
+      },
+      onUnexpected: onUnexpected,
+      onNotFound: onNotFound,
+      onInsufficientPermission: onInsufficientPermission,
+      onBadRequest: onBadRequest ?? onUnableToDelete ?? onUnableToUpdate,
+    );
+  }
+}

generators/static/templates/core/infrastructure/firebase_injectable_module_template.jinja

@@ -0,0 +1,11 @@
+// import __STRING_0__;
+import 'package:injectable/injectable.dart';
+// import __STRING_2__;
+
+@module
+abstract class FirebaseInjectableModule {
+  // @lazySingleton
+  // FirebaseAuth get firebaseAuth => FirebaseAuth.instance;
+  // @lazySingleton
+  // Firestore get firestore => Firestore.instance;
+}

generators/static/templates/core/infrastructure/firestore_helpers_template.jinja

@@ -0,0 +1,22 @@
+// import __STRING_0__;
+// import __STRING_1__;
+// import __STRING_2__;
+// import __STRING_3__;
+
+// extension FirestoreX on Firestore {
+//   /// The user must be already authenticated when calling this method.
+//   /// Otherwise, throws [NotAuthenticatedError].
+//   Future<DocumentReference> userDocument() async {
+//     final userOption = await getIt<IAuthFacade>().getSignedInUser();
+//     final user = userOption.getOrElse(() => throw NotAuthenticatedError());
+//     return Firestore.instance
+//         .collection(__STRING_4__)
+//         .document(user.id.getOrCrash());
+//   }
+// }
+
+// extension DocumentReferenceX on DocumentReference {
+//   CollectionReference get noteCollection => collection(__STRING_5__);
+
+//   /// Nested subcollection under a [noteCollection]__STRING_6__todos');
+// }

generators/static/templates/core/infrastructure/repository_error_handler_template.jinja

@@ -0,0 +1,44 @@
+import 'package:dartz/dartz.dart';
+import 'package:dio/dio.dart';
+
+/// Centralized error handler for repository operations.
+/// Maps DioException HTTP status codes to typed failure objects.
+class RepositoryErrorHandler {
+  /// Executes a repository call and maps errors to [TFailure] automatically.
+  static Future<Either<TFailure, T>> handleCall<T, TFailure>({
+    required Future<T> Function() call,
+    required TFailure Function() onUnexpected,
+    required TFailure Function() onNotFound,
+    required TFailure Function() onInsufficientPermission,
+    TFailure Function()? onBadRequest,
+    TFailure Function()? onUnauthorized,
+  }) async {
+    try {
+      final T result = await call();
+      return right(result);
+    } on DioException catch (e, _) {
+      final int? statusCode = e.response?.statusCode;
+
+      switch (statusCode) {
+        case 400:
+          if (onBadRequest != null) {
+            return left(onBadRequest());
+          }
+          return left(onUnexpected());
+        case 401:
+          if (onUnauthorized != null) {
+            return left(onUnauthorized());
+          }
+          return left(onInsufficientPermission());
+        case 403:
+          return left(onInsufficientPermission());
+        case 404:
+          return left(onNotFound());
+        default:
+          return left(onUnexpected());
+      }
+    } on Object catch (e) {
+      return left(onUnexpected());
+    }
+  }
+}

generators/static/templates/core/model/common_interfaces_template.jinja

@@ -0,0 +1,3 @@
+abstract class IValidatable {
+  bool isValid();
+}

generators/static/templates/core/model/entity_template.jinja

@@ -0,0 +1,5 @@
+import 'package:[[project_name]]/core/model/value_objects.dart';
+
+abstract class IEntity {
+  UniqueId get id;
+}

generators/static/templates/core/model/errors_template.jinja

@@ -0,0 +1,15 @@
+import 'package:[[project_name]]/core/model/failures.dart';
+
+class NotAuthenticatedError extends Error {}
+
+class UnexpectedValueError extends Error {
+  final ValueFailure<dynamic> valueFailure;
+
+  UnexpectedValueError(this.valueFailure);
+
+  @override
+  String toString() {
+    const String explanation = 'Encountered a ValueFailure at an unrecoverable point. Terminating.';
+    return Error.safeToString('[[explanation]] Failure was: [[valueFailure]]');
+  }
+}

generators/static/templates/core/model/failures_template.jinja

@@ -0,0 +1,97 @@
+/*
+ * Core failure types for domain validation and errors
+ * Defines common failure patterns used throughout the application:
+ * - ValueFailure: For value object validation failures
+ * - Domain-specific failures for business logic errors
+ * 
+ * This provides a comprehensive error handling system that distinguishes
+ * between validation errors and business logic errors
+ */
+
+import 'package:flutter/material.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'failures.freezed.dart';
+
+/* Used if the validation of ValueObjects within the domain fails
+ * Example:
+ * 
+ * Note({required Description description})
+ * 
+ * Description extends a ValueObject<String> and has a validator that ensures, for example, that the string is not empty.
+ * If validation fails, a ValueFailure<String> is returned with the reason for the failure.
+ * 
+ * NOTE:  All domain ValueObjects extend the ValueObject<T> defined in core/value_objects.dart
+ *        Each domain ValueObject has a specific validator in core/value_validators.dart
+ *        Validators return an Either<ValueFailure<T>, T> representing the result of the validation.
+ *        If validation fails, a ValueFailure<T> is returned with the reason for the failure.
+ *        If validation succeeds, the valid value of type T is returned.
+ * 
+ *        The Failures defined in the domain folder (e.g. note_failure.dart) are instead used to represent specific errors
+ *        that can occur during the execution of operations in the domain (e.g. error while saving a note).
+ *        These Failures are used to handle errors at the application level and not for data validation.
+ */
+
+@freezed
+abstract class ValueFailure<T> with _$ValueFailure<T> {
+  const factory ValueFailure.exceedingLength({required T failedValue, required int max}) = ExceedingLength<T>;
+  const factory ValueFailure.empty({required T failedValue}) = Empty<T>;
+  const factory ValueFailure.multiline({required T failedValue}) = Multiline<T>;
+  const factory ValueFailure.numberTooLarge({required T failedValue, required num max}) = NumberTooLarge<T>;
+  const factory ValueFailure.listTooLong({required T failedValue, required int max}) = ListTooLong<T>;
+  const factory ValueFailure.invalidEmail({required T failedValue}) = InvalidEmail<T>;
+  const factory ValueFailure.shortPassword({required T failedValue}) = ShortPassword<T>;
+  const factory ValueFailure.invalidPhotoUrl({required T failedValue}) = InvalidPhotoUrl<T>;
+  const factory ValueFailure.passwordsDoNotMatch({required T failedValue}) = PasswordsDoNotMatch<T>;
+}
+
+/*
+ * TO USE LOCALIZATION (l10n):
+ *   Import your AppLocalizations and replace the hardcoded strings, e.g.:
+ *     final l10n = AppLocalizations.of(context)!;
+ *     return switch (failure) {
+ *       ExceedingLength<T>() => l10n.errorMaxLengthExceeded,
+ *       Empty<T>() => l10n.errorEmpty,
+ *       Multiline<T>() => l10n.errorMultiline,
+ *       NumberTooLarge<T>() => l10n.errorNumberTooLarge,
+ *       ListTooLong<T>() => l10n.errorListTooLong,
+ *       InvalidEmail<T>() => l10n.errorInvalidEmail,
+ *       ShortPassword<T>() => l10n.errorShortPassword,
+ *       InvalidPhotoUrl<T>() => l10n.errorInvalidPhotoUrl,
+ *       PasswordsDoNotMatch<T>() => l10n.errorPasswordsDoNotMatch,
+ *       ...
+ *       _ => 'Error',
+ *     };
+ */
+
+extension ValueFailureX<T> on ValueFailure<T> {
+  String title(BuildContext context, ValueFailure<T> failure) {
+    return switch (failure) {
+      ExceedingLength<T>() => 'Max length exceeded',
+      Empty<T>() => 'Empty',
+      Multiline<T>() => 'Multiline',
+      NumberTooLarge<T>() => 'Number too large',
+      ListTooLong<T>() => 'List too long',
+      InvalidEmail<T>() => 'Invalid email',
+      ShortPassword<T>() => 'Short password',
+      InvalidPhotoUrl<T>() => 'Invalid photo URL',
+      PasswordsDoNotMatch<T>() => 'Passwords do not match',
+      _ => 'Error',
+    };
+  }
+
+  String message(BuildContext context, ValueFailure<T> failure) {
+    return switch (failure) {
+      ExceedingLength<T>() => 'The value must be less than ${failure.max}',
+      Empty<T>() => 'The value cannot be empty',
+      Multiline<T>() => 'The value cannot contain multiple lines',
+      NumberTooLarge<T>() => 'The value must be less than ${failure.max}',
+      ListTooLong<T>() => 'The value must be less than ${failure.max}',
+      InvalidEmail<T>() => 'The value must be a valid email',
+      ShortPassword<T>() => 'The value must be at least 6 characters',
+      InvalidPhotoUrl<T>() => 'The value must be a valid photo URL',
+      PasswordsDoNotMatch<T>() => 'The passwords do not match',
+      _ => 'Error',
+    };
+  }
+}