@mudrichenkoevgeny/shared-foundation 0.0.48 → 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,18 @@ 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",
@@ -533,6 +751,72 @@ MANAGEMENT_SECURITY_SETTINGS_UPDATED: "MANAGEMENT_SECURITY_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",
@@ -548,6 +832,52 @@ export const ListingParamNames = {
   }
 };
 
+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",
@@ -668,6 +998,512 @@ export const UserPermissionCode = {
 
 };
 
+              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 toTotpRecoveryCodesPayload = (domain) => ({
+  totp_recovery_codes: domain.codes
+});
+
+      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 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",
@@ -803,6 +1639,38 @@ SELF_REGENERATE_RECOVERY_CODES: "self_regenerate_recovery_codes",
 REFRESH_TOKEN_REUSE_DETECTED: "refresh_token_reuse_detected"
       };
 
+      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 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 userAccountStatusSchema = z.enum(["active", "read_only", "banned", "security_hold", "pending_deletion"]);
       export const UserAccountStatus = {
         ACTIVE: "active",
@@ -1050,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({