@mudrichenkoevgeny/shared-foundation 0.0.47 → 0.0.49

package/index.mjs

@@ -144,6 +144,204 @@ export const clientDeviceIdSchema = z.string().transform((val, ctx) => {
   return result;
 });
 
+export function toDecryptedStringOrNull(value) {
+  if (!value || typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  return value;
+}
+
+export function toDecryptedStringOrThrow(value) {
+  const result = toDecryptedStringOrNull(value);
+  if (!result) {
+    throw new Error('DecryptedString value must not be blank.');
+  }
+  return result;
+}
+
+export const decryptedStringSchema = z.string().transform((val, ctx) => {
+  const result = toDecryptedStringOrNull(val);
+  if (!result) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid DecryptedString' });
+    return z.NEVER;
+  }
+  return result;
+});
+
+export function toEncryptedStringOrNull(value) {
+  if (!value || typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  return value;
+}
+
+export function toEncryptedStringOrThrow(value) {
+  const result = toEncryptedStringOrNull(value);
+  if (!result) {
+    throw new Error('EncryptedString value must not be blank.');
+  }
+  return result;
+}
+
+export const encryptedStringSchema = z.string().transform((val, ctx) => {
+  const result = toEncryptedStringOrNull(val);
+  if (!result) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid EncryptedString' });
+    return z.NEVER;
+  }
+  return result;
+});
+
+export function toPasswordHashOrNull(value) {
+  if (!value || typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  return value;
+}
+
+export function toPasswordHashOrThrow(value) {
+  const result = toPasswordHashOrNull(value);
+  if (!result) {
+    throw new Error('PasswordHash value must not be blank.');
+  }
+  return result;
+}
+
+export const passwordHashSchema = z.string().transform((val, ctx) => {
+  const result = toPasswordHashOrNull(val);
+  if (!result) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid PasswordHash' });
+    return z.NEVER;
+  }
+  return result;
+});
+
+export function toAccessTokenOrNull(value) {
+  if (!value || typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  return value;
+}
+
+export function toAccessTokenOrThrow(value) {
+  const result = toAccessTokenOrNull(value);
+  if (!result) {
+    throw new Error('AccessToken value must not be blank.');
+  }
+  return result;
+}
+
+export const accessTokenSchema = z.string().transform((val, ctx) => {
+  const result = toAccessTokenOrNull(val);
+  if (!result) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid AccessToken' });
+    return z.NEVER;
+  }
+  return result;
+});
+
+export function toRefreshTokenOrNull(value) {
+  if (!value || typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  return value;
+}
+
+export function toRefreshTokenOrThrow(value) {
+  const result = toRefreshTokenOrNull(value);
+  if (!result) {
+    throw new Error('RefreshToken value must not be blank.');
+  }
+  return result;
+}
+
+export const refreshTokenSchema = z.string().transform((val, ctx) => {
+  const result = toRefreshTokenOrNull(val);
+  if (!result) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid RefreshToken' });
+    return z.NEVER;
+  }
+  return result;
+});
+
+export function toRefreshTokenHashOrNull(value) {
+  if (!value || typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  return value;
+}
+
+export function toRefreshTokenHashOrThrow(value) {
+  const result = toRefreshTokenHashOrNull(value);
+  if (!result) {
+    throw new Error('RefreshTokenHash value must not be blank.');
+  }
+  return result;
+}
+
+export const refreshTokenHashSchema = z.string().transform((val, ctx) => {
+  const result = toRefreshTokenHashOrNull(val);
+  if (!result) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid RefreshTokenHash' });
+    return z.NEVER;
+  }
+  return result;
+});
+
+        export class CompositeAuditActionTypeParser {
+  constructor(auditActionTypes) {
+    this.auditActionTypes = auditActionTypes;
+  }
+
+  fromValueOrThrow(value) {
+    for (const parse of this.auditActionTypes) {
+      const result = typeof parse === 'function'
+        ? parse(value)
+        : (parse && typeof parse.parseOrNull === 'function' ? parse.parseOrNull(value) : null);
+      if (result !== null && result !== undefined) {
+        return result;
+      }
+    }
+    throw new Error("Unknown value of AuditActionType: '" + value + "'");
+  }
+}
+
+export class CompositeAuditMetadataKeyParser {
+  constructor(metadataKeys) {
+    this.metadataKeys = metadataKeys;
+  }
+
+  fromValueOrThrow(value) {
+    for (const parse of this.metadataKeys) {
+      const result = typeof parse === 'function'
+        ? parse(value)
+        : (parse && typeof parse.parseOrNull === 'function' ? parse.parseOrNull(value) : null);
+      if (result !== null && result !== undefined) {
+        return result;
+      }
+    }
+    throw new Error("Unknown value of AuditMetadataKey: '" + value + "'");
+  }
+}
+
+export class CompositeAuditResourceTypeParser {
+  constructor(auditResourceTypes) {
+    this.auditResourceTypes = auditResourceTypes;
+  }
+
+  fromValueOrThrow(value) {
+    for (const parse of this.auditResourceTypes) {
+      const result = typeof parse === 'function'
+        ? parse(value)
+        : (parse && typeof parse.parseOrNull === 'function' ? parse.parseOrNull(value) : null);
+      if (result !== null && result !== undefined) {
+        return result;
+      }
+    }
+    throw new Error("Unknown value of AuditResourceType: '" + value + "'");
+  }
+}
+
         export const ManagementRoutes = {
   BASE_MANAGEMENT_ROUTE: "/management"
 };
@@ -194,6 +392,14 @@ LOGIN_BY_TOTP: "/management/auth/login/totp",
 LOGIN_BY_TOTP_RECOVERY_CODE: "/management/auth/login/totp-recovery-code"
       };
 
+export const OpenRefreshTokenRoutes = {
+  REFRESH_TOKEN: "/auth/refresh"
+};
+
+export const SelfManagementRefreshTokenRoutes = {
+  REFRESH_TOKEN: "/management/auth/refresh"
+};
+
       export const OpenRegisterRoutes = {
         REGISTER_BY_EMAIL_ROUTE: "/auth/register/email",
 REGISTER_BY_EMAIL: "/auth/register/email",
@@ -342,6 +548,336 @@ UPDATE_MANAGEMENT_AUTH_SETTINGS: "/management/auth/settings",
 RESET_MANAGEMENT_AUTH_SETTINGS: "/management/auth/settings/reset"
       };
 
