@hichchi/nest-connector 0.0.1-beta.2 → 0.0.1

package/auth.cjs.js

@@ -0,0 +1,1283 @@
+'use strict';
+
+var error_responses = require('./error.responses.cjs.js');
+
+/**
+ * Authentication Endpoints Enum
+ *
+ * This enum defines all authentication-related endpoints used in the application.
+ * Each value represents a specific API endpoint path segment for authentication operations.
+ *
+ * Enum Values:
+ * - `SIGN_UP`: User registration endpoint.
+ * - `SIGN_IN`: Local authentication endpoint.
+ * - `GOOGLE_SIGN_IN`: Initiates Google OAuth flow.
+ * - `GOOGLE_CALLBACK`: Callback endpoint for Google OAuth.
+ * - `AUTHENTICATE_SOCIAL`: Process social authentication data.
+ * - `REFRESH_TOKEN`: Obtain a new access token using refresh token.
+ * - `REQUEST_PASSWORD_RESET`: Request password reset link/code.
+ * - `RESET_PASSWORD_VERIFY`: Verify password reset token/code.
+ * - `RESEND_EMAIL_VERIFICATION`: Send verification email again.
+ * - `VERIFY_EMAIL`: Confirm email verification.
+ * - `RESET_PASSWORD`: Set new password after verification.
+ * - `ME`: Get current authenticated user info.
+ * - `CHANGE_PASSWORD`: Update user's password.
+ * - `SIGN_OUT`: End user session/invalidate tokens.
+ */
+exports.AuthEndpoint = void 0;
+(function (AuthEndpoint) {
+  /**
+   * User registration endpoint
+   *
+   * Handles new user account creation with provided credentials and profile information.
+   * This endpoint accepts user registration data including email, password, and optional
+   * profile details, then creates a new account in the system.
+   *
+   * The endpoint may also trigger email verification, depending on configuration.
+   */
+  AuthEndpoint["SIGN_UP"] = "sign-up";
+  /**
+   * Local authentication endpoint
+   *
+   * Authenticates users with username/email and password, returning authentication tokens.
+   * This endpoint validates the provided credentials against stored user data and,
+   * if valid, generates and returns access and refresh tokens for the authenticated session.
+   *
+   * The endpoint also sets authentication cookies if configured to do so.
+   */
+  AuthEndpoint["SIGN_IN"] = "sign-in";
+  /**
+   * Initiates Google OAuth flow
+   *
+   * Redirects users to Google's authentication page to begin the OAuth process.
+   * This endpoint starts the OAuth 2.0 flow with Google by redirecting the user
+   * to Google's authentication page. It accepts a redirectUrl parameter that
+   * specifies where to redirect after successful authentication.
+   *
+   * The URL is stored in the OAuth state parameter to be used by the callback endpoint.
+   *
+   * @see {@link GOOGLE_CALLBACK} - The endpoint that handles the OAuth callback
+   */
+  AuthEndpoint["GOOGLE_SIGN_IN"] = "google-sign-in";
+  /**
+   * Callback endpoint for Google OAuth
+   *
+   * Receives and processes authentication data after successful Google authentication.
+   * This endpoint is called by Google's OAuth service after the user has successfully
+   * authenticated. It extracts the authentication code, exchanges it for tokens,
+   * and redirects the user to the original redirectUrl specified in the initial request,
+   * passing the access token as a query parameter.
+   *
+   * @see {@link GOOGLE_SIGN_IN} - The endpoint that initiates the OAuth flow
+   */
+  AuthEndpoint["GOOGLE_CALLBACK"] = "google-callback";
+  /**
+   * Get authentication response from an existing token
+   *
+   * This endpoint allows clients to retrieve a complete authentication response
+   * using a previously issued JWT access token. It verifies the token,
+   * retrieves the associated user information, generates new tokens,
+   * and returns comprehensive authentication data.
+   *
+   * This is useful for clients that need to exchange an existing token
+   * for a complete authentication response containing user details and session information.
+   */
+  AuthEndpoint["GET_AUTH_RESPONSE"] = "get-auth-response";
+  /**
+   * Obtain a new access token using refresh token
+   *
+   * Allows clients to get a new access token without requiring re-authentication.
+   * This endpoint accepts a valid refresh token and, if the token is valid and
+   * not expired, issues new access and refresh tokens for continued authentication.
+   *
+   * This enables longer user sessions without requiring frequent logins while still
+   * maintaining security by using short-lived access tokens.
+   */
+  AuthEndpoint["REFRESH_TOKEN"] = "refresh-token";
+  /**
+   * Request password reset link/code
+   *
+   * Initiates the password recovery process by sending reset instructions.
+   * This endpoint accepts an email address, validates that it belongs to a registered
+   * user, and sends a password reset link or code to that email address. For security,
+   * it typically returns a success response regardless of whether the email exists
+   * in the system to prevent email enumeration attacks.
+   */
+  AuthEndpoint["REQUEST_PASSWORD_RESET"] = "request-password-reset";
+  /**
+   * Verify password reset token/code
+   *
+   * Validates the reset token before allowing password change.
+   * This endpoint accepts a password reset token and verifies its validity without
+   * actually resetting the password. This allows client applications to verify
+   * a token before showing the password reset form to the user, improving user experience
+   * by providing immediate feedback about expired or invalid tokens.
+   */
+  AuthEndpoint["RESET_PASSWORD_VERIFY"] = "reset-password-verify";
+  /**
+   * Send verification email again
+   *
+   * Allows users to request a new verification email if the original expired or was lost.
+   * This endpoint accepts an email address and, if it belongs to an unverified user,
+   * generates a new verification token and sends a verification email to that address.
+   * For security reasons, it typically returns a success response regardless of whether
+   * the email exists or is already verified.
+   */
+  AuthEndpoint["RESEND_EMAIL_VERIFICATION"] = "resend-email-verification";
+  /**
+   * Confirm email verification
+   *
+   * Processes the verification link clicked from email to confirm user's email address.
+   * This endpoint is typically accessed via a link in the verification email sent to users.
+   * It accepts a verification token, validates it, marks the user's email as verified if
+   * the token is valid, and redirects the user to a configured URL with a query parameter
+   * indicating whether the verification was successful.
+   */
+  AuthEndpoint["VERIFY_EMAIL"] = "verify-email";
+  /**
+   * Set new password after verification
+   *
+   * Allows users to create a new password after identity verification.
+   * This endpoint accepts a valid password reset token and a new password, then
+   * updates the user's password if the token is valid. It should typically be called
+   * after the token has been verified using the RESET_PASSWORD_VERIFY endpoint.
+   * The endpoint invalidates the reset token after successful password reset to
+   * prevent reuse.
+   */
+  AuthEndpoint["RESET_PASSWORD"] = "reset-password";
+  /**
+   * Get current authenticated user info
+   *
+   * Returns the profile and relevant information for the currently authenticated user.
+   * This endpoint requires a valid JWT token and returns the user information associated
+   * with that token. It allows client applications to retrieve up-to-date user data
+   * for displaying profile information, checking permissions, or verifying authentication
+   * status.
+   */
+  AuthEndpoint["ME"] = "me";
+  /**
+   * Update user's password
+   *
+   * Allows authenticated users to change their password (requires current password).
+   * This endpoint requires a valid JWT token and accepts both the current password
+   * (for verification) and the new password. It validates the current password against
+   * the stored credentials, and if valid, updates the user's password to the new value.
+   * This endpoint is used for routine password changes by authenticated users, not for
+   * password reset after forgetting credentials.
+   */
+  AuthEndpoint["CHANGE_PASSWORD"] = "change-password";
+  /**
+   * End user session/invalidate tokens
+   *
+   * Handles user logout by invalidating active authentication tokens.
+   * This endpoint requires a valid JWT token and invalidates the current authentication
+   * session by blacklisting or removing the refresh token, clearing authentication cookies
+   * if they're being used, and performing any other cleanup necessary to terminate the
+   * user session securely. After calling this endpoint, client applications should also
+   * remove any locally stored tokens.
+   */
+  AuthEndpoint["SIGN_OUT"] = "sign-out";
+})(exports.AuthEndpoint || (exports.AuthEndpoint = {}));
+
+/**
+ * Authentication Error Response Codes Enum
+ *
+ * This enum defines all error response codes related to authentication operations.
+ * Each code represents a specific error condition that can occur during authentication
+ * processes. The naming convention includes HTTP status codes (e.g., 400, 401, 403)
+ * followed by a descriptive identifier.
+ *
+ * The codes are organized by HTTP status categories:
+ * - `400` series: Client errors (Bad Request, Unauthorized, Forbidden, Not Found, Conflict)
+ * - `500` series: Server errors (Internal Server Error, Not Implemented)
+ *
+ * Each prefix (`AUTH_` or `USER_`) indicates the domain of the error:
+ * - `AUTH_`: Authentication service errors
+ * - `USER_`: User management errors
+ *
+ * Enum Values:
+ * - `AUTH_400_EMAIL_ALREADY_VERIFIED`: Email already verified error.
+ * - `AUTH_400_REDIRECT_URL_REQUIRED`: Redirect URL required error.
+ * - `AUTH_401_CORS`: CORS error.
+ * - `AUTH_401_INVALID_USERNAME_PASSWORD`: Invalid username/password combination.
+ * - `AUTH_401_INVALID_EMAIL_PASSWORD`: Invalid email/password combination.
+ * - `AUTH_401_INVALID_PASSWORD`: Invalid password.
+ * - `AUTH_401_NOT_LOGGED_IN`: User not logged in.
+ * - `AUTH_401_NOT_LOCAL`: Non-local authentication attempt.
+ * - `AUTH_401_SOCIAL_SIGN_IN`: Social sign-in error.
+ * - `AUTH_401_EMAIL_NOT_VERIFIED`: Email not verified.
+ * - `AUTH_401_NOT_ACTIVE`: Account not active.
+ * - `AUTH_401_TOKEN_NOT_SET`: Authentication token not set.
+ * - `AUTH_401_REFRESH_TOKEN_NOT_SET`: Refresh token not set.
+ * - `AUTH_401_INVALID_TOKEN`: Invalid authentication token.
+ * - `AUTH_401_EXPIRED_TOKEN`: Expired authentication token.
+ * - `AUTH_401_INVALID_VERIFICATION_TOKEN`: Invalid email verification token.
+ * - `AUTH_401_INVALID_PASSWORD_RESET_TOKEN`: Invalid password reset token.
+ * - `AUTH_401_INVALID_REFRESH_TOKEN`: Invalid refresh token.
+ * - `AUTH_401_EXPIRED_REFRESH_TOKEN`: Expired refresh token.
+ * - `AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN`: Expired or invalid password reset token.
+ * - `AUTH_401_UNKNOWN`: Unknown authentication error.
+ * - `AUTH_403_PENDING`: Pending account approval.
+ * - `AUTH_403_ACCOUNT_DISABLED`: Account disabled.
+ * - `AUTH_403_ROLE_FORBIDDEN`: Insufficient role.
+ * - `AUTH_403_PERMISSION_FORBIDDEN`: Insufficient role permissions.
+ * - `AUTH_404_EMAIL`: Email not found.
+ * - `AUTH_500_SIGN_UP`: Sign up error.
+ * - `AUTH_500_SOCIAL_SIGN_UP`: Social sign up error.
+ * - `AUTH_500_SIGN_IN`: Sign in error.
+ * - `AUTH_500_SOCIAL_SIGN_IN`: Social sign in error.
+ * - `AUTH_500_SOCIAL_SIGN_IN_CALLBACK`: Social sign in callback error.
+ * - `AUTH_500_SIGN_OUT`: Sign out error.
+ * - `AUTH_500_SEND_EMAIL_VERIFICATION`: Email verification sending error.
+ * - `AUTH_500_VERIFY_EMAIL`: Email verification error.
+ * - `AUTH_500_REQUEST_PASSWORD_RESET`: Password reset request error.
+ * - `AUTH_500_PASSWORD_RESET`: Password reset error.
+ * - `AUTH_500`: Generic authentication error.
+ * - `AUTH_501_NOT_IMPLEMENTED`: Feature not implemented.
+ * - `USER_400_EMPTY_EMAIL`: Empty email field.
+ * - `USER_400_EMPTY_FNAME`: Empty first name field.
+ * - `USER_400_EMPTY_LNAME`: Empty last name field.
+ * - `USER_400_EMPTY_UNAME`: Empty username field.
+ * - `USER_400_EMPTY_PASSWORD`: Empty password field.
+ * - `USER_400_INVALID_EMAIL`: Invalid email format.
+ * - `USER_400_NOT_EMPTY_UNAME`: Username should not be empty.
+ * - `USER_400_NOT_EMPTY_PASSWORD`: Password should not be empty.
+ * - `USER_400_NOT_EMPTY_SALT`: Salt should not be empty.
+ * - `USER_403_SIGN_UP`: Sign up forbidden.
+ * - `USER_404_ID`: User not found.
+ * - `USER_409_EXIST_UNAME`: Username already exists.
+ * - `USER_500_CREATE`: User creation error.
+ */
+exports.AuthErrorResponseCode = void 0;
+(function (AuthErrorResponseCode) {
+  /**
+   * Email already verified error (400 Bad Request)
+   *
+   * Occurs when attempting to verify an email that has already been verified.
+   */
+  AuthErrorResponseCode["AUTH_400_EMAIL_ALREADY_VERIFIED"] = "AUTH_400_EMAIL_ALREADY_VERIFIED";
+  /**
+   * Redirect URL required error (400 Bad Request)
+   *
+   * Occurs when a redirect URL is required for an operation but not provided.
+   */
+  AuthErrorResponseCode["AUTH_400_REDIRECT_URL_REQUIRED"] = "AUTH_400_REDIRECT_URL_REQUIRED";
+  /**
+   * CORS error (401 Unauthorized)
+   *
+   * Occurs when a cross-origin request is not allowed due to security restrictions.
+   */
+  AuthErrorResponseCode["AUTH_401_CORS"] = "AUTH_401_CORS";
+  /**
+   * Invalid username/password combination (401 Unauthorized)
+   *
+   * Occurs when authentication fails due to incorrect username and password combination.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_USERNAME_PASSWORD"] = "AUTH_401_INVALID_USERNAME_PASSWORD";
+  /**
+   * Invalid email/password combination (401 Unauthorized)
+   *
+   * Occurs when authentication fails due to incorrect email and password combination.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_EMAIL_PASSWORD"] = "AUTH_401_INVALID_EMAIL_PASSWORD";
+  /**
+   * Invalid password (401 Unauthorized)
+   *
+   * Occurs when authentication fails due to incorrect password.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_PASSWORD"] = "AUTH_401_INVALID_PASSWORD";
+  /**
+   * User not logged in (401 Unauthorized)
+   *
+   * Occurs when accessing a protected resource without authentication.
+   */
+  AuthErrorResponseCode["AUTH_401_NOT_LOGGED_IN"] = "AUTH_401_NOT_LOGGED_IN";
+  /**
+   * Non-local authentication attempt (401 Unauthorized)
+   *
+   * Occurs when attempting to use local authentication methods for an account
+   * that was created using social authentication.
+   */
+  AuthErrorResponseCode["AUTH_401_NOT_LOCAL"] = "AUTH_401_NOT_LOCAL";
+  /**
+   * Social sign-in error (401 Unauthorized)
+   *
+   * Occurs when there is an issue with social authentication process.
+   */
+  AuthErrorResponseCode["AUTH_401_SOCIAL_SIGN_IN"] = "AUTH_401_SOCIAL_SIGN_IN";
+  /**
+   * Email not verified (401 Unauthorized)
+   *
+   * Occurs when attempting to access resources that require email verification
+   * before the user has verified their email address.
+   */
+  AuthErrorResponseCode["AUTH_401_EMAIL_NOT_VERIFIED"] = "AUTH_401_EMAIL_NOT_VERIFIED";
+  /**
+   * Account not active (401 Unauthorized)
+   *
+   * Occurs when attempting to authenticate with an inactive account.
+   */
+  AuthErrorResponseCode["AUTH_401_NOT_ACTIVE"] = "AUTH_401_NOT_ACTIVE";
+  /**
+   * Authentication token not set (401 Unauthorized)
+   *
+   * Occurs when no authentication token is provided for a protected resource.
+   */
+  AuthErrorResponseCode["AUTH_401_TOKEN_NOT_SET"] = "AUTH_401_TOKEN_NOT_SET";
+  /**
+   * Refresh token not set (401 Unauthorized)
+   *
+   * Occurs when attempting to refresh an access token without providing a refresh token.
+   */
+  AuthErrorResponseCode["AUTH_401_REFRESH_TOKEN_NOT_SET"] = "AUTH_401_REFRESH_TOKEN_NOT_SET";
+  /**
+   * Invalid authentication token (401 Unauthorized)
+   *
+   * Occurs when the provided authentication token is malformed or invalid.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_TOKEN"] = "AUTH_401_INVALID_TOKEN";
+  /**
+   * Expired authentication token (401 Unauthorized)
+   *
+   * Occurs when the provided authentication token has expired.
+   */
+  AuthErrorResponseCode["AUTH_401_EXPIRED_TOKEN"] = "AUTH_401_EXPIRED_TOKEN";
+  /**
+   * Invalid email verification token (401 Unauthorized)
+   *
+   * Occurs when attempting to verify an email with an invalid token.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_VERIFICATION_TOKEN"] = "AUTH_401_INVALID_VERIFICATION_TOKEN";
+  /**
+   * Invalid password reset token (401 Unauthorized)
+   *
+   * Occurs when attempting to reset a password with an invalid token.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_PASSWORD_RESET_TOKEN"] = "AUTH_401_INVALID_PASSWORD_RESET_TOKEN";
+  /**
+   * Invalid refresh token (401 Unauthorized)
+   *
+   * Occurs when attempting to refresh an access token with an invalid refresh token.
+   */
+  AuthErrorResponseCode["AUTH_401_INVALID_REFRESH_TOKEN"] = "AUTH_401_INVALID_REFRESH_TOKEN";
+  /**
+   * Expired refresh token (401 Unauthorized)
+   *
+   * Occurs when attempting to refresh an access token with an expired refresh token.
+   */
+  AuthErrorResponseCode["AUTH_401_EXPIRED_REFRESH_TOKEN"] = "AUTH_401_EXPIRED_REFRESH_TOKEN";
+  /**
+   * Expired or invalid password reset token (401 Unauthorized)
+   *
+   * Occurs when attempting to reset a password with a token that is either invalid or expired.
+   */
+  AuthErrorResponseCode["AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN"] = "AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN";
+  /**
+   * Unknown authentication error (401 Unauthorized)
+   *
+   * Generic authentication error when the specific cause cannot be determined.
+   */
+  AuthErrorResponseCode["AUTH_401_UNKNOWN"] = "AUTH_401_UNKNOWN";
+  /**
+   * Pending account approval (403 Forbidden)
+   *
+   * Occurs when attempting to access resources with an account that is still pending approval.
+   */
+  AuthErrorResponseCode["AUTH_403_PENDING"] = "AUTH_403_PENDING";
+  /**
+   * Account disabled (403 Forbidden)
+   *
+   * Occurs when attempting to authenticate with a disabled account.
+   */
+  AuthErrorResponseCode["AUTH_403_ACCOUNT_DISABLED"] = "AUTH_403_ACCOUNT_DISABLED";
+  /**
+   * Insufficient role (403 Forbidden)
+   *
+   * Occurs when a user attempts to access a resource that requires higher privileges.
+   */
+  AuthErrorResponseCode["AUTH_403_ROLE_FORBIDDEN"] = "AUTH_403_ROLE_FORBIDDEN";
+  /**
+   * Insufficient role permissions (403 Forbidden)
+   *
+   * Occurs when a user attempts to access a resource that requires higher privileges.
+   */
+  AuthErrorResponseCode["AUTH_403_PERMISSION_FORBIDDEN"] = "AUTH_403_PERMISSION_FORBIDDEN";
+  AuthErrorResponseCode["AUTH_403_SUB_DOMAIN_NOT_ALLOWED"] = "AUTH_403_SUB_DOMAIN_NOT_ALLOWED";
+  /**
+   * Email not found (404 Not Found)
+   *
+   * Occurs when attempting operations on an email address that doesn't exist in the system.
+   */
+  AuthErrorResponseCode["AUTH_404_EMAIL"] = "AUTH_404_EMAIL";
+  /**
+   * Sign up error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error during the registration process.
+   */
+  AuthErrorResponseCode["AUTH_500_SIGN_UP"] = "AUTH_500_SIGN_UP";
+  /**
+   * Social sign up error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error during social registration.
+   */
+  AuthErrorResponseCode["AUTH_500_SOCIAL_SIGN_UP"] = "AUTH_500_SOCIAL_SIGN_UP";
+  /**
+   * Sign in error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error during the authentication process.
+   */
+  AuthErrorResponseCode["AUTH_500_SIGN_IN"] = "AUTH_500_SIGN_IN";
+  /**
+   * Social sign in error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error during social authentication.
+   */
+  AuthErrorResponseCode["AUTH_500_SOCIAL_SIGN_IN"] = "AUTH_500_SOCIAL_SIGN_IN";
+  /**
+   * Social sign in callback error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error processing the social authentication callback.
+   */
+  AuthErrorResponseCode["AUTH_500_SOCIAL_SIGN_IN_CALLBACK"] = "AUTH_500_SOCIAL_SIGN_IN_CALLBACK";
+  /**
+   * Sign out error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error during the sign-out process,
+   * such as failure to clear sessions, tokens, or other authentication data.
+   */
+  AuthErrorResponseCode["AUTH_500_SIGN_OUT"] = "AUTH_500_SIGN_OUT";
+  /**
+   * Email verification sending error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error sending the verification email.
+   */
+  AuthErrorResponseCode["AUTH_500_SEND_EMAIL_VERIFICATION"] = "AUTH_500_SEND_EMAIL_VERIFICATION";
+  /**
+   * Email verification error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error processing the email verification.
+   */
+  AuthErrorResponseCode["AUTH_500_VERIFY_EMAIL"] = "AUTH_500_VERIFY_EMAIL";
+  /**
+   * Password reset request error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error processing a password reset request.
+   */
+  AuthErrorResponseCode["AUTH_500_REQUEST_PASSWORD_RESET"] = "AUTH_500_REQUEST_PASSWORD_RESET";
+  /**
+   * Password reset error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error processing a password reset.
+   */
+  AuthErrorResponseCode["AUTH_500_PASSWORD_RESET"] = "AUTH_500_PASSWORD_RESET";
+  /**
+   * Generic authentication error (500 Internal Server Error)
+   *
+   * Generic server-side error in the authentication service.
+   */
+  AuthErrorResponseCode["AUTH_500"] = "AUTH_500";
+  /**
+   * Feature not implemented (501 Not Implemented)
+   *
+   * Occurs when attempting to use an authentication feature that is not yet implemented.
+   */
+  AuthErrorResponseCode["AUTH_501_NOT_IMPLEMENTED"] = "AUTH_501_NOT_IMPLEMENTED";
+  /**
+   * Empty email field (400 Bad Request)
+   *
+   * Occurs when the email field is required but not provided.
+   */
+  AuthErrorResponseCode["USER_400_EMPTY_EMAIL"] = "USER_400_EMPTY_EMAIL";
+  /**
+   * Empty first name field (400 Bad Request)
+   *
+   * Occurs when the first name field is required but not provided.
+   */
+  AuthErrorResponseCode["USER_400_EMPTY_FNAME"] = "USER_400_EMPTY_FNAME";
+  /**
+   * Empty last name field (400 Bad Request)
+   *
+   * Occurs when the last name field is required but not provided.
+   */
+  AuthErrorResponseCode["USER_400_EMPTY_LNAME"] = "USER_400_EMPTY_LNAME";
+  /**
+   * Empty username field (400 Bad Request)
+   *
+   * Occurs when the username field is required but not provided.
+   */
+  AuthErrorResponseCode["USER_400_EMPTY_UNAME"] = "USER_400_EMPTY_UNAME";
+  /**
+   * Empty password field (400 Bad Request)
+   *
+   * Occurs when the password field is required but not provided.
+   */
+  AuthErrorResponseCode["USER_400_EMPTY_PASSWORD"] = "USER_400_EMPTY_PASSWORD";
+  /**
+   * Invalid email format (400 Bad Request)
+   *
+   * Occurs when the provided email address doesn't match a valid email format.
+   */
+  AuthErrorResponseCode["USER_400_INVALID_EMAIL"] = "USER_400_INVALID_EMAIL";
+  /**
+   * Username should not be empty (400 Bad Request)
+   *
+   * Validation error when username is expected to have a value.
+   */
+  AuthErrorResponseCode["USER_400_NOT_EMPTY_UNAME"] = "USER_400_NOT_EMPTY_UNAME";
+  /**
+   * Password should not be empty (400 Bad Request)
+   *
+   * Validation error when password is expected to have a value.
+   */
+  AuthErrorResponseCode["USER_400_NOT_EMPTY_PASSWORD"] = "USER_400_NOT_EMPTY_PASSWORD";
+  /**
+   * Salt should not be empty (400 Bad Request)
+   *
+   * Validation error when password salt is expected to have a value.
+   */
+  AuthErrorResponseCode["USER_400_NOT_EMPTY_SALT"] = "USER_400_NOT_EMPTY_SALT";
+  /**
+   * Sign up forbidden (403 Forbidden)
+   *
+   * Occurs when registration is currently not allowed or restricted.
+   */
+  AuthErrorResponseCode["USER_403_SIGN_UP"] = "USER_403_SIGN_UP";
+  /**
+   * User not found (404 Not Found)
+   *
+   * Occurs when attempting operations on a user that doesn't exist.
+   */
+  AuthErrorResponseCode["USER_404_ID"] = "USER_404_ID";
+  /**
+   * Username already exists (409 Conflict)
+   *
+   * Occurs when attempting to create a user with a username that is already taken.
+   */
+  AuthErrorResponseCode["USER_409_EXIST_UNAME"] = "USER_409_EXIST_UNAME";
+  /**
+   * User creation error (500 Internal Server Error)
+   *
+   * Occurs when there is a server-side error creating a new user account.
+   */
+  AuthErrorResponseCode["USER_500_CREATE"] = "USER_500_CREATE";
+})(exports.AuthErrorResponseCode || (exports.AuthErrorResponseCode = {}));
+
+/**
+ * Enum representing authentication fields used for user identification.
+ *
+ * This enum is used to specify the type of identifier required
+ * for authentication processes. Each value represents a different
+ * approach to identifying users during authentication.
+ *
+ * Enum Values:
+ * - `USERNAME`: Authentication using the user's unique username.
+ * - `EMAIL`: Authentication using the user's email address.
+ * - `BOTH`: Authentication using either username or email address.
+ */
+exports.AuthField = void 0;
+(function (AuthField) {
+  /**
+   * Username-based authentication
+   *
+   * Users authenticate using their unique username.
+   * This is useful for applications where email addresses are not required
+   * or where users prefer to sign in with a chosen identifier.
+   */
+  AuthField["USERNAME"] = "username";
+  /**
+   * Email-based authentication
+   *
+   * Users authenticate using their email address.
+   * This is the most common approach as email addresses are unique
+   * and provide a way to contact users for account verification and recovery.
+   */
+  AuthField["EMAIL"] = "email";
+  /**
+   * Combined username/email authentication
+   *
+   * Users can authenticate using either their username or email address.
+   * This provides flexibility for users to sign in with whichever identifier they remember.
+   * Implementation requires checking both fields when authenticating.
+   */
+  AuthField["BOTH"] = "both";
+})(exports.AuthField || (exports.AuthField = {}));
+
+/**
+ * Enumeration representing the supported authentication methods.
+ *
+ * This enum provides two authentication strategies:
+ * - `COOKIE`: Utilizes cookies for storing and transmitting authentication tokens.
+ * - `JWT`: Employs JSON Web Tokens for authentication, typically passed via headers.
+ *
+ * Use this enum to specify the desired authentication method in your application.
+ */
+exports.AuthMethod = void 0;
+(function (AuthMethod) {
+  /**
+   * Cookie-based authentication
+   *
+   * Authentication tokens are stored in HTTP cookies and automatically included in requests.
+   * This method provides better security against XSS attacks but requires proper cookie configuration.
+   */
+  AuthMethod["COOKIE"] = "cookie";
+  /**
+   * JWT-based authentication
+   *
+   * Authentication tokens are typically stored client-side (localStorage/sessionStorage) and
+   * manually included in request headers. This method provides more flexibility but requires
+   * careful implementation to prevent token theft via XSS.
+   */
+  AuthMethod["JWT"] = "jwt";
+})(exports.AuthMethod || (exports.AuthMethod = {}));
+
+/**
+ * Authentication Success Response Codes Enum
+ *
+ * This enum defines success response codes specific to authentication operations.
+ * Each code represents a specific successful outcome from an authentication-related action.
+ * The naming convention includes HTTP status codes (e.g., 200, 201) for clarity.
+ *
+ * Enum Values:
+ * - `AUTH_201_ACCOUNT_CREATED_REQUIRE_VERIFY`: Account created but requires email verification.
+ * - `AUTH_201_ACCOUNT_CREATED`: Account successfully created without verification requirement.
+ * - `AUTH_201_EMAIL_VERIFIED`: Email address successfully verified.
+ * - `AUTH_200_EMAIL_VERIFICATION_SENT`: Email verification message sent successfully.
+ * - `AUTH_200_PASSWORD_RESET_EMAIL_SENT`: Password reset email sent successfully.
+ * - `AUTH_200_PASSWORD_RESET_TOKEN_VALID`: Password reset token validated successfully.
+ * - `AUTH_200_PASSWORD_RESET_SUCCESS`: Password reset completed successfully.
+ * - `AUTH_200_SIGNED_OUT`: User successfully signed out of the system.
+ */
+exports.AuthSuccessResponseCode = void 0;
+(function (AuthSuccessResponseCode) {
+  /**
+   * Account created but requires email verification
+   *
+   * Indicates a new user account was successfully created, but the user
+   * must verify their email address before they can fully access the system.
+   */
+  AuthSuccessResponseCode["AUTH_201_ACCOUNT_CREATED_REQUIRE_VERIFY"] = "AUTH_201_ACCOUNT_CREATED_REQUIRE_VERIFY";
+  /**
+   * Account successfully created without verification requirement
+   *
+   * Indicates a new user account was successfully created and is immediately
+   * active without requiring additional verification steps.
+   */
+  AuthSuccessResponseCode["AUTH_201_ACCOUNT_CREATED"] = "AUTH_201_ACCOUNT_CREATED";
+  /**
+   * Email address successfully verified
+   *
+   * Indicates that a user's email address has been successfully verified,
+   * enabling full access to account features that require verification.
+   */
+  AuthSuccessResponseCode["AUTH_201_EMAIL_VERIFIED"] = "AUTH_201_EMAIL_VERIFIED";
+  /**
+   * Email verification message sent successfully
+   *
+   * Indicates that an email containing verification instructions has been
+   * successfully sent to the user's email address.
+   */
+  AuthSuccessResponseCode["AUTH_200_EMAIL_VERIFICATION_SENT"] = "AUTH_200_EMAIL_VERIFICATION_SENT";
+  /**
+   * Password reset email sent successfully
+   *
+   * Indicates that an email containing password reset instructions has been
+   * successfully sent to the user's email address.
+   */
+  AuthSuccessResponseCode["AUTH_200_PASSWORD_RESET_EMAIL_SENT"] = "AUTH_200_PASSWORD_RESET_EMAIL_SENT";
+  /**
+   * Password reset token validated successfully
+   *
+   * Indicates that a password reset token provided by the user has been
+   * verified and is valid for proceeding with the password reset process.
+   */
+  AuthSuccessResponseCode["AUTH_200_PASSWORD_RESET_TOKEN_VALID"] = "AUTH_200_PASSWORD_RESET_TOKEN_VALID";
+  /**
+   * Password reset completed successfully
+   *
+   * Indicates that a user's password has been successfully reset and updated
+   * in the system. The user can now login with their new password.
+   */
+  AuthSuccessResponseCode["AUTH_200_PASSWORD_RESET_SUCCESS"] = "AUTH_200_PASSWORD_RESET_SUCCESS";
+  /**
+   * User signed out successfully
+   *
+   * Indicates that a user has been successfully signed out of the system,
+   * their session has been terminated, and authentication tokens have been
+   * invalidated. Any authentication cookies would also be cleared.
+   */
+  AuthSuccessResponseCode["AUTH_200_SIGNED_OUT"] = "AUTH_200_SIGNED_OUT";
+})(exports.AuthSuccessResponseCode || (exports.AuthSuccessResponseCode = {}));
+
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Enum representing the different authentication strategies available.
+ *
+ * This enum is used to specify the type of authentication mechanism
+ * employed within the application. Each strategy corresponds to a
+ * distinct method of authenticating users.
+ *
+ * Enum Values:
+ * - `LOCAL`: Authentication using local credentials (e.g., username and password).
+ * - `JWT`: Authentication using JSON Web Tokens.
+ * - `GOOGLE`: Authentication via Google OAuth.
+ * - `FACEBOOK`: Authentication via Facebook OAuth.
+ */
+exports.AuthStrategy = void 0;
+(function (AuthStrategy) {
+  /**
+   * Local authentication strategy
+   *
+   * Authenticates users using username/email and password stored in the application's database.
+   * This is the most basic form of authentication that doesn't rely on third-party services.
+   */
+  AuthStrategy["LOCAL"] = "local";
+  /**
+   * JWT authentication strategy
+   *
+   * Uses JSON Web Tokens for authentication and authorization. Tokens contain encoded user
+   * information and are validated on the server side. Typically used for stateless authentication
+   * in RESTful APIs.
+   */
+  AuthStrategy["JWT"] = "jwt";
+  /**
+   * Google OAuth authentication strategy
+   *
+   * Allows users to sign in using their Google accounts. This strategy delegates the authentication
+   * process to Google's identity service and receives user information upon successful authentication.
+   */
+  AuthStrategy["GOOGLE"] = "google";
+  /**
+   * Facebook OAuth authentication strategy
+   *
+   * Enables authentication through Facebook accounts. Similar to Google OAuth, this strategy
+   * relies on Facebook's identity provider to authenticate users and return their profile information.
+   */
+  AuthStrategy["FACEBOOK"] = "facebook";
+})(exports.AuthStrategy || (exports.AuthStrategy = {}));
+
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Sign Up Type Enum
+ *
+ * This enum represents the different methods by which a user can sign up in the application.
+ * It is used to track how a user account was created and to apply different business rules
+ * based on the sign up method (e.g., email verification requirements).
+ */
+exports.AuthProvider = void 0;
+(function (AuthProvider) {
+  /**
+   * Local Sign Up with email and password
+   *
+   * Users who sign up directly on the application with an email and password.
+   * These users typically need to verify their email address.
+   */
+  AuthProvider["LOCAL"] = "local";
+  /**
+   * Google OAuth Sign Up
+   *
+   * Users who sign up by authenticating through their Google account.
+   * These users typically have pre-verified email addresses.
+   */
+  AuthProvider["GOOGLE"] = "google";
+  /**
+   * Facebook OAuth Sign Up
+   *
+   * Users who sign up by authenticating through their Facebook account.
+   * These users typically have pre-verified email addresses.
+   */
+  AuthProvider["FACEBOOK"] = "facebook";
+})(exports.AuthProvider || (exports.AuthProvider = {}));
+
+/**
+ * Collection of standardized authentication error responses
+ *
+ * This constant maps each authentication error code to its corresponding
+ * standardized error response object. The responses include HTTP status codes,
+ * error codes, and human-readable messages.
+ *
+ * Key features:
+ * - Standardized error response format following the ErrorResponse interface
+ * - Comprehensive coverage of authentication error scenarios
+ * - Organized by HTTP status code (400, 401, 403, 404, 500, 501)
+ * - Includes both authentication service errors (AUTH_) and user management errors (USER_)
+ * - Human-readable error messages suitable for end-users
+ *
+ * The error responses are organized into categories based on HTTP status codes:
+ * - 400 Bad Request: Client errors related to invalid input or request format
+ * - 401 Unauthorized: Authentication failures and token-related errors
+ * - 403 Forbidden: Access denied due to insufficient permissions
+ * - 404 Not Found: Resource not found errors
+ * - 500 Internal Server Error: Server-side errors during authentication operations
+ * - 501 Not Implemented: Features that are not yet implemented
+ *
+ * The object is organized by error code, with each code mapping to an ErrorResponse
+ * object that follows the standardized format defined by the ErrorResponse interface.
+ *
+ * @example
+ * ```typescript
+ * // Using an error response in an exception
+ * import { AuthErrors } from '@hichchi/nest-connector/auth';
+ * import { UnauthorizedException } from '@nestjs/common';
+ *
+ * // In an authentication service
+ * if (!user.isEmailVerified) {
+ *   throw new UnauthorizedException(AuthErrors.AUTH_401_EMAIL_NOT_VERIFIED);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using an error response in a custom exception filter
+ * import { AuthErrors } from '@hichchi/nest-connector/auth';
+ * import { ExceptionFilter, Catch, ArgumentsHost, UnauthorizedException } from '@nestjs/common';
+ *
+ * @Catch(UnauthorizedException)
+ * export class AuthExceptionFilter implements ExceptionFilter {
+ *   catch(exception: UnauthorizedException, host: ArgumentsHost) {
+ *     const response = host.switchToHttp().getResponse();
+ *     const status = exception.getStatus();
+ *
+ *     // Use a standard error response
+ *     response
+ *       .status(status)
+ *       .json(AuthErrors.AUTH_401_NOT_LOGGED_IN);
+ *   }
+ * }
+ * ```
+ *
+ * @type {{ [key in AuthErrorResponseCode]: ErrorResponse }}
+ *
+ * @see {@link AuthErrorResponseCode} For all available error codes
+ * @see {@link ErrorResponse} For the structure of error response objects
+ * @see {@link AuthSuccessResponses} Complementary success responses for authentication
+ */
+const AuthErrors = {
+  [exports.AuthErrorResponseCode.AUTH_400_EMAIL_ALREADY_VERIFIED]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.AUTH_400_EMAIL_ALREADY_VERIFIED,
+    message: "Email already verified!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_400_REDIRECT_URL_REQUIRED]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.AUTH_400_REDIRECT_URL_REQUIRED,
+    message: "Redirect URL is required",
+    description: "Redirect URL is required"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_CORS]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_CORS,
+    message: "Access blocked by CORS!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_USERNAME_PASSWORD]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_USERNAME_PASSWORD,
+    message: "Invalid username or password!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_EMAIL_PASSWORD]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_EMAIL_PASSWORD,
+    message: "Invalid e-mail or password!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_PASSWORD]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_PASSWORD,
+    message: "Invalid password!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_NOT_LOGGED_IN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_NOT_LOGGED_IN,
+    message: "User must be logged in to access this resource!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_NOT_LOCAL]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_NOT_LOCAL,
+    message: "Cannot sign in with password for accounts signed up with social media!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_SOCIAL_SIGN_IN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_SOCIAL_SIGN_IN,
+    message: "Cannot sign in with social media account!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_EMAIL_NOT_VERIFIED]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_EMAIL_NOT_VERIFIED,
+    message: "User e-mail not verified!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_NOT_ACTIVE]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_NOT_ACTIVE,
+    message: "Your account has been disabled. Contact us if you think this is a mistake!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_TOKEN_NOT_SET]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_TOKEN_NOT_SET,
+    message: "Cannot find a token!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_REFRESH_TOKEN_NOT_SET]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_REFRESH_TOKEN_NOT_SET,
+    message: "Cannot find a refresh token!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_TOKEN,
+    message: "Invalid token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_EXPIRED_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_EXPIRED_TOKEN,
+    message: "Expired token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_VERIFICATION_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_VERIFICATION_TOKEN,
+    message: "Invalid or expired verification token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_PASSWORD_RESET_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_PASSWORD_RESET_TOKEN,
+    message: "Invalid or expired password reset token token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_INVALID_REFRESH_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_INVALID_REFRESH_TOKEN,
+    message: "Invalid refresh token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_EXPIRED_REFRESH_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_EXPIRED_REFRESH_TOKEN,
+    message: "Expired refresh token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN,
+    message: "Expired or invalid password reset token received!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_401_UNKNOWN]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_401_UNKNOWN,
+    message: "Unknown error occurred!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_403_PENDING]: {
+    statusCode: error_responses.HttpClientErrorStatus.UNAUTHORIZED,
+    code: exports.AuthErrorResponseCode.AUTH_403_PENDING,
+    message: "Please verify your e-mail address to continue. If you didn't receive the email you can click " + "the resend verification button to receive it again!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_403_ACCOUNT_DISABLED]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.AUTH_403_ACCOUNT_DISABLED,
+    message: "Account disabled!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_403_ROLE_FORBIDDEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.FORBIDDEN,
+    code: exports.AuthErrorResponseCode.AUTH_403_ROLE_FORBIDDEN,
+    message: "You don't have privileges to access this resource!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_403_PERMISSION_FORBIDDEN]: {
+    statusCode: error_responses.HttpClientErrorStatus.FORBIDDEN,
+    code: exports.AuthErrorResponseCode.AUTH_403_PERMISSION_FORBIDDEN,
+    message: "You don't have privileges to access this resource!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_403_SUB_DOMAIN_NOT_ALLOWED]: {
+    statusCode: error_responses.HttpClientErrorStatus.FORBIDDEN,
+    code: exports.AuthErrorResponseCode.AUTH_403_SUB_DOMAIN_NOT_ALLOWED,
+    message: "You don't have privileges to access this resource!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_404_EMAIL]: {
+    statusCode: error_responses.HttpClientErrorStatus.NOT_FOUND,
+    code: exports.AuthErrorResponseCode.AUTH_404_EMAIL,
+    message: "Cannot find a user account with this e-mail!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SIGN_UP]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SIGN_UP,
+    message: "Error occurred while signing up!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SOCIAL_SIGN_UP]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SOCIAL_SIGN_UP,
+    message: "Error occurred while signing up with social media account!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SIGN_IN]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SIGN_IN,
+    message: "Error occurred while signing in!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SOCIAL_SIGN_IN]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SOCIAL_SIGN_IN,
+    message: "Error occurred while signing in with social media account!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SOCIAL_SIGN_IN_CALLBACK]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SOCIAL_SIGN_IN_CALLBACK,
+    message: "Error occurred while signing in with social media account!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SIGN_OUT]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SIGN_OUT,
+    message: "Error occurred while signing out!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_SEND_EMAIL_VERIFICATION]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_SEND_EMAIL_VERIFICATION,
+    message: "Error occurred while sending email verification!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_VERIFY_EMAIL]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_VERIFY_EMAIL,
+    message: "Error occurred while verifying email!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_REQUEST_PASSWORD_RESET]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_REQUEST_PASSWORD_RESET,
+    message: "Error occurred while requesting password reset!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500_PASSWORD_RESET]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500_PASSWORD_RESET,
+    message: "Error occurred while resetting password!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_500]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.AUTH_500,
+    message: "Error occurred!"
+  },
+  [exports.AuthErrorResponseCode.AUTH_501_NOT_IMPLEMENTED]: {
+    statusCode: error_responses.HttpServerErrorStatus.NOT_IMPLEMENTED,
+    code: exports.AuthErrorResponseCode.AUTH_501_NOT_IMPLEMENTED,
+    message: "API Not implemented!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_EMPTY_EMAIL]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_EMPTY_EMAIL,
+    message: "Email cannot be empty!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_EMPTY_FNAME]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_EMPTY_FNAME,
+    message: "User first name cannot be empty!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_EMPTY_LNAME]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_EMPTY_LNAME,
+    message: "User last name cannot be empty!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_EMPTY_UNAME]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_EMPTY_UNAME,
+    message: "User username cannot be empty!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_EMPTY_PASSWORD]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_EMPTY_PASSWORD,
+    message: "User password cannot be empty!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_INVALID_EMAIL]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_INVALID_EMAIL,
+    message: "Invalid e-mail address!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_NOT_EMPTY_UNAME]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_NOT_EMPTY_UNAME,
+    message: "User username cannot be updated!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_NOT_EMPTY_PASSWORD]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_NOT_EMPTY_PASSWORD,
+    message: "User password cannot be updated!"
+  },
+  [exports.AuthErrorResponseCode.USER_400_NOT_EMPTY_SALT]: {
+    statusCode: error_responses.HttpClientErrorStatus.BAD_REQUEST,
+    code: exports.AuthErrorResponseCode.USER_400_NOT_EMPTY_SALT,
+    message: "User salt cannot be inserted/updated!"
+  },
+  [exports.AuthErrorResponseCode.USER_403_SIGN_UP]: {
+    statusCode: error_responses.HttpClientErrorStatus.FORBIDDEN,
+    code: exports.AuthErrorResponseCode.USER_403_SIGN_UP,
+    message: "User sign up is disabled!"
+  },
+  [exports.AuthErrorResponseCode.USER_404_ID]: {
+    statusCode: error_responses.HttpClientErrorStatus.NOT_FOUND,
+    code: exports.AuthErrorResponseCode.USER_404_ID,
+    message: "Cannot find a user with given id!"
+  },
+  [exports.AuthErrorResponseCode.USER_409_EXIST_UNAME]: {
+    statusCode: error_responses.HttpClientErrorStatus.CONFLICT,
+    code: exports.AuthErrorResponseCode.USER_409_EXIST_UNAME,
+    message: "User with given username already exist!"
+  },
+  [exports.AuthErrorResponseCode.USER_500_CREATE]: {
+    statusCode: error_responses.HttpServerErrorStatus.INTERNAL_SERVER_ERROR,
+    code: exports.AuthErrorResponseCode.USER_500_CREATE,
+    message: "Error occurred while creating user!"
+  }
+};
+
+/**
+ * Collection of standardized authentication success responses
+ *
+ * This constant maps each authentication success response code to its corresponding
+ * standardized success response object. The responses include HTTP status codes,
+ * success codes, and human-readable messages.
+ *
+ * Key features:
+ * - Standardized success response format following the SuccessResponse interface
+ * - Comprehensive coverage of authentication success scenarios
+ * - Organized by HTTP status code (200, 201)
+ * - Human-readable success messages suitable for end-users
+ * - Consistent response structure across the authentication system
+ *
+ * The success responses are organized into categories based on HTTP status codes:
+ * - 200 OK: General success responses for operations like verification, password reset, sign out
+ * - 201 Created: Success responses for resource creation operations like account creation
+ *
+ * The object is organized by success code, with each code mapping to a SuccessResponse
+ * object that follows the standardized format defined by the SuccessResponse interface.
+ *
+ * @example
+ * ```typescript
+ * // Using a success response in a controller
+ * import { AuthSuccessResponses } from '@hichchi/nest-connector/auth';
+ * import { Controller, Post, Body } from '@nestjs/common';
+ *
+ * @Controller('auth')
+ * export class AuthController {
+ *   constructor(private readonly authService: AuthService) {}
+ *
+ *   @Post('register')
+ *   async register(@Body() registerDto: RegisterDto) {
+ *     await this.authService.register(registerDto);
+ *     return AuthSuccessResponses.AUTH_201_ACCOUNT_CREATED_REQUIRE_VERIFY;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using a success response in a service
+ * import { AuthSuccessResponses } from '@hichchi/nest-connector/auth';
+ * import { Injectable } from '@nestjs/common';
+ *
+ * @Injectable()
+ * export class AuthService {
+ *   async verifyEmail(token: string) {
+ *     // Verify email logic...
+ *     return AuthSuccessResponses.AUTH_201_EMAIL_VERIFIED;
+ *   }
+ * }
+ * ```
+ *
+ * @type {{ [key in AuthSuccessResponseCode]: SuccessResponse }}
+ *
+ * @see {@link AuthSuccessResponseCode} For all available success codes
+ * @see {@link SuccessResponse} For the structure of success response objects
+ * @see {@link AuthErrors} Complementary error responses for authentication
+ */
+const AuthSuccessResponses = {
+  [exports.AuthSuccessResponseCode.AUTH_201_ACCOUNT_CREATED_REQUIRE_VERIFY]: {
+    statusCode: error_responses.HttpSuccessStatus.CREATED,
+    code: exports.AuthSuccessResponseCode.AUTH_201_ACCOUNT_CREATED_REQUIRE_VERIFY,
+    message: "Account created successfully. Please verify your email to activate your account."
+  },
+  [exports.AuthSuccessResponseCode.AUTH_201_ACCOUNT_CREATED]: {
+    statusCode: error_responses.HttpSuccessStatus.CREATED,
+    code: exports.AuthSuccessResponseCode.AUTH_201_ACCOUNT_CREATED,
+    message: "Account created successfully."
+  },
+  [exports.AuthSuccessResponseCode.AUTH_201_EMAIL_VERIFIED]: {
+    statusCode: error_responses.HttpSuccessStatus.OK,
+    code: exports.AuthSuccessResponseCode.AUTH_201_EMAIL_VERIFIED,
+    message: "Email verified successfully. You can now sign in."
+  },
+  [exports.AuthSuccessResponseCode.AUTH_200_EMAIL_VERIFICATION_SENT]: {
+    statusCode: error_responses.HttpSuccessStatus.OK,
+    code: exports.AuthSuccessResponseCode.AUTH_200_EMAIL_VERIFICATION_SENT,
+    message: "Verification email sent successfully"
+  },
+  [exports.AuthSuccessResponseCode.AUTH_200_PASSWORD_RESET_EMAIL_SENT]: {
+    statusCode: error_responses.HttpSuccessStatus.OK,
+    code: exports.AuthSuccessResponseCode.AUTH_200_PASSWORD_RESET_EMAIL_SENT,
+    message: "Password reset email sent successfully"
+  },
+  [exports.AuthSuccessResponseCode.AUTH_200_PASSWORD_RESET_TOKEN_VALID]: {
+    statusCode: error_responses.HttpSuccessStatus.OK,
+    code: exports.AuthSuccessResponseCode.AUTH_200_PASSWORD_RESET_TOKEN_VALID,
+    message: "Password reset token is valid"
+  },
+  [exports.AuthSuccessResponseCode.AUTH_200_PASSWORD_RESET_SUCCESS]: {
+    statusCode: error_responses.HttpSuccessStatus.OK,
+    code: exports.AuthSuccessResponseCode.AUTH_200_PASSWORD_RESET_SUCCESS,
+    message: "Password reset successfully"
+  },
+  [exports.AuthSuccessResponseCode.AUTH_200_SIGNED_OUT]: {
+    statusCode: error_responses.HttpSuccessStatus.OK,
+    code: exports.AuthSuccessResponseCode.AUTH_200_SIGNED_OUT,
+    message: "Successfully signed out"
+  }
+};
+
+/**
+ * Type guard function to check if a role is a Role object or a string
+ *
+ * This utility function determines whether the provided role parameter is a Role object
+ * (containing properties like name, permissions, etc.) or just a string representation
+ * of the role name. It's commonly used in authentication and authorization logic to
+ * handle different role formats consistently.
+ *
+ * The function performs a type-safe check by verifying that the role exists and
+ * contains a "name" property, which is characteristic of Role objects.
+ *
+ * @template R - The type of role string (defaults to string)
+ * @param role - The role to check, can be a Role object, string, or null
+ * @returns True if the role is a Role object, false if it's a string or null
+ *
+ * @example
+ * ```typescript
+ * // With a Role object
+ * const roleObject: Role = {
+ *   name: 'admin',
+ *   permissions: ['users.read', 'users.write']
+ * };
+ *
+ * if (isRoleObject(roleObject)) {
+ *   console.log('Role name:', roleObject.name);
+ *   console.log('Permissions:', roleObject.permissions);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With a string role
+ * const roleString = 'admin';
+ *
+ * if (isRoleObject(roleString)) {
+ *   // This won't execute because roleString is just a string
+ *   console.log('Role object:', roleString.name);
+ * } else {
+ *   console.log('Role string:', roleString);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In a permission check function
+ * function hasPermission(userRole: Role | string, requiredPermission: string): boolean {
+ *   if (isRoleObject(userRole)) {
+ *     return userRole.permissions?.includes(requiredPermission) ?? false;
+ *   }
+ *   // Handle string role case
+ *   return false;
+ * }
+ * ```
+ *
+ * @see {@link Role} Interface defining the structure of role objects
+ */
+function isRoleObject(role) {
+  return Boolean(role) && Boolean("name" in role);
+}
+
+exports.AuthErrors = AuthErrors;
+exports.AuthSuccessResponses = AuthSuccessResponses;
+exports.isRoleObject = isRoleObject;