+export const OpenAuthSettingsRoutes = {
+  GET_OPEN_AUTH_SETTINGS: "/auth/settings"
+};
+
+export const OpenUserConfigurationRoutes = {
+  GET_CONFIGURATION: "user-configuration"
+};
+
+export const ManagementUserConfigurationRoutes = {
+  GET_CONFIGURATION: "/management/user-configuration"
+};
+
+              export const CommonApiFields = {
+        ITEMS: "items",
+TOTAL_COUNT: "total_count",
+TOTAL_PAGES: "total_pages",
+ID: "id",
+CREATED_AT: "created_at",
+UPDATED_AT: "updated_at",
+CODE: "code",
+MESSAGE: "message",
+ARGS: "args",
+TYPE: "type",
+PAYLOAD: "payload",
+METADATA: "metadata",
+TIMESTAMP: "timestamp",
+CLIENT_TYPE: "client_type",
+CLIENT_DEVICE_INFO: "client_device_info",
+CLIENT_INFO: "client_info",
+USER_AGENT: "user_agent",
+IP_ADDRESS: "ip_address",
+MASKED_IP_ADDRESS: "masked_ip_address",
+LANGUAGE: "language",
+DEVICE_ID: "device_id",
+DEVICE_NAME: "device_name",
+APP_VERSION: "app_version",
+OPERATION_SYSTEM_VERSION: "operation_system_version",
+API_VERSION: "api_version",
+IS_SENSITIVE_VALUES_MASKED: "is_sensitive_values_masked"
+      };
+
+      export const SecurityApiFields = {
+        RECENT_AUTHENTICATION_VALIDITY_SECONDS_FOR_OPEN_USER: "recent_authentication_validity_seconds_for_open_user",
+RECENT_AUTHENTICATION_VALIDITY_SECONDS_FOR_MANAGEMENT_USER: "recent_authentication_validity_seconds_for_management_user",
+MFA_TOKEN: "mfa_token",
+TOTP_CODE: "totp_code",
+TOTP_SECRET_KEY: "totp_secret_key",
+TOTP_OTP_AUTH_URL: "totp_otp_auth_url",
+TOTP_RECOVERY_CODES: "totp_recovery_codes",
+OPEN_PASSWORD_POLICY: "open_password_policy",
+MANAGEMENT_PASSWORD_POLICY: "management_password_policy",
+MIN_LENGTH: "min_length",
+REQUIRE_LETTER: "require_letter",
+REQUIRE_UPPER_CASE: "require_upper_case",
+REQUIRE_LOWER_CASE: "require_lower_case",
+REQUIRE_DIGIT: "require_digit",
+REQUIRE_SPECIAL_CHAR: "require_special_char",
+COMMON_PASSWORDS: "common_passwords",
+OTP_CONFIRMATION: "otp_confirmation",
+RETRY_AFTER_SECONDS: "retry_after_seconds",
+NUMBER_OF_SYMBOLS: "number_of_symbols",
+EXPIRATION_SECONDS: "expiration_seconds",
+MAX_REQUESTS_PER_PERIOD: "max_requests_per_period",
+RATE_LIMIT_PERIOD_SECONDS: "rate_limit_period_seconds",
+REFRESH_TOKEN_ROTATION_GRACE_PERIOD_SECONDS: "refresh_token_rotation_grace_period_seconds",
+ACCOUNT_LOCKOUT_POLICY: "account_lockout_policy",
+ACCOUNT_LOCKOUT_CHECK_INTERVAL_SECONDS: "account_lockout_check_interval_seconds",
+MAX_FAILED_PASSWORD_ATTEMPTS: "max_failed_password_attempts",
+MAX_FAILED_OTP_ATTEMPTS: "max_failed_otp_attempts",
+MAX_FAILED_TOTP_ATTEMPTS: "max_failed_totp_attempts",
+FAILED_ATTEMPTS_WINDOW_SECONDS: "failed_attempts_window_seconds",
+LOCKOUT_DURATION_SECONDS: "lockout_duration_seconds",
+INDEFINITE_LOCKOUT_THRESHOLD: "indefinite_lockout_threshold",
+IS_SELF_SERVICE_UNLOCK_ENABLED: "is_self_service_unlock_enabled",
+OPEN_IP_RESTRICTION_POLICY: "open_ip_restriction_policy",
+MANAGEMENT_IP_RESTRICTION_POLICY: "management_ip_restriction_policy",
+IS_BLACKLIST_ENABLED: "is_blacklist_enabled",
+BLACKLIST: "blacklist",
+IS_WHITELIST_ENABLED: "is_whitelist_enabled",
+WHITELIST: "whitelist"
+      };
+
+      export const GlobalSettingsApiFields = {
+        PRIVACY_POLICY_URL: "privacy_policy_url",
+TERMS_OF_SERVICE_URL: "terms_of_service_url",
+CONTACT_SUPPORT_EMAIL: "contact_support_email",
+IS_TRACING_ENABLED: "is_tracing_enabled",
+IS_METRICS_ENABLED: "is_metrics_enabled",
+IS_VERBOSE_LOGGING_ENABLED: "is_verbose_logging_enabled",
+MIN_SUPPORTED_APP_VERSIONS: "min_supported_app_versions"
+      };
+
+      export const UserApiFields = {
+        EXTERNAL_PROVIDER_TOKEN: "external_provider_token",
+TOKEN_TYPE: "token_type",
+SESSION_ID: "session_id",
+ACCESS_TOKEN: "access_token",
+REFRESH_TOKEN: "refresh_token",
+SESSION_TOKEN: "session_token",
+EXPIRES_AT: "expires_at",
+EMAIL: "email",
+PHONE_NUMBER: "phone_number",
+PASSWORD: "password",
+OLD_PASSWORD: "old_password",
+NEW_PASSWORD: "new_password",
+CONFIRMATION_CODE: "confirmation_code",
+AUTH_PROVIDER: "auth_provider",
+USER: "user",
+USER_ID: "user_id",
+ROLE: "role",
+USER_ROLE: "user_role",
+ACCOUNT_STATUS: "account_status",
+ACCOUNT_STATUS_ON_RESTORE: "account_status_on_restore",
+AUTHORITY_LEVEL: "authority_level",
+PERMISSION_CODES: "permission_codes",
+IS_TOTP_ENABLED: "is_totp_enabled",
+LAST_LOGIN_AT: "last_login_at",
+LAST_ACTIVE_AT: "last_active_at",
+SCHEDULED_PERMANENT_DELETION_AT: "scheduled_permanent_deletion_at",
+ACCOUNT_LOCKOUT_TYPE: "account_lockout_type",
+TEMPORARY_LOCKOUT_UNTIL: "temporary_lockout_until",
+IDENTIFIER: "identifier",
+EXTERNAL_PROVIDER_EMAIL: "external_provider_email",
+USER_AUTH_PROVIDER: "user_auth_provider",
+IDENTIFIER_ID: "identifier_id",
+DISPLAY_NAME: "display_name",
+IDENTIFIER_DISPLAY_NAME: "identifier_display_name",
+IDENTIFIER_AUTH_PROVIDER: "identifier_auth_provider",
+LAST_ACCESSED_AT: "last_accessed_at",
+LAST_REAUTHENTICATED_AT: "last_reauthenticated_at",
+DELETED_SESSION_IDS: "deleted_session_ids",
+DELETED_IDENTIFIER_IDS: "deleted_identifier_ids",
+MAX_TOTAL_IDENTIFIERS: "max_total_identifiers",
+MAX_EMAIL_IDENTIFIERS: "max_email_identifiers",
+MAX_PHONE_IDENTIFIERS: "max_phone_identifiers",
+MAX_IDENTIFIERS_PER_EXTERNAL_PROVIDER: "max_identifiers_per_external_provider",
+MAX_ACTIVE_SESSIONS_FOR_OPEN_USER: "max_active_sessions_for_open_user",
+MAX_ACTIVE_SESSIONS_FOR_MANAGEMENT_USER: "max_active_sessions_for_management_user",
+AVAILABLE_AUTH_PROVIDERS: "available_auth_providers",
+ACCESS_TOKEN_VALIDITY_SECONDS: "access_token_validity_seconds",
+REFRESH_TOKEN_VALIDITY_SECONDS: "refresh_token_validity_seconds",
+ACCOUNT_DELETION_GRACE_PERIOD_SECONDS: "account_deletion_grace_period_seconds",
+ACCOUNT_DELETION_CHECK_INTERVAL_SECONDS: "account_deletion_check_interval_seconds",
+IS_REGISTRATION_ENABLED: "is_registration_enabled",
+EMAIL_RESTRICTION_POLICY: "email_restriction_policy",
+OPEN_EMAIL_RESTRICTION_POLICY: "open_email_restriction_policy",
+MANAGEMENT_EMAIL_RESTRICTION_POLICY: "management_email_restriction_policy",
+PRIMARY: "primary",
+SECONDARY: "secondary",
+OPEN_GLOBAL_SETTINGS: "open_global_settings",
+MANAGEMENT_GLOBAL_SETTINGS: "management_global_settings",
+OPEN_SECURITY_SETTINGS: "open_security_settings",
+MANAGEMENT_SECURITY_SETTINGS: "management_security_settings",
+OPEN_AUTH_SETTINGS: "open_auth_settings",
+MANAGEMENT_AUTH_SETTINGS: "management_auth_settings"
+      };
+
+      export const AuditEventFields = {
+        ACTOR_ID: "actor_id",
+ACTOR_TYPE: "actor_type",
+ACTOR_USER_ROLE: "actor_user_role",
+ACTION: "action",
+RESOURCE: "resource",
+RESOURCE_ID: "resource_id",
+STATUS: "status",
+METADATA_KEY: "key",
+METADATA_VALUE: "value",
+METADATA_VALUE_SENSITIVITY: "value_sensitivity"
+      };
+
+      export const CommonHttpHeaders = {
+        TRACE_HEADER_NAME: "X-Trace-Id",
+CLIENT_TYPE_HEADER_NAME: "X-Client-Type",
+DEVICE_ID_HEADER_NAME: "X-Device-Id",
+DEVICE_NAME_HEADER_NAME: "X-Device-Name",
+APP_VERSION_HEADER_NAME: "X-App-Version",
+OPERATION_SYSTEM_VERSION_HEADER_NAME: "X-OS-Version",
+API_VERSION_HEADER_NAME: "X-Api-Version"
+      };
+
+      export const CommonWebSocketCloseReasons = {
+        NORMAL: "Normal",
+SERVER_RESTART: "Server restart",
+INTERNAL_SERVER_ERROR: "Internal server error"
+      };
+
+      export const CommonWebSocketEventTypes = {
+        PING: "PING",
+PONG: "PONG",
+INITIALIZE: "INITIALIZE",
+INITIALIZED_SUCCESS: "INITIALIZED_SUCCESS"
+      };
+
+      export const SecurityWebSocketEventTypes = {
+        OPEN_SECURITY_SETTINGS_UPDATED: "OPEN_SECURITY_SETTINGS_UPDATED",
+MANAGEMENT_SECURITY_SETTINGS_UPDATED: "MANAGEMENT_SECURITY_SETTINGS_UPDATED"
+      };
+
+      export const SettingsWebSocketEventTypes = {
+        OPEN_GLOBAL_SETTINGS_UPDATED: "OPEN_GLOBAL_SETTINGS_UPDATED",
+MANAGEMENT_GLOBAL_SETTINGS_UPDATED: "MANAGEMENT_GLOBAL_SETTINGS_UPDATED"
+      };
+
+      export const UserWebSocketCloseReasons = {
+        AUTH_FAILED: "Auth failed",
+SESSION_EXPIRED: "Session expired",
+SESSION_DELETED: "Session deleted",
+USER_BANNED: "User banned"
+      };
+
+      export const UserWebSocketEventTypes = {
+        UNAUTHORIZED: "UNAUTHORIZED",
+OPEN_AUTH_SETTINGS_UPDATED: "OPEN_AUTH_SETTINGS_UPDATED",
+MANAGEMENT_AUTH_SETTINGS_UPDATED: "MANAGEMENT_AUTH_SETTINGS_UPDATED",
+USER_UPDATED: "USER_UPDATED",
+SESSION_DELETED: "SESSION_DELETED"
+      };
+
+      export const UserApiPaths = {
+        USER_ID: "user_id",
+SESSION_ID: "session_id",
+USER_IDENTIFIER_ID: "user_identifier_id"
+      };
+
+export const UserApiQueryParams = {
+  ACCESS_TOKEN: "token"
+};
+
+export const UserAuthSpec = {
+  TOKEN_TYPE_BEARER: "Bearer"
+};
+
+export const AuditApiPaths = {
+  EVENT_ID: "event_id"
+};
+
+export const UserRoleDefaultAuthorityLevel = {
+
+};
+
+      export const SecurityAuditMetadataDeniedReasonValues = {
+        RATE_LIMIT: "rate_limit",
+PASSWORD_TOO_WEAK: "password_too_weak",
+MFA_TOKEN_EXPIRED: "mfa_token_expired",
+TOTP_ALREADY_ENABLED: "totp_already_enabled",
+TOTP_NOT_ENABLED: "totp_not_enabled",
+RECOVERY_CODE_ALREADY_USED: "recovery_code_already_used",
+MFA_REQUIRED: "mfa_required"
+      };
+
+      export const UserAuditMetadataDeniedReasonValues = {
+        USER_READ_ONLY: "user_read_only",
+USER_BANNED: "user_banned",
+USER_LOCKED: "user_locked",
+USER_SECURITY_HOLD: "user_security_hold",
+USER_PENDING_DELETION: "user_pending_deletion",
+USER_NOT_FOUND: "user_not_found",
+USER_ROLE_NOT_ALLOWED: "user_role_not_allowed",
+USER_MISSING_PERMISSIONS: "user_missing_permissions",
+USER_INSUFFICIENT_AUTHORITY_LEVEL: "user_insufficient_authority_level",
+USER_ILLEGAL_ACCOUNT_STATUS: "user_illegal_account_status",
+USER_FORBIDDEN: "user_forbidden",
+USER_IDENTIFIER_LIMIT_REACHED: "user_identifier_limit_reached",
+TOTAL_USER_IDENTIFIERS_LIMIT_REACHED: "total_user_identifier_limit_reached",
+PASSWORD_SETUP_REQUIRED: "password_setup_required",
+USER_IDENTIFIER_PASSWORD_NOT_SUPPORTED: "user_identifier_password_not_supported",
+USER_IDENTIFIER_PASSWORD_NOT_SET: "user_identifier_password_not_set"
+      };
+
+export const ListingParamNames = {
+  PAGE_NUMBER: "page_number",
+  PAGE_SIZE: "page_size",
+  SORT_BY: "sort_by",
+  SORT_ORDER: "sort_order",
+  Pagination: {
+    PAGE_NUMBER: "page_number",
+    PAGE_SIZE: "page_size"
+  },
+  Sort: {
+    SORT_BY: "sort_by",
+    SORT_ORDER: "sort_order"
+  }
+};
+
+export const AuditFilterValues = {
+  AuditEventFilterValues: {
+    ACTOR_ID: "actor_id",
+    ACTOR_TYPE: "actor_type",
+    ACTOR_USER_ROLE: "actor_user_role",
+    ACTION: "action",
+    RESOURCE: "resource",
+    RESOURCE_ID: "resource_id",
+    STATUS: "status",
+    MESSAGE: "message"
+  }
+};
+
+export const UserFilterValues = {
+  UserFilterValues: {
+    ROLE: "role",
+    ACCOUNT_STATUS: "account_status",
+    ACCOUNT_STATUS_ON_RESTORE: "account_status_on_restore",
+    ACCOUNT_LOCKOUT_TYPE: "account_lockout_type",
+    AUTHORITY_LEVEL_FROM: "authority_level_from",
+    AUTHORITY_LEVEL_TO: "authority_level_to",
+    IS_TOTP_ENABLED: "is_totp_enabled",
+    PERMISSION_CODES: "permission_codes"
+  },
+  UserIdentifierFilterValues: {
+    USER_ID: "user_id",
+    USER_AUTH_PROVIDER: "user_auth_provider",
+    IDENTIFIER: "identifier"
+  },
+  UserSessionFilterValues: {
+    USER_ID: "user_id",
+    USER_ROLE: "user_role",
+    IDENTIFIER_ID: "identifier_id",
+    USER_AUTH_PROVIDER: "user_auth_provider",
+    CLIENT_TYPE: "client_type",
+    USER_AGENT: "user_agent",
+    IP_ADDRESS: "ip_address",
+    LANGUAGE: "language",
+    DEVICE_ID: "device_id",
+    DEVICE_NAME: "device_name",
+    APP_VERSION: "app_version",
+    OPERATION_SYSTEM_VERSION: "operation_system_version",
+    IDENTIFIER: "identifier"
+  }
+};
+
               export const CommonErrorCodes = {
         UNKNOWN: "UNKNOWN",
 INTERNAL: "INTERNAL",
@@ -462,41 +998,781 @@ export const UserPermissionCode = {
 
 };
 
-        export const clientTypeSchema = z.enum(["web", "android", "ios", "desktop"]);
+              export const toClientInfo = (payload) => ({
+        deviceInfo: toClientDeviceInfo(payload.client_device_info),
+userAgent: payload.user_agent,
+ipAddress: payload.ip_address,
+host: null,
+origin: null,
+apiVersion: payload.api_version
+      });
+      
+      export const toClientInfoPayload = (domain) => ({
+        client_device_info: toClientDeviceInfoPayload(domain.deviceInfo),
+user_agent: domain.userAgent,
+ip_address: domain.ipAddress,
+api_version: domain.apiVersion
+      });
+
+      export const toClientDeviceInfo = (payload) => ({
+        deviceId: payload.device_id ? toClientDeviceIdOrThrow(payload.device_id) : null,
+deviceName: payload.device_name,
+clientType: payload.client_type,
+language: payload.language,
+appVersion: payload.app_version,
+operationSystemVersion: payload.operation_system_version
+      });
+      
+      export const toClientDeviceInfoPayload = (domain) => ({
+        client_type: domain.clientType,
+language: domain.language,
+device_id: domain.deviceId,
+device_name: domain.deviceName,
+app_version: domain.appVersion,
+operation_system_version: domain.operationSystemVersion
+      });
+
+      export const toAccountLockoutPolicy = (payload) => ({
+        maxFailedPasswordAttempts: payload.max_failed_password_attempts,
+maxFailedOtpAttempts: payload.max_failed_otp_attempts,
+maxFailedTotpAttempts: payload.max_failed_totp_attempts,
+failedAttemptsWindowSeconds: payload.failed_attempts_window_seconds,
+lockoutDurationSeconds: payload.lockout_duration_seconds,
+indefiniteLockoutThreshold: payload.indefinite_lockout_threshold,
+isSelfServiceUnlockEnabled: payload.is_self_service_unlock_enabled
+      });
+      
+      export const toAccountLockoutPolicyPayload = (domain) => ({
+        max_failed_password_attempts: domain.maxFailedPasswordAttempts,
+max_failed_otp_attempts: domain.maxFailedOtpAttempts,
+max_failed_totp_attempts: domain.maxFailedTotpAttempts,
+failed_attempts_window_seconds: domain.failedAttemptsWindowSeconds,
+lockout_duration_seconds: domain.lockoutDurationSeconds,
+indefinite_lockout_threshold: domain.indefiniteLockoutThreshold,
+is_self_service_unlock_enabled: domain.isSelfServiceUnlockEnabled
+      });
+
+      export const toIpRestrictionPolicy = (payload) => ({
+        isBlacklistEnabled: payload.is_blacklist_enabled,
+blacklist: payload.blacklist,
+isWhitelistEnabled: payload.is_whitelist_enabled,
+whitelist: payload.whitelist
+      });
+      
+      export const toIpRestrictionPolicyPayload = (domain) => ({
+        is_blacklist_enabled: domain.isBlacklistEnabled,
+blacklist: domain.blacklist,
+is_whitelist_enabled: domain.isWhitelistEnabled,
+whitelist: domain.whitelist
+      });
+
+      export const toOtpConfirmation = (payload) => ({
+        retryAfterSeconds: payload.retry_after_seconds,
+numberOfSymbols: payload.number_of_symbols,
+expirationSeconds: payload.expiration_seconds
+      });
+      
+      export const toOtpConfirmationPayload = (domain) => ({
+        retry_after_seconds: domain.retryAfterSeconds,
+number_of_symbols: domain.numberOfSymbols,
+expiration_seconds: domain.expirationSeconds
+      });
+
+      export const toManagementPasswordPolicy = (payload) => ({
+        minLength: payload.min_length,
+requireLetter: payload.require_letter,
+requireUpperCase: payload.require_upper_case,
+requireLowerCase: payload.require_lower_case,
+requireDigit: payload.require_digit,
+requireSpecialChar: payload.require_special_char,
+commonPasswords: payload.common_passwords
+      });
+      
+      export const toManagementPasswordPolicyPayload = (domain) => ({
+        min_length: domain.minLength,
+require_letter: domain.requireLetter,
+require_upper_case: domain.requireUpperCase,
+require_lower_case: domain.requireLowerCase,
+require_digit: domain.requireDigit,
+require_special_char: domain.requireSpecialChar,
+common_passwords: domain.commonPasswords
+      });
+
+      export const toOpenPasswordPolicy = (payload) => ({
+        minLength: payload.min_length,
+requireLetter: payload.require_letter,
+requireUpperCase: payload.require_upper_case,
+requireLowerCase: payload.require_lower_case,
+requireDigit: payload.require_digit,
+requireSpecialChar: payload.require_special_char
+      });
+      
+      export const toOpenPasswordPolicyPayload = (domain) => ({
+        min_length: domain.minLength,
+require_letter: domain.requireLetter,
+require_upper_case: domain.requireUpperCase,
+require_lower_case: domain.requireLowerCase,
+require_digit: domain.requireDigit,
+require_special_char: domain.requireSpecialChar
+      });
+
+      export const toManagementSecuritySettings = (payload) => ({
+        recentAuthenticationValiditySecondsForOpenUser: payload.recent_authentication_validity_seconds_for_open_user,
+recentAuthenticationValiditySecondsForManagementUser: payload.recent_authentication_validity_seconds_for_management_user,
+passwordPolicy: toManagementPasswordPolicy(payload.management_password_policy),
+otpConfirmation: toOtpConfirmation(payload.otp_confirmation),
+accountLockoutPolicy: toAccountLockoutPolicy(payload.account_lockout_policy),
+accountLockoutCheckIntervalSeconds: payload.account_lockout_check_interval_seconds,
+openIpRestrictionPolicy: toIpRestrictionPolicy(payload.open_ip_restriction_policy),
+managementIpRestrictionPolicy: toIpRestrictionPolicy(payload.management_ip_restriction_policy),
+mfaTokenExpirationSeconds: payload.expiration_seconds,
+maxRequestsPerPeriod: payload.max_requests_per_period,
+rateLimitPeriodSeconds: payload.rate_limit_period_seconds,
+refreshTokenRotationGracePeriodSeconds: payload.refresh_token_rotation_grace_period_seconds
+      });
+      
+      export const toManagementSecuritySettingsPayload = (domain) => ({
+        recent_authentication_validity_seconds_for_open_user: domain.recentAuthenticationValiditySecondsForOpenUser,
+recent_authentication_validity_seconds_for_management_user: domain.recentAuthenticationValiditySecondsForManagementUser,
+management_password_policy: toManagementPasswordPolicyPayload(domain.passwordPolicy),
+otp_confirmation: toOtpConfirmationPayload(domain.otpConfirmation),
+account_lockout_policy: toAccountLockoutPolicyPayload(domain.accountLockoutPolicy),
+account_lockout_check_interval_seconds: domain.accountLockoutCheckIntervalSeconds,
+open_ip_restriction_policy: toIpRestrictionPolicyPayload(domain.openIpRestrictionPolicy),
+management_ip_restriction_policy: toIpRestrictionPolicyPayload(domain.managementIpRestrictionPolicy),
+expiration_seconds: domain.mfaTokenExpirationSeconds,
+max_requests_per_period: domain.maxRequestsPerPeriod,
+rate_limit_period_seconds: domain.rateLimitPeriodSeconds,
+refresh_token_rotation_grace_period_seconds: domain.refreshTokenRotationGracePeriodSeconds
+      });
+
+      export const toOpenSecuritySettings = (payload) => ({
+        passwordPolicy: toOpenPasswordPolicy(payload.open_password_policy),
+otpConfirmation: toOtpConfirmation(payload.otp_confirmation)
+      });
+      
+      export const toOpenSecuritySettingsPayload = (domain) => ({
+        open_password_policy: toOpenPasswordPolicyPayload(domain.passwordPolicy),
+otp_confirmation: toOtpConfirmationPayload(domain.otpConfirmation)
+      });
+
+export const toTotpRecoveryCodes = (payload) => ({
+  codes: payload.totp_recovery_codes
+});
 
-export const sortOrderSchema = z.enum(["asc", "desc"]);
+export const toTotpRecoveryCodesPayload = (domain) => ({
+  totp_recovery_codes: domain.codes
+});
 
-export const accountLockoutTypeSchema = z.enum(["none", "indefinite", "temporary"]);
+      export const toTotpSetup = (payload) => ({
+        secretKey: payload.totp_secret_key,
+otpAuthUrl: payload.totp_otp_auth_url,
+mfaToken: payload.mfa_token
+      });
+      
+      export const toTotpSetupPayload = (domain) => ({
+        totp_secret_key: domain.secretKey,
+totp_otp_auth_url: domain.otpAuthUrl,
+mfa_token: domain.mfaToken
+      });
+
+      export const toVerifyTotp = (payload) => ({
+        mfaToken: payload.mfa_token,
+code: payload.totp_code
+      });
+      
+      export const toVerifyTotpPayload = (domain) => ({
+        mfa_token: domain.mfaToken,
+totp_code: domain.code
+      });
+
+      export const toManagementGlobalSettings = (payload) => ({
+        privacyPolicyUrl: payload.privacy_policy_url,
+termsOfServiceUrl: payload.terms_of_service_url,
+contactSupportEmail: payload.contact_support_email,
+minSupportedAppVersions: payload.min_supported_app_versions,
+isTracingEnabled: payload.is_tracing_enabled,
+isMetricsEnabled: payload.is_metrics_enabled,
+isVerboseLoggingEnabled: payload.is_verbose_logging_enabled
+      });
+      
+      export const toManagementGlobalSettingsPayload = (domain) => ({
+        privacy_policy_url: domain.privacyPolicyUrl,
+terms_of_service_url: domain.termsOfServiceUrl,
+contact_support_email: domain.contactSupportEmail,
+min_supported_app_versions: domain.minSupportedAppVersions,
+is_tracing_enabled: domain.isTracingEnabled,
+is_metrics_enabled: domain.isMetricsEnabled,
+is_verbose_logging_enabled: domain.isVerboseLoggingEnabled
+      });
+
+      export const toOpenGlobalSettings = (payload) => ({
+        privacyPolicyUrl: payload.privacy_policy_url,
+termsOfServiceUrl: payload.terms_of_service_url,
+contactSupportEmail: payload.contact_support_email,
+minSupportedAppVersions: payload.min_supported_app_versions
+      });
+      
+      export const toOpenGlobalSettingsPayload = (domain) => ({
+        privacy_policy_url: domain.privacyPolicyUrl,
+terms_of_service_url: domain.termsOfServiceUrl,
+contact_support_email: domain.contactSupportEmail,
+min_supported_app_versions: domain.minSupportedAppVersions
+      });
+
+      export const toAuditEvent = (payload) => ({
+        id: toAuditEventIdOrThrow(payload.id),
+actorId: payload.actor_id,
+actorType: payload.actor_type,
+actorUserRole: payload.actor_user_role,
+action: payload.action,
+resource: payload.resource,
+resourceId: payload.resource_id,
+resourceValueSensitivity: null,
+status: payload.status,
+metadata: payload.metadata ? payload.metadata.map(val => toAuditEventMetadata(val)) : [],
+message: payload.message,
+createdAt: payload.created_at
+      });
+      
+      export const toAuditEventPayload = (domain) => ({
+        id: domain.id,
+actor_id: domain.actorId,
+actor_type: domain.actorType,
+actor_user_role: domain.actorUserRole,
+action: domain.action,
+resource: domain.resource,
+resource_id: domain.resourceId,
+status: domain.status,
+metadata: domain.metadata ? domain.metadata.map(val => toAuditEventMetadataPayload(val)) : [],
+message: domain.message,
+created_at: domain.createdAt
+      });
+
+      export const toAuditEventMetadata = (payload) => ({
+        key: payload.key,
+value: payload.value
+      });
+      
+      export const toAuditEventMetadataPayload = (domain) => ({
+        key: domain.key,
+value: domain.value,
+value_sensitivity: null
+      });
+
+      export const toAuthData = (payload) => ({
+        userDetails: toUserDetails(payload.user),
+sessionToken: toSessionToken(payload.session_token)
+      });
+      
+      export const toAuthDataPayload = (domain) => ({
+        user: toUserDetailsPayload(domain.userDetails),
+session_token: toSessionTokenPayload(domain.sessionToken)
+      });
+
+      export const toAvailableAuthProviders = (payload) => ({
+        primary: payload.primary,
+secondary: payload.secondary
+      });
+      
+      export const toAvailableAuthProvidersPayload = (domain) => ({
+        primary: domain.primary,
+secondary: domain.secondary
+      });
+
+      export const toManagementAuthSettings = (payload) => ({
+        availableAuthProviders: toAvailableAuthProviders(payload.available_auth_providers),
+maxTotalIdentifiers: payload.max_total_identifiers,
+maxEmailIdentifiers: payload.max_email_identifiers,
+maxPhoneIdentifiers: payload.max_phone_identifiers,
+maxIdentifiersPerExternalProvider: payload.max_identifiers_per_external_provider,
+maxActiveSessionsForOpenUser: payload.max_active_sessions_for_open_user,
+maxActiveSessionsForManagementUser: payload.max_active_sessions_for_management_user,
+accessTokenExpirationSeconds: payload.access_token_validity_seconds,
+refreshTokenExpirationSeconds: payload.refresh_token_validity_seconds,
+accountDeletionGracePeriodSeconds: payload.account_deletion_grace_period_seconds,
+accountDeletionCheckIntervalSeconds: payload.account_deletion_check_interval_seconds,
+isRegistrationEnabled: payload.is_registration_enabled,
+openEmailRestrictionPolicy: toEmailRestrictionPolicy(payload.open_email_restriction_policy),
+managementEmailRestrictionPolicy: toEmailRestrictionPolicy(payload.management_email_restriction_policy)
+      });
+      
+      export const toManagementAuthSettingsPayload = (domain) => ({
+        available_auth_providers: toAvailableAuthProvidersPayload(domain.availableAuthProviders),
+max_total_identifiers: domain.maxTotalIdentifiers,
+max_email_identifiers: domain.maxEmailIdentifiers,
+max_phone_identifiers: domain.maxPhoneIdentifiers,
+max_identifiers_per_external_provider: domain.maxIdentifiersPerExternalProvider,
+max_active_sessions_for_open_user: domain.maxActiveSessionsForOpenUser,
+max_active_sessions_for_management_user: domain.maxActiveSessionsForManagementUser,
+access_token_validity_seconds: domain.accessTokenExpirationSeconds,
+refresh_token_validity_seconds: domain.refreshTokenExpirationSeconds,
+account_deletion_grace_period_seconds: domain.accountDeletionGracePeriodSeconds,
+account_deletion_check_interval_seconds: domain.accountDeletionCheckIntervalSeconds,
+is_registration_enabled: domain.isRegistrationEnabled,
+open_email_restriction_policy: toEmailRestrictionPolicyPayload(domain.openEmailRestrictionPolicy),
+management_email_restriction_policy: toEmailRestrictionPolicyPayload(domain.managementEmailRestrictionPolicy)
+      });
+
+      export const toOpenAuthSettings = (payload) => ({
+        availableAuthProviders: toAvailableAuthProviders(payload.available_auth_providers),
+maxTotalIdentifiers: payload.max_total_identifiers,
+maxEmailIdentifiers: payload.max_email_identifiers,
+maxPhoneIdentifiers: payload.max_phone_identifiers,
+maxIdentifiersPerExternalProvider: payload.max_identifiers_per_external_provider,
+isRegistrationEnabled: payload.is_registration_enabled
+      });
+      
+      export const toOpenAuthSettingsPayload = (domain) => ({
+        available_auth_providers: toAvailableAuthProvidersPayload(domain.availableAuthProviders),
+max_total_identifiers: domain.maxTotalIdentifiers,
+max_email_identifiers: domain.maxEmailIdentifiers,
+max_phone_identifiers: domain.maxPhoneIdentifiers,
+max_identifiers_per_external_provider: domain.maxIdentifiersPerExternalProvider,
+is_registration_enabled: domain.isRegistrationEnabled
+      });
+
+      export const toManagementUserConfiguration = (payload) => ({
+        managementGlobalSettings: toManagementGlobalSettings(payload.management_global_settings),
+managementSecuritySettings: toManagementSecuritySettings(payload.management_security_settings),
+managementAuthSettings: toManagementAuthSettings(payload.management_auth_settings)
+      });
+      
+      export const toManagementUserConfigurationPayload = (domain) => ({
+        management_global_settings: toManagementGlobalSettingsPayload(domain.managementGlobalSettings),
+management_security_settings: toManagementSecuritySettingsPayload(domain.managementSecuritySettings),
+management_auth_settings: toManagementAuthSettingsPayload(domain.managementAuthSettings)
+      });
+
+      export const toOpenUserConfiguration = (payload) => ({
+        openGlobalSettings: toOpenGlobalSettings(payload.open_global_settings),
+openSecuritySettings: toOpenSecuritySettings(payload.open_security_settings),
+openAuthSettings: toOpenAuthSettings(payload.open_auth_settings)
+      });
+      
+      export const toOpenUserConfigurationPayload = (domain) => ({
+        open_global_settings: toOpenGlobalSettingsPayload(domain.openGlobalSettings),
+open_security_settings: toOpenSecuritySettingsPayload(domain.openSecuritySettings),
+open_auth_settings: toOpenAuthSettingsPayload(domain.openAuthSettings)
+      });
+
+      export const toEmailRestrictionPolicy = (payload) => ({
+        isBlacklistEnabled: payload.is_blacklist_enabled,
+blacklist: payload.blacklist,
+isWhitelistEnabled: payload.is_whitelist_enabled,
+whitelist: payload.whitelist
+      });
+      
+      export const toEmailRestrictionPolicyPayload = (domain) => ({
+        is_blacklist_enabled: domain.isBlacklistEnabled,
+blacklist: domain.blacklist,
+is_whitelist_enabled: domain.isWhitelistEnabled,
+whitelist: domain.whitelist
+      });
+
+      export const toUserIdentifier = (payload) => ({
+        id: toUserIdentifierIdOrThrow(payload.id),
+userId: toUserIdOrThrow(payload.user_id),
+userAuthProvider: payload.user_auth_provider,
+identifier: payload.identifier,
+displayName: payload.display_name,
+externalProviderEmail: payload.external_provider_email,
+isSensitiveValuesMasked: payload.is_sensitive_values_masked,
+createdAt: payload.created_at,
+updatedAt: payload.updated_at
+      });
+      
+      export const toUserIdentifierPayload = (domain) => ({
+        id: domain.id,
+user_id: domain.userId,
+user_auth_provider: domain.userAuthProvider,
+identifier: domain.identifier,
+display_name: domain.displayName,
+external_provider_email: domain.externalProviderEmail,
+is_sensitive_values_masked: domain.isSensitiveValuesMasked,
+created_at: domain.createdAt,
+updated_at: domain.updatedAt
+      });
+
+export const toDeletedSessions = (payload) => ({
+  deletedSessionIds: payload.deleted_session_ids ? payload.deleted_session_ids.map(val => toUserSessionIdOrThrow(val)) : []
+});
 
-export const passwordPolicyFailReasonSchema = z.enum(["too_short", "no_letter", "no_uppercase", "no_lowercase", "no_digit", "no_special_char", "too_common"]);
+export const toDeletedSessionsPayload = (domain) => ({
+  deleted_session_ids: domain.deletedSessionIds
+});
+
+      export const toUserSession = (payload) => ({
+        id: toUserSessionIdOrThrow(payload.id),
+userId: toUserIdOrThrow(payload.user_id),
+userRole: payload.user_role,
+identifier: payload.identifier,
+identifierId: toUserIdentifierIdOrThrow(payload.identifier_id),
+identifierDisplayName: payload.identifier_display_name,
+identifierAuthProvider: payload.identifier_auth_provider,
+deviceInfo: toClientDeviceInfo(payload.client_device_info),
+userAgent: payload.user_agent,
+ipAddress: payload.ip_address,
+expiresAt: payload.expires_at,
+lastAccessedAt: payload.last_accessed_at,
+lastReauthenticatedAt: payload.last_reauthenticated_at,
+isSensitiveValuesMasked: payload.is_sensitive_values_masked,
+createdAt: payload.created_at,
+updatedAt: payload.updated_at
+      });
+      
+      export const toUserSessionPayload = (domain) => ({
+        id: domain.id,
+user_id: domain.userId,
+user_role: domain.userRole,
+identifier: domain.identifier,
+identifier_id: domain.identifierId,
+identifier_display_name: domain.identifierDisplayName,
+identifier_auth_provider: domain.identifierAuthProvider,
+client_device_info: toClientDeviceInfoPayload(domain.deviceInfo),
+user_agent: domain.userAgent,
+ip_address: domain.ipAddress,
+expires_at: domain.expiresAt,
+last_accessed_at: domain.lastAccessedAt,
+last_reauthenticated_at: domain.lastReauthenticatedAt,
+is_sensitive_values_masked: domain.isSensitiveValuesMasked,
+created_at: domain.createdAt,
+updated_at: domain.updatedAt
+      });
+
+      export const toSessionToken = (payload) => ({
+        accessToken: payload.access_token,
+refreshToken: payload.refresh_token,
+expiresAt: payload.expires_at,
+tokenType: payload.token_type,
+sessionId: toUserSessionIdOrThrow(payload.session_id),
+identifierId: toUserIdentifierIdOrThrow(payload.identifier_id)
+      });
+      
+      export const toSessionTokenPayload = (domain) => ({
+        access_token: domain.accessToken,
+refresh_token: domain.refreshToken,
+expires_at: domain.expiresAt,
+token_type: domain.tokenType,
+session_id: domain.sessionId,
+identifier_id: domain.identifierId
+      });
+
+      export const toUserDetails = (payload) => ({
+        id: toUserIdOrThrow(payload.id),
+role: payload.role,
+accountStatus: payload.account_status,
+accountStatusOnRestore: payload.account_status_on_restore,
+authorityLevel: payload.authority_level,
+permissionCodes: payload.permission_codes ? payload.permission_codes.map(val => toPermissionCodeOrThrow(val)) : [],
+isTotpEnabled: payload.is_totp_enabled,
+lastLoginAt: payload.last_login_at,
+lastActiveAt: payload.last_active_at,
+createdAt: payload.created_at,
+updatedAt: payload.updated_at,
+scheduledPermanentDeletionAt: payload.scheduled_permanent_deletion_at,
+lockoutType: payload.account_lockout_type,
+temporaryLockoutUntil: payload.temporary_lockout_until
+      });
+      
+      export const toUserDetailsPayload = (domain) => ({
+        id: domain.id,
+role: domain.role,
+account_status: domain.accountStatus,
+account_status_on_restore: domain.accountStatusOnRestore,
+authority_level: domain.authorityLevel,
+permission_codes: domain.permissionCodes,
+is_totp_enabled: domain.isTotpEnabled,
+last_login_at: domain.lastLoginAt,
+last_active_at: domain.lastActiveAt,
+created_at: domain.createdAt,
+updated_at: domain.updatedAt,
+scheduled_permanent_deletion_at: domain.scheduledPermanentDeletionAt,
+account_lockout_type: domain.lockoutType,
+temporary_lockout_until: domain.temporaryLockoutUntil
+      });
+
+      export const toUserPublic = (payload) => ({
+        id: toUserIdOrThrow(payload.id),
+role: payload.role,
+accountStatus: payload.account_status
+      });
+      
+      export const toUserPublicPayload = (domain) => ({
+        id: domain.id,
+role: domain.role,
+account_status: domain.accountStatus
+      });
+
+              export const clientTypeSchema = z.enum(["web", "android", "ios", "desktop"]);
+      export const ClientType = {
+        WEB: "web",
+ANDROID: "android",
+IOS: "ios",
+DESKTOP: "desktop"
+      };
 
-export const auditActorTypeSchema = z.enum(["user", "system", "service"]);
+      export const sortOrderSchema = z.enum(["asc", "desc"]);
+      export const SortOrder = {
+        ASC: "asc",
+DESC: "desc"
+      };
 
-export const auditValueSensitivitySchema = z.enum(["non_sensitive", "email", "phone_number", "ip_address", "partial_value_mask", "full_value_mask"]);
+      export const accountLockoutTypeSchema = z.enum(["none", "indefinite", "temporary"]);
+      export const AccountLockoutType = {
+        NONE: "none",
+INDEFINITE: "indefinite",
+TEMPORARY: "temporary",
+PERMANENT: "indefinite"
+      };
 
-export const auditStatusSchema = z.enum(["success", "failed", "denied"]);
+      export const passwordPolicyFailReasonSchema = z.enum(["too_short", "no_letter", "no_uppercase", "no_lowercase", "no_digit", "no_special_char", "too_common"]);
+      export const PasswordPolicyFailReason = {
+        TOO_SHORT: "too_short",
+NO_LETTER: "no_letter",
+NO_UPPERCASE: "no_uppercase",
+NO_LOWERCASE: "no_lowercase",
+NO_DIGIT: "no_digit",
+NO_SPECIAL_CHAR: "no_special_char",
+TOO_COMMON: "too_common"
+      };
 
-export const commonAuditResourceTypeSchema = z.enum(["audit_event", "audit_events"]);
+      export const auditActorTypeSchema = z.enum(["user", "system", "service"]);
+      export const AuditActorType = {
+        USER: "user",
+SYSTEM: "system",
+SERVICE: "service"
+      };
+
+      export const auditValueSensitivitySchema = z.enum(["non_sensitive", "email", "phone_number", "ip_address", "partial_value_mask", "full_value_mask"]);
+      export const AuditValueSensitivity = {
+        NON_SENSITIVE: "non_sensitive",
+EMAIL: "email",
+PHONE_NUMBER: "phone_number",
+IP_ADDRESS: "ip_address",
+PARTIAL_VALUE_MASK: "partial_value_mask",
+FULL_VALUE_MASK: "full_value_mask"
+      };
+
+      export const auditStatusSchema = z.enum(["success", "failed", "denied"]);
+      export const AuditStatus = {
+        SUCCESS: "success",
+FAILED: "failed",
+DENIED: "denied"
+      };
+
+      export const commonAuditResourceTypeSchema = z.enum(["audit_event", "audit_events"]);
+      export const CommonAuditResourceType = {
+        AUDIT_EVENT: "audit_event",
+AUDIT_EVENTS: "audit_events"
+      };
 
 export const securityAuditResourceTypeSchema = z.enum(["security_settings"]);
+export const SecurityAuditResourceType = {
+  SECURITY_SETTINGS: "security_settings"
+};
 
 export const settingsAuditResourceTypeSchema = z.enum(["global_settings"]);
+export const SettingsAuditResourceType = {
+  GLOBAL_SETTINGS: "global_settings"
+};
 
-export const userAuditResourceTypeSchema = z.enum(["auth_settings", "user", "email_address", "phone_number", "identifier", "session"]);
+      export const userAuditResourceTypeSchema = z.enum(["auth_settings", "user", "email_address", "phone_number", "identifier", "session"]);
+      export const UserAuditResourceType = {
+        AUTH_SETTINGS: "auth_settings",
+USER: "user",
+EMAIL_ADDRESS: "email_address",
+PHONE_NUMBER: "phone_number",
+IDENTIFIER: "identifier",
+SESSION: "session"
+      };
 
-export const securityAuditActionTypeSchema = z.enum(["management_update_security_settings", "management_reset_security_settings"]);
+      export const securityAuditActionTypeSchema = z.enum(["management_update_security_settings", "management_reset_security_settings"]);
+      export const SecurityAuditActionType = {
+        MANAGEMENT_UPDATE_SECURITY_SETTINGS: "management_update_security_settings",
+MANAGEMENT_RESET_SECURITY_SETTINGS: "management_reset_security_settings"
+      };
 
-export const settingsAuditActionTypeSchema = z.enum(["management_update_global_settings", "management_reset_global_settings"]);
+      export const settingsAuditActionTypeSchema = z.enum(["management_update_global_settings", "management_reset_global_settings"]);
+      export const SettingsAuditActionType = {
+        MANAGEMENT_UPDATE_GLOBAL_SETTINGS: "management_update_global_settings",
+MANAGEMENT_RESET_GLOBAL_SETTINGS: "management_reset_global_settings"
+      };
 
-export const userAuditActionTypeSchema = z.enum(["management_update_auth_settings", "management_reset_auth_settings", "management_delete_identifier", "management_delete_identifier_password", "management_delete_session", "management_delete_all_user_sessions", "management_update_user", "management_delete_user", "management_create_user", "management_disable_user_totp", "login_by_email", "login_by_phone", "login_by_external_auth_provider", "login_by_totp", "login_by_totp_recovery_code", "new_device_detected", "register_by_email", "reset_password", "self_unlock_account", "logout", "self_delete_session", "self_delete_other_sessions", "reauthenticate_session", "self_delete_identifier", "add_identifier_email", "add_identifier_phone", "add_identifier_external_auth_provider", "change_password", "self_schedule_user_deletion", "self_restore_user", "self_setup_totp_initiated", "self_enable_totp", "self_disable_totp", "self_get_recovery_codes", "self_regenerate_recovery_codes", "refresh_token_reuse_detected"]);
+      export const userAuditActionTypeSchema = z.enum(["management_update_auth_settings", "management_reset_auth_settings", "management_delete_identifier", "management_delete_identifier_password", "management_delete_session", "management_delete_all_user_sessions", "management_update_user", "management_delete_user", "management_create_user", "management_disable_user_totp", "login_by_email", "login_by_phone", "login_by_external_auth_provider", "login_by_totp", "login_by_totp_recovery_code", "new_device_detected", "register_by_email", "reset_password", "self_unlock_account", "logout", "self_delete_session", "self_delete_other_sessions", "reauthenticate_session", "self_delete_identifier", "add_identifier_email", "add_identifier_phone", "add_identifier_external_auth_provider", "change_password", "self_schedule_user_deletion", "self_restore_user", "self_setup_totp_initiated", "self_enable_totp", "self_disable_totp", "self_get_recovery_codes", "self_regenerate_recovery_codes", "refresh_token_reuse_detected"]);
+      export const UserAuditActionType = {
+        MANAGEMENT_UPDATE_AUTH_SETTINGS: "management_update_auth_settings",
+MANAGEMENT_RESET_AUTH_SETTINGS: "management_reset_auth_settings",
+MANAGEMENT_DELETE_IDENTIFIER: "management_delete_identifier",
+MANAGEMENT_DELETE_IDENTIFIER_PASSWORD: "management_delete_identifier_password",
+MANAGEMENT_DELETE_SESSION: "management_delete_session",
+MANAGEMENT_DELETE_ALL_USER_SESSIONS: "management_delete_all_user_sessions",
+MANAGEMENT_UPDATE_USER: "management_update_user",
+MANAGEMENT_DELETE_USER: "management_delete_user",
+MANAGEMENT_CREATE_USER: "management_create_user",
+MANAGEMENT_DISABLE_USER_TOTP: "management_disable_user_totp",
+LOGIN_BY_EMAIL: "login_by_email",
+LOGIN_BY_PHONE: "login_by_phone",
+LOGIN_BY_EXTERNAL_AUTH_PROVIDER: "login_by_external_auth_provider",
+LOGIN_BY_TOTP: "login_by_totp",
+LOGIN_BY_TOTP_RECOVERY_CODE: "login_by_totp_recovery_code",
+NEW_DEVICE_DETECTED: "new_device_detected",
+REGISTER_BY_EMAIL: "register_by_email",
+RESET_PASSWORD: "reset_password",
+SELF_UNLOCK_ACCOUNT: "self_unlock_account",
+LOGOUT: "logout",
+SELF_DELETE_SESSION: "self_delete_session",
+SELF_DELETE_OTHER_SESSIONS: "self_delete_other_sessions",
+REAUTHENTICATE_SESSION: "reauthenticate_session",
+SELF_DELETE_IDENTIFIER: "self_delete_identifier",
+ADD_IDENTIFIER_EMAIL: "add_identifier_email",
+ADD_IDENTIFIER_PHONE: "add_identifier_phone",
+ADD_IDENTIFIER_EXTERNAL_AUTH_PROVIDER: "add_identifier_external_auth_provider",
+CHANGE_PASSWORD: "change_password",
+SELF_SCHEDULE_USER_DELETION: "self_schedule_user_deletion",
+SELF_RESTORE_USER: "self_restore_user",
+SELF_SETUP_TOTP_INITIATED: "self_setup_totp_initiated",
+SELF_ENABLE_TOTP: "self_enable_totp",
+SELF_DISABLE_TOTP: "self_disable_totp",
+SELF_GET_RECOVERY_CODES: "self_get_recovery_codes",
+SELF_REGENERATE_RECOVERY_CODES: "self_regenerate_recovery_codes",
+REFRESH_TOKEN_REUSE_DETECTED: "refresh_token_reuse_detected"
+      };
 
-export const userAccountStatusSchema = z.enum(["active", "read_only", "banned", "security_hold", "pending_deletion"]);
+      export const commonAuditMetadataKeySchema = z.enum(["device_id", "device_name", "client_type", "language", "app_version", "os_version", "user_agent", "key_ip_address", "host", "origin", "api_version", "trace_id", "denied_reason", "error_id", "error_code"]);
+      export const CommonAuditMetadataKey = {
+        DEVICE_ID: "device_id",
+DEVICE_NAME: "device_name",
+CLIENT_TYPE: "client_type",
+LANGUAGE: "language",
+APP_VERSION: "app_version",
+OS_VERSION: "os_version",
+USER_AGENT: "user_agent",
+IP_ADDRESS: "key_ip_address",
+HOST: "host",
+ORIGIN: "origin",
+API_VERSION: "api_version",
+TRACE_ID: "trace_id",
+DENIED_REASON: "denied_reason",
+ERROR_ID: "error_id",
+ERROR_CODE: "error_code"
+      };
 
-export const userRoleSchema = z.enum(["user", "staff", "admin"]);
+      export const userAuditMetadataKeySchema = z.enum(["user_id", "session_id", "identifier_id", "email_address", "phone_number", "user_auth_provider", "external_id", "account_lockout_type", "temporary_lockout_until"]);
+      export const UserAuditMetadataKey = {
+        USER_ID: "user_id",
+SESSION_ID: "session_id",
+IDENTIFIER_ID: "identifier_id",
+EMAIL_ADDRESS: "email_address",
+PHONE_NUMBER: "phone_number",
+USER_AUTH_PROVIDER: "user_auth_provider",
+EXTERNAL_ID: "external_id",
+ACCOUNT_LOCKOUT_TYPE: "account_lockout_type",
+TEMPORARY_LOCKOUT_UNTIL: "temporary_lockout_until"
+      };
 
-export const userAuthProviderSchema = z.enum(["email", "phone", "google", "apple"]);
+      export const userAccountStatusSchema = z.enum(["active", "read_only", "banned", "security_hold", "pending_deletion"]);
+      export const UserAccountStatus = {
+        ACTIVE: "active",
+READ_ONLY: "read_only",
+BANNED: "banned",
+SECURITY_HOLD: "security_hold",
+PENDING_DELETION: "pending_deletion"
+      };
 
-export const externalAuthProviderSchema = z.enum(["google", "apple"]);
+      export const userRoleSchema = z.enum(["user", "staff", "admin"]);
+      export const UserRole = {
+        USER: "user",
+STAFF: "staff",
+ADMIN: "admin",
+CLIENT_USER: "user",
+MANAGEMENT_USER: "admin"
+      };
+
+      export const userAuthProviderSchema = z.enum(["email", "phone", "google", "apple"]);
+      export const UserAuthProvider = {
+        EMAIL: "email",
+PHONE: "phone",
+GOOGLE: "google",
+APPLE: "apple"
+      };
+
+      export const externalAuthProviderSchema = z.enum(["google", "apple"]);
+      export const ExternalAuthProvider = {
+        GOOGLE: "google",
+APPLE: "apple"
+      };
+
+      export const userSortBySchema = z.enum(["last_login_at", "last_active_at", "scheduled_permanent_deletion_at", "account_lockout_type", "temporary_lockout_until", "created_at", "updated_at"]);
+      export const UserSortBy = {
+        LAST_LOGIN_AT: "last_login_at",
+LAST_ACTIVE_AT: "last_active_at",
+SCHEDULED_PERMANENT_DELETION_AT: "scheduled_permanent_deletion_at",
+ACCOUNT_LOCKOUT_TYPE: "account_lockout_type",
+TEMPORARY_LOCKOUT_UNTIL: "temporary_lockout_until",
+CREATED_AT: "created_at",
+UPDATED_AT: "updated_at"
+      };
+
+      export const userIdentifierSortBySchema = z.enum(["created_at", "updated_at"]);
+      export const UserIdentifierSortBy = {
+        CREATED_AT: "created_at",
+UPDATED_AT: "updated_at"
+      };
+
+      export const userSessionSortBySchema = z.enum(["expires_at", "last_accessed_at", "last_reauthenticated_at", "created_at", "updated_at"]);
+      export const UserSessionSortBy = {
+        EXPIRES_AT: "expires_at",
+LAST_ACCESSED_AT: "last_accessed_at",
+LAST_REAUTHENTICATED_AT: "last_reauthenticated_at",
+CREATED_AT: "created_at",
+UPDATED_AT: "updated_at"
+      };
+
+export const auditEventSortBySchema = z.enum(["created_at"]);
+export const AuditEventSortBy = {
+  CREATED_AT: "created_at"
+};
+
+      export const timestampSortBySchema = z.enum(["created_at", "updated_at"]);
+      export const TimestampSortBy = {
+        CREATED_AT: "created_at",
+UPDATED_AT: "updated_at"
+      };
+
+      export const unlockMethodSchema = z.enum(["EMAIL", "PHONE"]);
+      export const UnlockMethod = {
+        EMAIL: "EMAIL",
+PHONE: "PHONE"
+      };
+
+      export const confirmationTypeSchema = z.enum(["REGISTRATION_EMAIL", "ADD_EMAIL", "PASSWORD_RESET_EMAIL", "LOGIN_PHONE", "ADD_PHONE", "UNLOCK_EMAIL", "UNLOCK_PHONE"]);
+      export const ConfirmationType = {
+        REGISTRATION_EMAIL: "REGISTRATION_EMAIL",
+ADD_EMAIL: "ADD_EMAIL",
+PASSWORD_RESET_EMAIL: "PASSWORD_RESET_EMAIL",
+LOGIN_PHONE: "LOGIN_PHONE",
+ADD_PHONE: "ADD_PHONE",
+UNLOCK_EMAIL: "UNLOCK_EMAIL",
+UNLOCK_PHONE: "UNLOCK_PHONE"
+      };
+
+      export const appTypeSchema = z.enum(["CLIENT", "MANAGEMENT"]);
+      export const AppType = {
+        CLIENT: "CLIENT",
+MANAGEMENT: "MANAGEMENT"
+      };
+
+export const confirmationKeySchema = z.object({
+  type: confirmationTypeSchema,
+  identifier: z.string()
+});
+
+export const UserSortValues = {
+  UserSortBy,
+  UserIdentifierSortBy,
+  UserSessionSortBy
+};
 
         export function pagedResultSchema(itemSchema) {
   return z.object({
@@ -642,7 +1918,7 @@ created_at: z.number()
 export const auditEventMetadataPayloadSchema = z.object({
     key: z.string(),
 value: z.string(),
-value_sensitivity: z.string()
+value_sensitivity: auditValueSensitivitySchema
 });
 
 export const authDataPayloadSchema = z.object({
@@ -771,6 +2047,24 @@ role: userRoleSchema,
 account_status: userAccountStatusSchema
 });
 
+export const socketFrameSchema = z.object({
+    id: userIdSchema,
+type: z.string(),
+payload: z.unknown().nullable(),
+metadata: z.record(z.string(), z.string()),
+timestamp: z.number()
+});
+
+export const webSocketInitializePayloadSchema = z.object({
+    client_type: clientTypeSchema.nullable(),
+language: z.string().nullable(),
+device_id: clientDeviceIdSchema.nullable(),
+device_name: z.string().nullable(),
+app_version: z.string().nullable(),
+operation_system_version: z.string().nullable(),
+api_version: z.string().nullable()
+});
+
 export const createByEmailRequestSchema = z.object({
     email: z.string(),
 password: z.string().nullable(),