@dalmore/api-contracts 0.0.0-dev.d07da18 → 0.0.0-dev.d10f798

package/common/types/common.types.js

@@ -0,0 +1,1442 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types.js';
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { TwoFactorMethod } from './sms.types.js';
+import { normalizeShortDate } from '../helpers/index.js';
+import { HttpStatus } from '@nestjs/common';
+extendZodWithOpenApi(z);
+// All possible statuses for the system
+export var BaseStatus;
+(function (BaseStatus) {
+    BaseStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    BaseStatus["PENDING"] = "PENDING";
+    BaseStatus["APPROVED"] = "APPROVED";
+    BaseStatus["REJECTED"] = "REJECTED";
+    BaseStatus["IN_REVIEW"] = "IN_REVIEW";
+    BaseStatus["ADDITIONAL_INFO"] = "ADDITIONAL_INFO";
+    BaseStatus["SUBMITTED"] = "SUBMITTED";
+    BaseStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    BaseStatus["CANCELLED"] = "CANCELLED";
+    BaseStatus["SETTLED"] = "SETTLED";
+    BaseStatus["REFUNDED"] = "REFUNDED";
+    BaseStatus["RESUBMIT"] = "RESUBMIT";
+    BaseStatus["FUNDED"] = "FUNDED";
+    BaseStatus["COMPLETED"] = "COMPLETED";
+    BaseStatus["SIGNED"] = "SIGNED";
+    BaseStatus["DECLINED"] = "DECLINED";
+    BaseStatus["CART"] = "CART";
+    BaseStatus["PLACED"] = "PLACED";
+    BaseStatus["NEEDS_INFO"] = "NEEDS_INFO";
+    BaseStatus["NEEDS_PAYMENT_INFO"] = "NEEDS_PAYMENT_INFO";
+    BaseStatus["FUNDING"] = "FUNDING";
+    BaseStatus["CHARGED"] = "CHARGED";
+    BaseStatus["NEW"] = "NEW";
+    BaseStatus["IMPORT_ERROR"] = "IMPORT_ERROR";
+    BaseStatus["ERROR"] = "ERROR";
+    BaseStatus["UPDATE_PAYMENT_METHOD"] = "UPDATE_PAYMENT_METHOD";
+    BaseStatus["RE_SIGN"] = "RE_SIGN";
+    BaseStatus["RESET_2FA"] = "RESET_2FA";
+    BaseStatus["FORGOT_PASSWORD"] = "FORGOT_PASSWORD";
+    BaseStatus["RESET_PASSWORD"] = "RESET_PASSWORD";
+    BaseStatus["TWO_FACTOR_LOGIN"] = "TWO_FACTOR_LOGIN";
+    BaseStatus["LOGIN"] = "LOGIN";
+    BaseStatus["FAILED"] = "FAILED";
+    BaseStatus["AUTHORIZING"] = "AUTHORIZING";
+    BaseStatus["VALID"] = "VALID";
+    BaseStatus["DELETED"] = "DELETED";
+    BaseStatus["REVOKED"] = "REVOKED";
+    BaseStatus["WARNING"] = "WARNING";
+    BaseStatus["READY_TO_APPROVE"] = "READY_TO_APPROVE";
+    BaseStatus["INCOMPLETE"] = "INCOMPLETE";
+    BaseStatus["RE_PROCESS"] = "RE_PROCESS";
+    BaseStatus["INVALID"] = "INVALID";
+    BaseStatus["NOT_PROCESSED"] = "NOT_PROCESSED";
+    BaseStatus["PROCESSING"] = "PROCESSING";
+    BaseStatus["PROCESSING_ERROR"] = "PROCESSING_ERROR";
+    BaseStatus["REVIEW_ERROR"] = "REVIEW_ERROR";
+    BaseStatus["PROCESSED"] = "PROCESSED";
+    BaseStatus["SAVE"] = "SAVE";
+    BaseStatus["ACCEPTED"] = "ACCEPTED";
+    BaseStatus["ONBOARDING"] = "ONBOARDING";
+    BaseStatus["LIVE"] = "LIVE";
+    BaseStatus["OVERDUE"] = "OVERDUE";
+    BaseStatus["SUSPENDED"] = "SUSPENDED";
+    BaseStatus["INACTIVE"] = "INACTIVE";
+    BaseStatus["PARTIALLY_REFUNDED"] = "PARTIALLY_REFUNDED";
+    BaseStatus["VOIDED"] = "VOIDED";
+    BaseStatus["JOIN"] = "JOIN";
+    BaseStatus["RESTORE"] = "RESTORE";
+    BaseStatus["ACTIVE"] = "ACTIVE";
+    BaseStatus["LOCKED"] = "LOCKED";
+    BaseStatus["ENABLED"] = "ENABLED";
+    BaseStatus["DISABLED"] = "DISABLED";
+})(BaseStatus || (BaseStatus = {}));
+export const UserWithoutPasswordAccountZod = IBaseEntity.extend({
+    firstName: z.string().openapi({ example: 'Daniel' }),
+    lastName: z.string().openapi({ example: 'Ice' }),
+    email: z.string().email().openapi({ example: 'test@test.com' }),
+    provider: z.string().openapi({ example: 'email' }),
+    active: z.boolean().openapi({ example: true }),
+    lastLoginAt: z.date().nullable().openapi({ example: new Date() }),
+    loginCount: z.number().openapi({ example: 1 }),
+    inviteId: z
+        .string()
+        .nullable()
+        .openapi({ example: 'invite_01j1xgme5mfrasd02hmfwsy13a' }),
+    accountId: z
+        .string()
+        .nullable()
+        .openapi({ example: 'account_01j1xgme5mfrasd02hmfwsy13a' }),
+});
+export var ManagedByType;
+(function (ManagedByType) {
+    ManagedByType["DALMORE"] = "DALMORE";
+    ManagedByType["ISSUER"] = "ISSUER";
+})(ManagedByType || (ManagedByType = {}));
+export var Platform;
+(function (Platform) {
+    Platform["DALMORE"] = "DALMORE";
+    Platform["INTEGRATION"] = "INTEGRATION";
+})(Platform || (Platform = {}));
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (HttpMethod = {}));
+export var UserStatus;
+(function (UserStatus) {
+    UserStatus["ACTIVE"] = "ACTIVE";
+    UserStatus["LOCKED"] = "LOCKED";
+})(UserStatus || (UserStatus = {}));
+export const SENSITIVE_PATTERNS = [
+    /password/i,
+    /credit.*card/i,
+    /ssn/i,
+    /social.*security/i,
+    /token/i,
+    /access.*token/i,
+    /code/i,
+    /apiKey/i,
+    /key/i,
+    /stripeSecretKey/i,
+    /usAccountNumber/i,
+    /recoveryCodes/i,
+    /totpSecret/i,
+    /totpTemporarySecret/i,
+    /smsVerificationCode/i,
+];
+export var AccountStatus;
+(function (AccountStatus) {
+    AccountStatus["ONBOARDING"] = "ONBOARDING";
+    AccountStatus["LIVE"] = "LIVE";
+    AccountStatus["OVERDUE"] = "OVERDUE";
+    AccountStatus["SUSPENDED"] = "SUSPENDED";
+    AccountStatus["INACTIVE"] = "INACTIVE";
+})(AccountStatus || (AccountStatus = {}));
+// CHANGES TO THIS WILL REQUIRE:
+// - Migrations to update the database
+// - Update to createDefaultIssuerPaymentMethods
+// - Update to existing issuers payment methods, see UpdateIssuerPaymentMethod1755035846643
+// - Updates to TradeFundingTransitionWorker
+export var PaymentMethodType;
+(function (PaymentMethodType) {
+    PaymentMethodType["CREDIT_CARD"] = "CREDIT_CARD";
+    PaymentMethodType["WIRE"] = "WIRE";
+    PaymentMethodType["ACH"] = "ACH";
+    PaymentMethodType["BANK_ACCOUNT"] = "BANK_ACCOUNT";
+    PaymentMethodType["CHECK"] = "CHECK";
+    PaymentMethodType["RETIREMENT"] = "RETIREMENT";
+})(PaymentMethodType || (PaymentMethodType = {}));
+export const AccountZod = IBaseEntity.extend({
+    name: z.string().openapi({ example: 'Dalmore' }),
+    status: z.nativeEnum(AccountStatus).openapi({ example: AccountStatus.LIVE }),
+    managedBy: z
+        .nativeEnum(ManagedByType)
+        .nullable()
+        .openapi({ example: ManagedByType.DALMORE }),
+    platform: z.nativeEnum(Platform).openapi({ example: Platform.INTEGRATION }),
+    onboardingReviewerId: z
+        .string()
+        .nullable()
+        .openapi({ example: 'user_01j1xgme5mfrasd02hmfwsy13a' }),
+    onboardingReviewAt: z.date().nullable(),
+    allowPendingComplianceReview: z.boolean().openapi({ example: false }),
+});
+export const AccountWithoutUsersZod = IBaseEntity.extend({
+    name: z.string().openapi({ example: 'Dalmore' }),
+    status: z.nativeEnum(AccountStatus).openapi({ example: AccountStatus.LIVE }),
+    managedBy: z
+        .nativeEnum(ManagedByType)
+        .nullable()
+        .openapi({ example: ManagedByType.DALMORE }),
+    platform: z.nativeEnum(Platform).openapi({ example: Platform.INTEGRATION }),
+    onboardingReviewerId: z
+        .string()
+        .nullable()
+        .openapi({ example: 'user_01j1xgme5mfrasd02hmfwsy13a' }),
+    onboardingReviewAt: z.date().nullable(),
+    allowPendingComplianceReview: z.boolean().openapi({ example: false }),
+});
+export var PortalType;
+(function (PortalType) {
+    PortalType["COMPLIANCE"] = "COMPLIANCE";
+    PortalType["ISSUER"] = "ISSUER";
+    PortalType["INVESTOR"] = "INVESTOR";
+    PortalType["CLIENT"] = "CLIENT";
+    PortalType["SECONDARIES"] = "SECONDARIES";
+    PortalType["COMPLIANCE_APIKEY"] = "COMPLIANCE_APIKEY";
+})(PortalType || (PortalType = {}));
+export var UserType;
+(function (UserType) {
+    UserType["USER"] = "USER";
+    UserType["LEAD"] = "LEAD";
+    UserType["INVESTOR"] = "INVESTOR";
+    UserType["DEMO"] = "DEMO";
+})(UserType || (UserType = {}));
+export var UserRole;
+(function (UserRole) {
+    UserRole["API_KEY"] = "API_KEY";
+    UserRole["IMPORT"] = "IMPORT";
+    UserRole["VIEWER"] = "VIEWER";
+    UserRole["SUPPORT"] = "SUPPORT";
+    UserRole["COMPLIANCE"] = "COMPLIANCE";
+    UserRole["ADMIN"] = "ADMIN";
+    UserRole["MARKETER"] = "MARKETER";
+    UserRole["OWNER"] = "OWNER";
+    UserRole["LEGAL"] = "LEGAL";
+    UserRole["COMMUNITY_MANAGER"] = "COMMUNITY_MANAGER";
+    UserRole["ESCROW_AGENT"] = "ESCROW_AGENT";
+    UserRole["AGENT"] = "AGENT";
+    UserRole["ONBOARDING"] = "ONBOARDING";
+})(UserRole || (UserRole = {}));
+export var IssuerRole;
+(function (IssuerRole) {
+    IssuerRole["VIEWER"] = "VIEWER";
+    IssuerRole["OWNER"] = "OWNER";
+    IssuerRole["MARKETER"] = "MARKETER";
+    IssuerRole["LEGAL"] = "LEGAL";
+    IssuerRole["COMMUNITY_MANAGER"] = "COMMUNITY_MANAGER";
+    IssuerRole["COMPLIANCE"] = "COMPLIANCE";
+    IssuerRole["ADMIN"] = "ADMIN";
+    IssuerRole["SUPPORT"] = "SUPPORT";
+})(IssuerRole || (IssuerRole = {}));
+export var FileContainerType;
+(function (FileContainerType) {
+    FileContainerType["SITE"] = "SITE";
+    FileContainerType["PRIVATE"] = "PRIVATE";
+    FileContainerType["PUBLIC"] = "PUBLIC";
+    FileContainerType["ASSET"] = "ASSET";
+})(FileContainerType || (FileContainerType = {}));
+export var UserDataType;
+(function (UserDataType) {
+    UserDataType["LIVE"] = "LIVE";
+    UserDataType["TEST"] = "TEST";
+})(UserDataType || (UserDataType = {}));
+export var AccountContactType;
+(function (AccountContactType) {
+    AccountContactType["GENERAL"] = "GENERAL";
+    AccountContactType["INVESTOR"] = "INVESTOR";
+    AccountContactType["ISSUER"] = "ISSUER";
+})(AccountContactType || (AccountContactType = {}));
+// Configuration for portals and their roles - in order of hierarchy
+export const PortalConfig = {
+    // JWT AUTH
+    [PortalType.COMPLIANCE]: {
+        type: PortalType.COMPLIANCE,
+        roles: [
+            UserRole.IMPORT,
+            UserRole.VIEWER,
+            UserRole.SUPPORT,
+            UserRole.COMPLIANCE,
+            UserRole.ADMIN,
+        ],
+    },
+    [PortalType.ISSUER]: {
+        type: PortalType.ISSUER,
+        roles: [UserRole.MARKETER, UserRole.OWNER],
+    },
+    [PortalType.INVESTOR]: {
+        type: PortalType.INVESTOR,
+        roles: [UserRole.VIEWER, UserRole.OWNER],
+    },
+    // API KEY AUTH
+    [PortalType.CLIENT]: {
+        type: PortalType.CLIENT,
+        roles: [UserRole.API_KEY],
+    },
+    [PortalType.SECONDARIES]: {
+        type: PortalType.SECONDARIES,
+        roles: [UserRole.API_KEY],
+    },
+    [PortalType.COMPLIANCE_APIKEY]: {
+        type: PortalType.COMPLIANCE_APIKEY,
+        roles: [UserRole.API_KEY],
+    },
+};
+export const BaseAuthReq = z.object({
+    id: z.string(),
+    accountId: z.string(),
+    isInactiveAccount: z.boolean(),
+    active: z.boolean(),
+    role: z.nativeEnum(UserRole),
+    type: z.nativeEnum(PortalType),
+    roleId: z.string(),
+});
+// Regular user type extending base
+export const AuthUserReq = BaseAuthReq.extend({
+    userLoginId: z.string(),
+    firstName: z.string(),
+    lastName: z.string(),
+    email: z.string().email(),
+    provider: z.string(),
+    locked: z.boolean(),
+    lastLoginAt: z.date().nullable(),
+    loginCount: z.number(),
+    requiresTwoFactorSetup: z.boolean().optional(),
+    twoFactorEnabled: z.boolean().optional(),
+    twoFactorMethod: z.nativeEnum(TwoFactorMethod).optional(),
+    managedBy: z.nativeEnum(ManagedByType).optional(),
+    userType: z.nativeEnum(UserType).optional(),
+    accountStatus: z.lazy(() => z.nativeEnum(AccountStatus)),
+});
+// API key type extending base
+export const AuthApiKeyReq = BaseAuthReq.extend({
+    name: z.string(),
+    description: z.string().nullable(),
+    lastUsedAt: z.date().nullable(),
+});
+export const UserWithoutPasswordZod = IBaseEntity.extend({
+    firstName: z.string().openapi({ example: 'Daniel' }),
+    lastName: z.string().openapi({ example: 'Ice' }),
+    email: z.string().email().openapi({ example: 'test@test.com' }),
+    provider: z.string().openapi({ example: 'email' }),
+    active: z.boolean().openapi({ example: true }),
+    lastLoginAt: z.date().nullable().openapi({ example: new Date() }),
+    loginCount: z.number().openapi({ example: 1 }),
+    inviteId: z
+        .string()
+        .nullable()
+        .openapi({ example: 'invite_01j1xgme5mfrasd02hmfwsy13a' }),
+    accountId: z
+        .string()
+        .nullable()
+        .openapi({ example: 'account_01j1xgme5mfrasd02hmfwsy13a' }),
+    account: AccountWithoutUsersZod.optional(),
+});
+export const IPaginationMeta = z.object({
+    itemCount: z.number().openapi({ example: 1 }),
+    totalItems: z.number().optional().openapi({ example: 10 }),
+    itemsPerPage: z.number().openapi({ example: 1 }),
+    totalPages: z.number().optional().openapi({ example: 10 }),
+    currentPage: z.number().openapi({ example: 1 }),
+});
+export const PaginationOptionsZod = z.object({
+    page: z.coerce
+        .number()
+        .transform((val) => (val === 0 ? 1 : val))
+        .optional()
+        .default(1),
+    limit: z.coerce
+        .number()
+        .transform((val) => (val === 0 ? 10 : val))
+        .optional()
+        .default(10),
+});
+// The base action types for the system
+export var BaseAction;
+(function (BaseAction) {
+    BaseAction["CREATE"] = "CREATE";
+    BaseAction["READ"] = "READ";
+    BaseAction["UPDATE"] = "UPDATE";
+    BaseAction["DELETE"] = "DELETE";
+    BaseAction["IMPORT"] = "IMPORT";
+})(BaseAction || (BaseAction = {}));
+export var KYCStatus;
+(function (KYCStatus) {
+    KYCStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    KYCStatus["PENDING"] = "PENDING";
+    KYCStatus["APPROVED"] = "APPROVED";
+    KYCStatus["REJECTED"] = "REJECTED";
+    KYCStatus["CANCELLED"] = "CANCELLED";
+    KYCStatus["RESUBMIT"] = "RESUBMIT";
+    KYCStatus["ERROR"] = "ERROR";
+})(KYCStatus || (KYCStatus = {}));
+export var AMLStatus;
+(function (AMLStatus) {
+    AMLStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    AMLStatus["PENDING"] = "PENDING";
+    AMLStatus["APPROVED"] = "APPROVED";
+    AMLStatus["REJECTED"] = "REJECTED";
+    AMLStatus["ERROR"] = "ERROR";
+})(AMLStatus || (AMLStatus = {}));
+export var AicStatus;
+(function (AicStatus) {
+    AicStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    AicStatus["PENDING"] = "PENDING";
+    AicStatus["APPROVED"] = "APPROVED";
+    AicStatus["REJECTED"] = "REJECTED";
+    AicStatus["PROCESSED"] = "PROCESSED";
+})(AicStatus || (AicStatus = {}));
+export var IssuerStatus;
+(function (IssuerStatus) {
+    IssuerStatus["REJECTED"] = "REJECTED";
+    IssuerStatus["IN_REVIEW"] = "IN_REVIEW";
+    IssuerStatus["ADDITIONAL_INFO"] = "ADDITIONAL_INFO";
+    IssuerStatus["SUBMITTED"] = "SUBMITTED";
+    IssuerStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    IssuerStatus["APPROVED"] = "APPROVED";
+})(IssuerStatus || (IssuerStatus = {}));
+export var KYBStatus;
+(function (KYBStatus) {
+    KYBStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    KYBStatus["PENDING"] = "PENDING";
+    KYBStatus["APPROVED"] = "APPROVED";
+    KYBStatus["REJECTED"] = "REJECTED";
+})(KYBStatus || (KYBStatus = {}));
+export var SanctionsStatus;
+(function (SanctionsStatus) {
+    SanctionsStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    SanctionsStatus["PENDING"] = "PENDING";
+    SanctionsStatus["APPROVED"] = "APPROVED";
+    SanctionsStatus["REJECTED"] = "REJECTED";
+})(SanctionsStatus || (SanctionsStatus = {}));
+export var FundingStatus;
+(function (FundingStatus) {
+    FundingStatus["PENDING"] = "PENDING";
+    FundingStatus["CANCELLED"] = "CANCELLED";
+    FundingStatus["SETTLED"] = "SETTLED";
+    FundingStatus["REFUNDED"] = "REFUNDED";
+    FundingStatus["DECLINED"] = "DECLINED";
+    FundingStatus["FUNDING"] = "FUNDING";
+    FundingStatus["AUTHORIZING"] = "AUTHORIZING";
+    FundingStatus["FAILED"] = "FAILED";
+})(FundingStatus || (FundingStatus = {}));
+export var TxnCheck;
+(function (TxnCheck) {
+    TxnCheck["PENDING"] = "PENDING";
+    TxnCheck["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    TxnCheck["APPROVED"] = "APPROVED";
+    TxnCheck["REJECTED"] = "REJECTED";
+})(TxnCheck || (TxnCheck = {}));
+export var ApprovalStatus;
+(function (ApprovalStatus) {
+    ApprovalStatus["PENDING"] = "PENDING";
+    ApprovalStatus["FUNDED"] = "FUNDED";
+    ApprovalStatus["APPROVED"] = "APPROVED";
+    ApprovalStatus["REJECTED"] = "REJECTED";
+    ApprovalStatus["REFUNDED"] = "REFUNDED";
+})(ApprovalStatus || (ApprovalStatus = {}));
+export var IraCheck;
+(function (IraCheck) {
+    IraCheck["PENDING"] = "PENDING";
+    IraCheck["APPROVED"] = "APPROVED";
+    IraCheck["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    IraCheck["REJECTED"] = "REJECTED";
+})(IraCheck || (IraCheck = {}));
+export var CoveredPersonsStatus;
+(function (CoveredPersonsStatus) {
+    CoveredPersonsStatus["REJECTED"] = "REJECTED";
+    CoveredPersonsStatus["IN_REVIEW"] = "IN_REVIEW";
+    CoveredPersonsStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    CoveredPersonsStatus["COMPLETED"] = "COMPLETED";
+})(CoveredPersonsStatus || (CoveredPersonsStatus = {}));
+export var ComplianceReview;
+(function (ComplianceReview) {
+    ComplianceReview["PENDING"] = "PENDING";
+    ComplianceReview["APPROVED"] = "APPROVED";
+    ComplianceReview["REJECTED"] = "REJECTED";
+    ComplianceReview["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    ComplianceReview["CANCELLED"] = "CANCELLED";
+    ComplianceReview["READY_TO_APPROVE"] = "READY_TO_APPROVE";
+})(ComplianceReview || (ComplianceReview = {}));
+export var KYCDocumentType;
+(function (KYCDocumentType) {
+    KYCDocumentType["PASSPORT"] = "PASSPORT";
+    KYCDocumentType["DRIVER_LICENSE"] = "DRIVER_LICENSE";
+    KYCDocumentType["STATE_ID"] = "STATE_ID";
+})(KYCDocumentType || (KYCDocumentType = {}));
+export var InvestmentType;
+(function (InvestmentType) {
+    InvestmentType["INDIVIDUAL"] = "INDIVIDUAL";
+    InvestmentType["JOINT"] = "JOINT";
+    InvestmentType["ENTITY"] = "ENTITY";
+})(InvestmentType || (InvestmentType = {}));
+export var AicAccreditationType;
+(function (AicAccreditationType) {
+    AicAccreditationType["PENDING"] = "PENDING";
+    AicAccreditationType["INCOME"] = "INCOME";
+    AicAccreditationType["NET_WORTH"] = "NET_WORTH";
+    AicAccreditationType["PROFESSIONAL_CERTIFICATION"] = "PROFESSIONAL_CERTIFICATION";
+    AicAccreditationType["KNOWLEDGEABLE_EMPLOYEE"] = "KNOWLEDGEABLE_EMPLOYEE";
+})(AicAccreditationType || (AicAccreditationType = {}));
+export var InvestorAccountType;
+(function (InvestorAccountType) {
+    InvestorAccountType["INDIVIDUAL"] = "INDIVIDUAL";
+    InvestorAccountType["JOINT"] = "JOINT";
+    InvestorAccountType["RETIREMENT"] = "RETIREMENT";
+    InvestorAccountType["LEGAL_ENTITY"] = "LEGAL_ENTITY";
+})(InvestorAccountType || (InvestorAccountType = {}));
+export var SetupStatusType;
+(function (SetupStatusType) {
+    SetupStatusType["IN_PROGRESS"] = "IN_PROGRESS";
+    SetupStatusType["COMPLETE"] = "COMPLETE";
+})(SetupStatusType || (SetupStatusType = {}));
+export var SetupStepType;
+(function (SetupStepType) {
+    SetupStepType["NEW"] = "NEW";
+    SetupStepType["PERSONAL_INFO"] = "PERSONAL_INFO";
+    SetupStepType["ADDRESS"] = "ADDRESS";
+    SetupStepType["KYC"] = "KYC";
+    SetupStepType["INCOME"] = "INCOME";
+    SetupStepType["AIC_QUESTIONS"] = "AIC_QUESTIONS";
+    SetupStepType["AIC_FILES"] = "AIC_FILES";
+})(SetupStepType || (SetupStepType = {}));
+export var OfferingType;
+(function (OfferingType) {
+    OfferingType["REG_A"] = "REG_A";
+    OfferingType["REG_CF"] = "REG_CF";
+    OfferingType["REG_D"] = "REG_D";
+    OfferingType["S1"] = "S1";
+    OfferingType["EXCHANGE_NOTE"] = "EXCHANGE_NOTE";
+})(OfferingType || (OfferingType = {}));
+export var AssetType;
+(function (AssetType) {
+    AssetType["BOND"] = "BOND";
+    AssetType["STOCK"] = "STOCK";
+    AssetType["PROMISSORY_NOTE"] = "PROMISSORY_NOTE";
+})(AssetType || (AssetType = {}));
+export var AdjustmentType;
+(function (AdjustmentType) {
+    AdjustmentType["CREDIT_CARD_FEES"] = "CREDIT_CARD_FEES";
+    AdjustmentType["SERVICE_CHARGES"] = "SERVICE_CHARGES";
+    AdjustmentType["SUBSCRIPTION_DISCOUNT"] = "SUBSCRIPTION_DISCOUNT";
+})(AdjustmentType || (AdjustmentType = {}));
+export var SignatureStatus;
+(function (SignatureStatus) {
+    SignatureStatus["PENDING"] = "PENDING";
+    SignatureStatus["SIGNED"] = "SIGNED";
+    SignatureStatus["DECLINED"] = "DECLINED";
+    SignatureStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    SignatureStatus["RE_SIGN"] = "RE_SIGN";
+})(SignatureStatus || (SignatureStatus = {}));
+export var TemplateType;
+(function (TemplateType) {
+    TemplateType["INDIVIDUAL"] = "INDIVIDUAL";
+    TemplateType["JOINT"] = "JOINT";
+    TemplateType["ENTITY"] = "ENTITY";
+    TemplateType["RETIREMENT"] = "RETIREMENT";
+    TemplateType["GENERAL"] = "GENERAL";
+})(TemplateType || (TemplateType = {}));
+export var TemplateStatus;
+(function (TemplateStatus) {
+    TemplateStatus["PENDING"] = "PENDING";
+    TemplateStatus["VALID"] = "VALID";
+    TemplateStatus["ERROR"] = "ERROR";
+})(TemplateStatus || (TemplateStatus = {}));
+export var SenderIdentityStatus;
+(function (SenderIdentityStatus) {
+    SenderIdentityStatus["PENDING"] = "PENDING";
+    SenderIdentityStatus["APPROVED"] = "APPROVED";
+    SenderIdentityStatus["REJECTED"] = "DECLINED";
+    SenderIdentityStatus["DELETED"] = "DELETED";
+    SenderIdentityStatus["REVOKED"] = "REVOKED";
+})(SenderIdentityStatus || (SenderIdentityStatus = {}));
+export var DurationType;
+(function (DurationType) {
+    DurationType["DAY"] = "DAYS";
+    DurationType["WEEK"] = "WEEKS";
+    DurationType["MONTH"] = "MONTHS";
+    DurationType["YEAR"] = "YEARS";
+})(DurationType || (DurationType = {}));
+export var CoveredPersonsRoleType;
+(function (CoveredPersonsRoleType) {
+    CoveredPersonsRoleType["ENTITY"] = "ENTITY";
+    CoveredPersonsRoleType["BOARD_MEMBER"] = "BOARD_MEMBER";
+    CoveredPersonsRoleType["ADVISOR"] = "ADVISOR";
+    CoveredPersonsRoleType["CEO"] = "CEO";
+    CoveredPersonsRoleType["CFO"] = "CFO";
+    CoveredPersonsRoleType["ACCOUNTING"] = "ACCOUNTING";
+    CoveredPersonsRoleType["CPA"] = "CPA";
+    CoveredPersonsRoleType["LEGAL"] = "LEGAL";
+    CoveredPersonsRoleType["EXECUTIVE"] = "EXECUTIVE";
+    CoveredPersonsRoleType["EMPLOYEE"] = "EMPLOYEE";
+    CoveredPersonsRoleType["INVESTOR"] = "INVESTOR";
+    CoveredPersonsRoleType["PROMOTER"] = "PROMOTER";
+    CoveredPersonsRoleType["OWNER"] = "OWNER";
+    CoveredPersonsRoleType["AFFILIATED"] = "AFFILIATED";
+})(CoveredPersonsRoleType || (CoveredPersonsRoleType = {}));
+export var IDType;
+(function (IDType) {
+    IDType["PASSPORT"] = "PASSPORT";
+    IDType["DRIVERS_LICENSE"] = "DRIVERS_LICENSE";
+})(IDType || (IDType = {}));
+export var CoveredPersonType;
+(function (CoveredPersonType) {
+    CoveredPersonType["CHILD"] = "CHILD";
+    CoveredPersonType["PARENT"] = "PARENT";
+})(CoveredPersonType || (CoveredPersonType = {}));
+export var CoveredPersonFileLabels;
+(function (CoveredPersonFileLabels) {
+    CoveredPersonFileLabels["IDENTITY_FRONT"] = "IDENTITY_FRONT";
+    CoveredPersonFileLabels["IDENTITY_BACK"] = "IDENTITY_BACK";
+    CoveredPersonFileLabels["BAD_ACTOR_REPORT_FILE"] = "BAD_ACTOR_REPORT_FILE";
+})(CoveredPersonFileLabels || (CoveredPersonFileLabels = {}));
+export var IdentityFileLabels;
+(function (IdentityFileLabels) {
+    IdentityFileLabels["IDENTITY_FRONT"] = "IDENTITY_FRONT";
+    IdentityFileLabels["IDENTITY_BACK"] = "IDENTITY_BACK";
+    IdentityFileLabels["PASSPORT"] = "PASSPORT";
+})(IdentityFileLabels || (IdentityFileLabels = {}));
+export var IssuerFileLabels;
+(function (IssuerFileLabels) {
+    IssuerFileLabels["SS4_LETTER"] = "SS4_LETTER";
+    IssuerFileLabels["FORMATION_DOCUMENT"] = "FORMATION_DOCUMENT";
+    IssuerFileLabels["COVER_ART"] = "COVER_ART";
+})(IssuerFileLabels || (IssuerFileLabels = {}));
+export var OfferingFileLabels;
+(function (OfferingFileLabels) {
+    OfferingFileLabels["MEMORANDUM"] = "MEMORANDUM";
+    OfferingFileLabels["SUBSCRIPTION_AGREEMENT"] = "SUBSCRIPTION_AGREEMENT";
+    OfferingFileLabels["COVER_ART"] = "COVER_ART";
+})(OfferingFileLabels || (OfferingFileLabels = {}));
+export var SiteBrandingFileLabels;
+(function (SiteBrandingFileLabels) {
+    SiteBrandingFileLabels["LOGO"] = "LOGO";
+    SiteBrandingFileLabels["FAVICON"] = "FAVICON";
+    SiteBrandingFileLabels["BACKGROUND_IMAGE"] = "BACKGROUND_IMAGE";
+})(SiteBrandingFileLabels || (SiteBrandingFileLabels = {}));
+export var TradeFileLables;
+(function (TradeFileLables) {
+    TradeFileLables["TRADE_DOCUMENT"] = "TRADE_DOCUMENT";
+})(TradeFileLables || (TradeFileLables = {}));
+export var RetirementFileLabels;
+(function (RetirementFileLabels) {
+    RetirementFileLabels["CUSTODIAN_INSTRUCTION_DOCUMENT"] = "CUSTODIAN_INSTRUCTION_DOCUMENT";
+})(RetirementFileLabels || (RetirementFileLabels = {}));
+export var AccreditationFileLabels;
+(function (AccreditationFileLabels) {
+    AccreditationFileLabels["PROOF_OF_INCOME"] = "PROOF_OF_INCOME";
+    AccreditationFileLabels["PROOF_OF_NET_WORTH"] = "PROOF_OF_NET_WORTH";
+    AccreditationFileLabels["EMPLOYEE"] = "EMPLOYEE";
+    AccreditationFileLabels["TAX_RETURNS"] = "TAX_RETURNS";
+    AccreditationFileLabels["ACCOUNT_STATEMENT"] = "ACCOUNT_STATEMENT";
+    AccreditationFileLabels["ACCREDITATION_LETTER"] = "ACCREDITATION_LETTER";
+    AccreditationFileLabels["LICENSE"] = "LICENSE";
+})(AccreditationFileLabels || (AccreditationFileLabels = {}));
+export var OtherFileLabels;
+(function (OtherFileLabels) {
+    OtherFileLabels["OTHER"] = "OTHER";
+    OtherFileLabels["COMPLIANCE_REQUEST"] = "COMPLIANCE_REQUEST";
+    OtherFileLabels["SUB_DOC"] = "SUB_DOC";
+})(OtherFileLabels || (OtherFileLabels = {}));
+export const FileLabels = {
+    ...AccreditationFileLabels,
+    ...CoveredPersonFileLabels,
+    ...OtherFileLabels,
+    ...RetirementFileLabels,
+    ...SiteBrandingFileLabels,
+    ...OfferingFileLabels,
+    ...IssuerFileLabels,
+    ...IdentityFileLabels,
+    ...TradeFileLables,
+};
+export const FileLabelsEnum = z.enum(Object.values(FileLabels));
+export var TradeType;
+(function (TradeType) {
+    TradeType["PURCHASE"] = "PURCHASE";
+    TradeType["CONVERSION"] = "CONVERSION";
+    TradeType["TRANSFER"] = "TRANSFER";
+})(TradeType || (TradeType = {}));
+export var TradeStatus;
+(function (TradeStatus) {
+    TradeStatus["CART"] = "CART";
+    TradeStatus["PLACED"] = "PLACED";
+    TradeStatus["IN_REVIEW"] = "IN_REVIEW";
+    TradeStatus["NEEDS_INFO"] = "NEEDS_INFO";
+    TradeStatus["NEEDS_PAYMENT_INFO"] = "NEEDS_PAYMENT_INFO";
+    TradeStatus["FUNDING"] = "FUNDING";
+    TradeStatus["CANCELLED"] = "CANCELLED";
+    TradeStatus["SETTLED"] = "SETTLED";
+    TradeStatus["IMPORT_ERROR"] = "IMPORT_ERROR";
+    TradeStatus["ERROR"] = "ERROR";
+    TradeStatus["UPDATE_PAYMENT_METHOD"] = "UPDATE_PAYMENT_METHOD";
+})(TradeStatus || (TradeStatus = {}));
+export var SavedQuery;
+(function (SavedQuery) {
+    SavedQuery["ERROR_REPORT"] = "ERROR_REPORT";
+    SavedQuery["STUCK_TRADES"] = "STUCK_TRADES";
+})(SavedQuery || (SavedQuery = {}));
+export var SystemReviewLogTrigger;
+(function (SystemReviewLogTrigger) {
+    SystemReviewLogTrigger["AML_STATUS_UPDATE"] = "AML_STATUS_UPDATE";
+    SystemReviewLogTrigger["AIC_STATUS_UPDATE"] = "AIC_STATUS_UPDATE";
+    SystemReviewLogTrigger["INDIVIDUAL_UPDATE"] = "INDIVIDUAL_UPDATE";
+    SystemReviewLogTrigger["TRADE_STATUS_UPDATE"] = "TRADE_STATUS_UPDATE";
+    SystemReviewLogTrigger["KYC_STATUS_UPDATE"] = "KYC_STATUS_UPDATE";
+    SystemReviewLogTrigger["SUBDOC_STATUS_UPDATE"] = "SUBDOC_STATUS_UPDATE";
+    SystemReviewLogTrigger["VALIDATE_PLACED_TRADES_WORKER"] = "VALIDATE_PLACED_TRADES_WORKER";
+})(SystemReviewLogTrigger || (SystemReviewLogTrigger = {}));
+export var OfferingOnboardingStatus;
+(function (OfferingOnboardingStatus) {
+    OfferingOnboardingStatus["IN_REVIEW"] = "IN_REVIEW";
+    OfferingOnboardingStatus["COMPLETE"] = "COMPLETED";
+})(OfferingOnboardingStatus || (OfferingOnboardingStatus = {}));
+export var ExchangeProvider;
+(function (ExchangeProvider) {
+    ExchangeProvider["PPEX"] = "PPEX";
+    ExchangeProvider["PHOENIX"] = "PHOENIX";
+    ExchangeProvider["NORTHCAP"] = "NORTHCAP";
+})(ExchangeProvider || (ExchangeProvider = {}));
+export var RunnerType;
+(function (RunnerType) {
+    RunnerType["WORKER"] = "WORKER";
+    RunnerType["PIPELINE"] = "PIPELINE";
+})(RunnerType || (RunnerType = {}));
+export var PublicDataType;
+(function (PublicDataType) {
+    PublicDataType["DATA_ROOM"] = "DATA_ROOM";
+    PublicDataType["PAGE"] = "PAGE";
+    PublicDataType["OFFERING"] = "OFFERING";
+})(PublicDataType || (PublicDataType = {}));
+export var TrustedContactRelationship;
+(function (TrustedContactRelationship) {
+    TrustedContactRelationship["SIBLING"] = "SIBLING";
+    TrustedContactRelationship["GUARDIAN"] = "GUARDIAN";
+    TrustedContactRelationship["CHILD"] = "CHILD";
+    TrustedContactRelationship["FRIEND"] = "FRIEND";
+    TrustedContactRelationship["OTHER"] = "OTHER";
+})(TrustedContactRelationship || (TrustedContactRelationship = {}));
+export var FileStatus;
+(function (FileStatus) {
+    FileStatus["PENDING"] = "PENDING";
+    FileStatus["ERROR"] = "ERROR";
+    FileStatus["VALID"] = "VALID";
+    FileStatus["INVALID"] = "INVALID";
+    FileStatus["NOT_PROCESSED"] = "NOT_PROCESSED";
+    FileStatus["PROCESSING"] = "PROCESSING";
+    FileStatus["PROCESSING_ERROR"] = "PROCESSING_ERROR";
+    FileStatus["REVIEW_ERROR"] = "REVIEW_ERROR";
+    FileStatus["PROCESSED"] = "PROCESSED";
+})(FileStatus || (FileStatus = {}));
+export var SystemReviewStatus;
+(function (SystemReviewStatus) {
+    SystemReviewStatus["PENDING"] = "PENDING";
+    SystemReviewStatus["NEEDS_INFO"] = "NEEDS_INFO";
+    SystemReviewStatus["READY_TO_APPROVE"] = "READY_TO_APPROVE";
+    SystemReviewStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    SystemReviewStatus["APPROVED"] = "APPROVED";
+    SystemReviewStatus["REJECTED"] = "REJECTED";
+})(SystemReviewStatus || (SystemReviewStatus = {}));
+export var FilingStatus;
+(function (FilingStatus) {
+    FilingStatus["SINGLE"] = "SINGLE";
+    FilingStatus["JOINT"] = "JOINT";
+})(FilingStatus || (FilingStatus = {}));
+export var AccountType;
+(function (AccountType) {
+    AccountType["CHECKING"] = "CHECKING";
+    AccountType["SAVINGS"] = "SAVINGS";
+    AccountType["BROKERAGE"] = "BROKERAGE";
+    AccountType["REAL_ESTATE"] = "REAL_ESTATE";
+    AccountType["OTHER"] = "OTHER";
+})(AccountType || (AccountType = {}));
+export var SourceOfIncome;
+(function (SourceOfIncome) {
+    SourceOfIncome["EMPLOYED"] = "EMPLOYED";
+    SourceOfIncome["SELF_EMPLOYED"] = "SELF_EMPLOYED";
+    SourceOfIncome["UNEMPLOYED"] = "UNEMPLOYED";
+    SourceOfIncome["RETIREMENT"] = "RETIREMENT";
+    SourceOfIncome["STUDENT"] = "STUDENT";
+})(SourceOfIncome || (SourceOfIncome = {}));
+export var DateField;
+(function (DateField) {
+    DateField["RAW_ORDER_CREATED_DATE"] = "rawOrder.createdDate";
+    DateField["RAW_TRADE_CREATED_DATE"] = "rawTrade.createdDate";
+    DateField["CREATED_AT"] = "createdAt";
+})(DateField || (DateField = {}));
+export const DateFieldMap = {
+    [DateField.RAW_ORDER_CREATED_DATE]: "raw_order_data->>'createdDate'",
+    [DateField.RAW_TRADE_CREATED_DATE]: "raw_trade_data->>'createdDate'",
+    [DateField.CREATED_AT]: 'entity.createdAt',
+};
+/**
+ * Event fields represent database entity columns that can be changed using status.changed events.
+ * These enum values correspond to actual column names in various database entities
+ * and are used to track field-level changes in the system's activity logging.
+ */
+export var EventField;
+(function (EventField) {
+    EventField["STATUS"] = "status";
+    EventField["TRADE_STATUS"] = "tradeStatus";
+    EventField["FUNDING_STATUS"] = "fundingStatus";
+    EventField["COMPLIANCE_REVIEW"] = "complianceReview";
+    EventField["SYSTEM_REVIEW_CHECK"] = "systemReviewCheck";
+    EventField["SYSTEM_REVIEW"] = "systemReview";
+    EventField["KYC_STATUS"] = "kycStatus";
+    EventField["AML_STATUS"] = "amlStatus";
+    EventField["AIC_STATUS"] = "aicStatus";
+    EventField["SA_STATUS"] = "saStatus";
+    EventField["ONBOARDING_STATUS"] = "onboardingStatus";
+    EventField["TRANSACTION_STATUS"] = "transactionStatus";
+    EventField["ACTIVE"] = "active";
+    EventField["LOCKED"] = "locked";
+})(EventField || (EventField = {}));
+export var EventName;
+(function (EventName) {
+    EventName["STATUS_CHANGED"] = "status.changed";
+    EventName["UPDATE_FIELD"] = "update.field";
+    EventName["ACTION_PERFORMED"] = "action.performed";
+    EventName["PENDING_OVERDUE_TRADES_ALERT"] = "pending_overdue.trades.alert";
+    EventName["IN_REVIEW_TRADES_ALERT"] = "trade.inreview.alert";
+    EventName["INDIVIDUAL_AML_STATUS_CHANGED"] = "individual.aml_status.changed";
+    EventName["ISSUER_CREATED"] = "issuer.created";
+})(EventName || (EventName = {}));
+// pending charged settled refunded cancelled
+export var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["PENDING"] = "PENDING";
+    TransactionStatus["CHARGED"] = "CHARGED";
+    TransactionStatus["APPROVED"] = "APPROVED";
+    TransactionStatus["SETTLED"] = "SETTLED";
+    TransactionStatus["REFUNDED"] = "REFUNDED";
+    TransactionStatus["CANCELLED"] = "CANCELLED";
+    TransactionStatus["DECLINED"] = "DECLINED";
+    TransactionStatus["FAILED"] = "FAILED";
+    TransactionStatus["AUTHORIZING"] = "AUTHORIZING";
+    TransactionStatus["FUNDING"] = "FUNDING";
+    TransactionStatus["PARTIALLY_REFUNDED"] = "PARTIALLY_REFUNDED";
+    TransactionStatus["VOIDED"] = "VOIDED";
+})(TransactionStatus || (TransactionStatus = {}));
+//charge, refund, adjustment
+export var TransactionType;
+(function (TransactionType) {
+    TransactionType["CHARGE"] = "CHARGE";
+    TransactionType["REFUND"] = "REFUND";
+    TransactionType["ADJUSTMENT"] = "ADJUSTMENT";
+})(TransactionType || (TransactionType = {}));
+const parseDate = (str) => {
+    if (!str)
+        return null;
+    const [monthStr, dayStr, yearStr] = str.split('/');
+    const month = Number(monthStr);
+    const day = Number(dayStr);
+    const year = Number(yearStr);
+    if (isNaN(month) || isNaN(day) || isNaN(year)) {
+        return null;
+    }
+    return new Date(year, month - 1, day);
+};
+export const dateSchema = z
+    .string()
+    .nullable()
+    .refine((val) => {
+    if (!val)
+        return true;
+    const regex = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/;
+    return regex.test(val);
+}, { message: 'Date must be in MM/DD/YYYY format' })
+    .transform((val) => (val ? parseDate(val) : null));
+/**
+ * Creates a Zod schema for parsing and transforming date strings in MM/DD/YYYY format.
+ * The schema accepts a parameter to determine if the date should be formatted as the start or end of the day.
+ * - If param is 'START', the time is set to 00:00:00.000 (local, no timezone effect).
+ * - If param is 'END', the time is set to 23:59:59.999 (local, no timezone effect).
+ * - Otherwise, the time is set to 00:00:00.000.
+ * The returned value is a Date object or null.
+ */
+export const createDateSchema = (param) => z
+    .string()
+    .nullable()
+    .refine((val) => {
+    if (!val)
+        return true;
+    const regex = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/;
+    return regex.test(val);
+}, { message: 'Date must be in MM/DD/YYYY format' })
+    .transform((val) => {
+    if (!val)
+        return null;
+    const [monthStr, dayStr, yearStr] = val.split('/');
+    const month = Number(monthStr);
+    const day = Number(dayStr);
+    const year = Number(yearStr);
+    if (isNaN(month) || isNaN(day) || isNaN(year)) {
+        return null;
+    }
+    let date;
+    if (param === 'END') {
+        // Set to 23:59:59.999 local, then force to end of day in UTC
+        date = new Date(Date.UTC(year, month - 1, day, 23, 59, 59, 999));
+    }
+    else {
+        // Default to START or normal, set to 00:00:00.000 UTC
+        date = new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0));
+    }
+    return date;
+});
+/**
+ * Default dateSchema (no param) for backward compatibility.
+ */
+export const dateSchemaWithParam = createDateSchema();
+export var IssuerOnboardingSetupType;
+(function (IssuerOnboardingSetupType) {
+    IssuerOnboardingSetupType["OFFERING"] = "OFFERING";
+    IssuerOnboardingSetupType["INVESTOR_PORTAL"] = "INVESTOR_PORTAL";
+    IssuerOnboardingSetupType["PAYMENT_METHOD"] = "PAYMENT_METHOD";
+    IssuerOnboardingSetupType["ACCOUNT_CONTACTS"] = "ACCOUNT_CONTACTS";
+})(IssuerOnboardingSetupType || (IssuerOnboardingSetupType = {}));
+export var ThemeScope;
+(function (ThemeScope) {
+    ThemeScope["ACCOUNT"] = "ACCOUNT";
+    ThemeScope["SYSTEM"] = "SYSTEM";
+})(ThemeScope || (ThemeScope = {}));
+/**
+ * The configuration for the target tables. Used in Notes, Files, and Activities
+ * All tables that need to be targeted should be added here.
+ * to determine the target table from the target ID.
+ * TODO: UPDATE WITH MORE TABLES
+ * CHANGES HERE WILL REQUIRE A MIGRATION
+ */
+export const TargetTableConfig = {
+    KYCS: { table: 'kycs', idPrefix: 'kyc' },
+    AMLS: { table: 'amls', idPrefix: 'aml' },
+    AICS: { table: 'aics', idPrefix: 'aic' },
+    KYBS: { table: 'kybs', idPrefix: 'kyb' },
+    INDIVIDUALS: { table: 'individuals', idPrefix: 'individual' },
+    LEGAL_ENTITIES: { table: 'legal_entities', idPrefix: 'legal_entity' },
+    INVESTOR_ACCOUNTS: {
+        table: 'investor_accounts',
+        idPrefix: 'investor_account',
+    },
+    TRADES: { table: 'trades', idPrefix: 'trade' },
+    OFFERINGS: { table: 'offerings', idPrefix: 'offering' },
+    ISSUERS: { table: 'issuers', idPrefix: 'issuer' },
+    COVERED_PERSONS: { table: 'covered_persons', idPrefix: 'covered_person' },
+    PAYMENT_METHODS: { table: 'payment_methods', idPrefix: 'payment_method' },
+    NOTES: { table: 'notes', idPrefix: 'note' },
+    USERS: { table: 'users', idPrefix: 'user' },
+    ACCOUNTS: { table: 'accounts', idPrefix: 'account' },
+    PAGES: { table: 'pages', idPrefix: 'page' },
+    TASKS: { table: 'tasks', idPrefix: 'task' },
+    FILES: { table: 'files', idPrefix: 'file' },
+    DATA_RECORD_FILES: {
+        table: 'data_record_files',
+        idPrefix: 'data_record_file',
+    },
+    ASSETS: { table: 'assets', idPrefix: 'asset' },
+    SITES: { table: 'sites', idPrefix: 'site' },
+    PAGE_REVISIONS: { table: 'page_revisions', idPrefix: 'page_revision' },
+    TRADE_LINE_ITEMS: { table: 'trade_line_items', idPrefix: 'trade_line_item' },
+    TRANSACTIONS: { table: 'transactions', idPrefix: 'transaction' },
+    DISBURSEMENTS: { table: 'disbursements', idPrefix: 'disbursement' },
+    DISBURSEMENT_REVIEWS: {
+        table: 'disbursement_reviews',
+        idPrefix: 'disbursement_review',
+    },
+    ISSUER_PAYMENT_METHODS: {
+        table: 'issuer_payment_methods',
+        idPrefix: 'issuer_payment_method',
+    },
+    SIGNER_BRANDS: { table: 'signer_brands', idPrefix: 'signer_brand' },
+    THEMES: { table: 'themes', idPrefix: 'theme' },
+    THEME_SETTINGS: { table: 'theme_settings', idPrefix: 'theme_setting' },
+    CAP_TABLES: { table: 'cap_tables', idPrefix: 'cap_table' },
+    CAP_TABLE_SHARE_CLASSES: {
+        table: 'cap_table_share_classes',
+        idPrefix: 'cap_table_share_class',
+    },
+    CAP_TABLE_ENTRIES: {
+        table: 'cap_table_entries',
+        idPrefix: 'cap_table_entry',
+    },
+};
+export const TargetTableEnum = Object.keys(TargetTableConfig);
+/**
+ * Get the target table name from a target ID.
+ * @param targetId - The target ID to get the table name for.
+ * @returns The target table name or null if the target ID is invalid.
+ */
+export function getTargetTableFromId(targetId) {
+    try {
+        const tid = TypeID.fromString(targetId);
+        const prefix = tid.getType();
+        for (const config of Object.values(TargetTableConfig)) {
+            if (config.idPrefix === prefix) {
+                return config.table;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export var UrlClassification;
+(function (UrlClassification) {
+    UrlClassification["BASE64"] = "BASE64";
+    UrlClassification["REGULAR"] = "REGULAR";
+    UrlClassification["INVALID"] = "INVALID";
+})(UrlClassification || (UrlClassification = {}));
+export var OfferingVersioningType;
+(function (OfferingVersioningType) {
+    OfferingVersioningType["PUBLISHED"] = "PUBLISHED";
+    OfferingVersioningType["DRAFT"] = "DRAFT";
+})(OfferingVersioningType || (OfferingVersioningType = {}));
+/**
+ * Get the target table type from a target ID.
+ * @param targetId - The target ID to get the table type for.
+ * @returns The target table type or null if the target ID is invalid.
+ */
+export function getTargetTableTypeFromId(targetId) {
+    try {
+        const tid = TypeID.fromString(targetId);
+        const prefix = tid.getType();
+        for (const [tableType, config] of Object.entries(TargetTableConfig)) {
+            if (config.idPrefix === prefix) {
+                return tableType;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export const REDACTED = '[REDACTED]';
+/**
+ * Zod schema for validating and normalizing URLs.
+ *
+ * This schema ensures that the URL is valid and normalizes it by removing the protocol (http/https)
+ * and any path after the main domain.
+ *
+ * @example
+ * UrlSchema.parse('https://www.example.com'); // Valid URL, normalized to 'www.example.com'
+ * UrlSchema.parse('abc.example.org'); // Valid URL, normalized to 'abc.example.org'
+ * UrlSchema.parse('https://subdomain.example.co.uk/path'); // Valid URL, normalized to 'subdomain.example.co.uk'
+ * UrlSchema.parse('ftp://example.com'); // Throws validation error
+ * UrlSchema.parse('invalid-url'); // Throws validation error
+ */
+export const createUrlSchema = (options) => {
+    return z
+        .string()
+        .refine((value) => {
+        try {
+            // If strict mode is enabled, require abc.def.com format (at least one subdomain)
+            const urlPattern = options?.strict
+                ? /^(https?:\/\/)?([a-zA-Z0-9-]+\.[a-zA-Z0-9-]+\.[a-zA-Z]{2,})(\/.*)?$/
+                : /^(https?:\/\/)?(www\.)?([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}(\/.*)?$/;
+            return urlPattern.test(value);
+        }
+        catch {
+            return false;
+        }
+    }, {
+        message: options?.strict
+            ? 'Invalid URL. Must be in format abc.def.com'
+            : 'Invalid URL',
+    })
+        .transform((value) => {
+        try {
+            const url = new URL(value.startsWith('http') || value.startsWith('https')
+                ? value
+                : `http://${value}`);
+            return url.hostname.toLowerCase();
+        }
+        catch {
+            return value.toLowerCase();
+        }
+    })
+        .openapi({
+        example: options?.strict ? 'subdomain.example.com' : 'www.example.com',
+    });
+};
+export const UrlSchema = createUrlSchema();
+/**
+ * Zod schema for validating subdomains.
+ *
+ * This schema ensures that the subdomain contains only alphanumeric characters and hyphens,
+ * does not start or end with a hyphen, and follows standard subdomain naming conventions.
+ *
+ * @example
+ * SubdomainSchema.parse('my-site'); // Valid subdomain
+ * SubdomainSchema.parse('123test'); // Valid subdomain
+ * SubdomainSchema.parse('my_site'); // Throws validation error (underscore not allowed)
+ * SubdomainSchema.parse('-mysite'); // Throws validation error (cannot start with hyphen)
+ * SubdomainSchema.parse('mysite-'); // Throws validation error (cannot end with hyphen)
+ */
+export const SubdomainSchema = z
+    .string()
+    .min(1, { message: 'Subdomain cannot be empty' })
+    .max(63, { message: 'Subdomain cannot exceed 63 characters' })
+    .refine((value) => {
+    // Subdomain can only contain alphanumeric characters and hyphens
+    // Cannot start or end with a hyphen
+    const subdomainPattern = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
+    return subdomainPattern.test(value);
+}, {
+    message: 'Subdomain can only contain letters, numbers, and hyphens, and cannot start or end with a hyphen',
+})
+    .transform((value) => value.toLowerCase())
+    .openapi({ example: 'my-site' });
+/**
+ * Zod schema for validating domain names without subdomains.
+ *
+ * This schema ensures the domain is in a valid format (example.com) without subdomains.
+ *
+ * @example
+ * DomainSchema.parse('example.com'); // Valid domain
+ * DomainSchema.parse('subdomain.example.com'); // Throws validation error
+ */
+export const DomainSchema = z
+    .string()
+    .refine((value) => {
+    // Only allow a single dot to prevent subdomains
+    const parts = value.split('.');
+    if (parts.length !== 2)
+        return false;
+    // Basic domain format validation
+    const domainPattern = /^[a-zA-Z0-9-]+\.[a-zA-Z]{2,}$/;
+    return domainPattern.test(value);
+}, {
+    message: 'Invalid domain format. Must be a domain without subdomains (e.g., example.com)',
+})
+    .openapi({ example: 'example.com' });
+/**
+ * Zod schema for validating hex color codes (with optional alpha/transparency).
+ *
+ * This schema allows hex codes with or without a leading '#', and accepts 3, 4, 6, 7, or 8 hex digits (e.g., #RRGGBB, #RRGGBBA, #RRGGBBAA, #RGB, #RGBA, #XXXXXXX).
+ * The 7-digit form (e.g., #RRGGBBA) is supported to allow for transparency/alpha values at the end.
+ * It also trims whitespace and lowercases the value.
+ *
+ * @example
+ * HexCodeColorSchema.parse('#FF0000'); // Valid hex code
+ * HexCodeColorSchema.parse('FF0000'); // Valid hex code
+ * HexCodeColorSchema.parse('#F00'); // Valid hex code
+ * HexCodeColorSchema.parse('F00'); // Valid hex code
+ * HexCodeColorSchema.parse('#FF000080'); // Valid hex code (with alpha)
+ * HexCodeColorSchema.parse('#D9D9D14'); // Valid hex code (7 digits, with transparency)
+ * HexCodeColorSchema.parse(' #abc '); // Valid hex code, returns '#abc'
+ * HexCodeColorSchema.parse('#XYZ'); // Throws validation error
+ */
+export const HexCodeColorSchema = z
+    .string()
+    .trim()
+    .transform((val) => (val.startsWith('#') ? val : `#${val}`))
+    .refine((val) => /^#[A-Fa-f0-9]{3}$/.test(val) || // #RGB
+    /^#[A-Fa-f0-9]{4}$/.test(val) || // #RGBA
+    /^#[A-Fa-f0-9]{6}$/.test(val) || // #RRGGBB
+    /^#[A-Fa-f0-9]{7}$/.test(val) || // #RRGGBBA (7 digits, e.g., with transparency)
+    /^#[A-Fa-f0-9]{8}$/.test(val), // #RRGGBBAA
+{
+    message: 'Invalid color hex code. It should be 3, 4, 6, 7, or 8 hex digits, with or without a leading "#".',
+})
+    .openapi({ example: '#FFA500' });
+export const WithCoverArtUrl = z.object({
+    coverArtUrl: z.string().nullable().optional(),
+});
+export const UNKNOWN = 'unknown';
+export var UserManualType;
+(function (UserManualType) {
+    UserManualType["FAQ"] = "FAQ";
+    UserManualType["USER_MANUAL"] = "USER_MANUAL";
+})(UserManualType || (UserManualType = {}));
+export var BulkExportType;
+(function (BulkExportType) {
+    BulkExportType["INVESTOR_ACCOUNTS"] = "INVESTOR_ACCOUNTS";
+    BulkExportType["TRADES"] = "TRADES";
+    BulkExportType["COMPLIANCE_TRADES"] = "COMPLIANCE_TRADES";
+    BulkExportType["SECONDARY_CUSTOMERS"] = "SECONDARY_CUSTOMERS";
+    BulkExportType["SECONDARY_TRADES"] = "SECONDARY_TRADES";
+})(BulkExportType || (BulkExportType = {}));
+export const SubmitIssuerOfferingError = z.object({
+    field: z.string(),
+    message: z.string(),
+    id: z.string().optional(),
+});
+export const ErrorResponseZod = z.object({
+    valid: z.boolean(),
+    errors: z.array(SubmitIssuerOfferingError),
+});
+/**
+ * A Zod schema that preprocesses a value to convert it to a number if it is a string.
+ * If the value is a string, it attempts to parse it as a float. If parsing fails, it returns `undefined`.
+ * If the value is already a number, it is returned as is.
+ *
+ * @example
+ * numberFromStringOrNumber.parse("123.45"); // returns 123.45
+ * numberFromStringOrNumber.parse(123.45); // returns 123.45
+ * numberFromStringOrNumber.parse("abc"); // throws a ZodError
+ *
+ * @type {ZodSchema<number>}
+ */
+export const numberFromStringOrNumber = (fieldName) => z.preprocess((val) => {
+    if (typeof val === 'string') {
+        const parsed = parseFloat(val);
+        return isNaN(parsed) ? undefined : parsed;
+    }
+    return val;
+}, z.number({
+    required_error: `${fieldName} field is required.`,
+    invalid_type_error: `${fieldName} field is required.`,
+}));
+/**
+ * Creates a Zod schema for transforming number values to a specified decimal precision.
+ * Transforms the number to exactly the specified decimal places without validation.
+ * Accepts a base number schema with constraints (e.g., .positive(), .max()) and applies precision transformation.
+ *
+ * @param precision - The number of decimal places to enforce. Defaults to 2.
+ * @param baseSchema - Optional base number schema with constraints. Defaults to z.number().
+ * @returns A Zod schema that transforms numbers to the specified decimal precision.
+ *
+ * @example
+ * numberPrecisionSchema(2).parse(123.456); // returns 123.46 (transformed)
+ * numberPrecisionSchema(2).parse(123.45); // returns 123.45
+ * numberPrecisionSchema(2).parse(123.4); // returns 123.40 (transformed)
+ * numberPrecisionSchema(3, z.number().positive().max(1000)).parse(500.9999); // returns 501.000 (transformed)
+ * numberPrecisionSchema(2, z.number().positive().max(1000)).parse(500.99); // returns 500.99
+ */
+export const numberPrecisionSchema = (precision = 2, baseSchema = z.number()) => baseSchema.transform((value) => {
+    if (!isFinite(value)) {
+        return value; // Return Infinity or -Infinity as-is
+    }
+    if (precision === 0) {
+        return Math.round(value);
+    }
+    // Round in two steps to reduce floating-point drift:
+    // 1) trim the value with extra precision
+    // 2) round the trimmed value at the target precision
+    const factor = Math.pow(10, precision);
+    // Trim with extra precision (precision + 5) to keep enough significant digits
+    const trimmed = parseFloat(value.toFixed(Math.min(precision + 5, 20)));
+    // Round at target precision
+    const rounded = Math.round(trimmed * factor) / factor;
+    // Ensure the returned number has exact decimal places
+    return parseFloat(rounded.toFixed(precision));
+});
+/**
+ * Convenience function for 2 decimal precision (backward compatibility).
+ * @deprecated Use numberPrecisionSchema(2) instead.
+ */
+export const amountPrecision2Schema = (baseSchema = z.number()) => numberPrecisionSchema(2, baseSchema);
+export var RetirementAccountType;
+(function (RetirementAccountType) {
+    RetirementAccountType["SELF_DIRECTED"] = "SELF_DIRECTED";
+    RetirementAccountType["CUSTODIAN_MANAGED"] = "CUSTODIAN_MANAGED";
+})(RetirementAccountType || (RetirementAccountType = {}));
+export var EmploymentStatus;
+(function (EmploymentStatus) {
+    EmploymentStatus["EMPLOYED"] = "EMPLOYED";
+    EmploymentStatus["UNEMPLOYED"] = "UNEMPLOYED";
+    EmploymentStatus["SELF_EMPLOYED"] = "SELF_EMPLOYED";
+    EmploymentStatus["RETIRED"] = "RETIRED";
+    EmploymentStatus["STUDENT"] = "STUDENT";
+    EmploymentStatus["OTHER"] = "OTHER";
+})(EmploymentStatus || (EmploymentStatus = {}));
+export const dateSchemaWithNormalization = z
+    .string()
+    .nullable()
+    .transform((val) => (val ? normalizeShortDate(val) : null))
+    .refine((val) => {
+    if (!val)
+        return true;
+    const regex = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$/;
+    return regex.test(val);
+}, { message: 'Date must be in MM/DD/YYYY format' })
+    .transform((val) => (val ? parseDate(val) : null));
+export const DateRangeFiltersZod = z.object({
+    from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+    to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export const metadataSchema = z
+    .string()
+    .min(2)
+    .max(600000)
+    .refine((data) => {
+    try {
+        if (!data)
+            return true;
+        const parsedData = JSON.parse(data);
+        if (typeof parsedData !== 'object' || parsedData === null)
+            return false;
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}, {
+    message: 'must be a valid JSON object.',
+    path: [],
+})
+    .transform((data) => data
+    ? { user_defined_data: JSON.parse(data), expected: JSON.parse(data) }
+    : null);
+export const LogContextZod = z.object({
+    queueName: z.string(),
+    jobId: z.string(),
+    jobName: z.string(),
+    shouldAlert: z.boolean().optional(),
+});
+/**
+ * Maps all documented Cloudflare Turnstile error codes to their corresponding HTTP status and user-friendly message.
+ *
+ * @see {@link https://developers.cloudflare.com/turnstile/get-started/server-side-validation/ Cloudflare Turnstile Server-side Validation}
+ */
+export const errorMap = {
+    'missing-input-secret': {
+        status: HttpStatus.INTERNAL_SERVER_ERROR,
+        message: 'Captcha server configuration is missing the secret key. Please ensure the secret key is included.',
+    },
+    'invalid-input-secret': {
+        status: HttpStatus.INTERNAL_SERVER_ERROR,
+        message: 'Captcha server secret key is invalid or expired. Please check your secret key in the Cloudflare dashboard.',
+    },
+    'missing-input-response': {
+        status: HttpStatus.BAD_REQUEST,
+        message: 'Captcha response is missing. Please ensure the token is included and try again.',
+    },
+    'invalid-input-response': {
+        status: HttpStatus.BAD_REQUEST,
+        message: 'Captcha response is invalid, malformed, or expired. Please retry the challenge.',
+    },
+    'bad-request': {
+        status: HttpStatus.BAD_REQUEST,
+        message: 'The captcha verification request was malformed. Please check the request format and parameters.',
+    },
+    'timeout-or-duplicate': {
+        status: HttpStatus.CONFLICT,
+        message: 'Captcha token has already been validated or expired. Each token can only be used once. Please refresh and try again.',
+    },
+    'internal-error': {
+        status: HttpStatus.INTERNAL_SERVER_ERROR,
+        message: 'An internal error occurred during captcha verification. Please retry the request.',
+    },
+};
+export var BaseContactUsOptions;
+(function (BaseContactUsOptions) {
+    BaseContactUsOptions["ISSUER"] = "ISSUER";
+    BaseContactUsOptions["TECHNICAL_SUPPORT"] = "TECHNICAL_SUPPORT";
+    BaseContactUsOptions["SALES"] = "SALES";
+    BaseContactUsOptions["ACCOUNT_MANAGER"] = "ACCOUNT_MANAGER";
+})(BaseContactUsOptions || (BaseContactUsOptions = {}));
+export var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASC"] = "ASC";
+    SortOrder["DESC"] = "DESC";
+})(SortOrder || (SortOrder = {}));
+export var SortBy;
+(function (SortBy) {
+    SortBy["CREATED_AT"] = "created_at";
+    SortBy["UPDATED_AT"] = "updated_at";
+    SortBy["PLACEDAT"] = "placedAt";
+    SortBy["NAME"] = "name";
+    SortBy["TITLE"] = "title";
+    SortBy["LEGAL_NAME"] = "legal_name";
+})(SortBy || (SortBy = {}));
+export var PersonaStatus;
+(function (PersonaStatus) {
+    PersonaStatus["APPROVED"] = "approved";
+    PersonaStatus["ACTIVE"] = "active";
+    PersonaStatus["CREATED"] = "created";
+    PersonaStatus["COMPLETED"] = "completed";
+    PersonaStatus["DRAFT"] = "draft";
+    PersonaStatus["DECLINED"] = "declined";
+    PersonaStatus["EXPIRED"] = "expired";
+    PersonaStatus["FAILED"] = "failed";
+    PersonaStatus["NEEDS_REVIEW"] = "needs_review";
+    PersonaStatus["PUBLISHED"] = "published";
+    PersonaStatus["PENDING"] = "pending";
+    PersonaStatus["REDACTED"] = "redacted";
+})(PersonaStatus || (PersonaStatus = {}));
+export var AMLProvider;
+(function (AMLProvider) {
+    AMLProvider["COMPLY_ADVANTAGE"] = "ComplyAdvantage";
+})(AMLProvider || (AMLProvider = {}));
+export var ThemeFileType;
+(function (ThemeFileType) {
+    ThemeFileType["LIGHT"] = "light";
+    ThemeFileType["DARK"] = "dark";
+})(ThemeFileType || (ThemeFileType = {}));
+/**
+ * Common timezone identifiers using IANA timezone database format.
+ * These are the most commonly used timezones in business applications.
+ */
+export var TimeZone;
+(function (TimeZone) {
+    // UTC
+    TimeZone["UTC"] = "UTC";
+    // North America
+    TimeZone["PACIFIC"] = "America/Los_Angeles";
+    TimeZone["MOUNTAIN"] = "America/Denver";
+    TimeZone["CENTRAL"] = "America/Chicago";
+    TimeZone["EASTERN"] = "America/New_York";
+    // Europe
+    TimeZone["LONDON"] = "Europe/London";
+    TimeZone["PARIS"] = "Europe/Paris";
+    TimeZone["BERLIN"] = "Europe/Berlin";
+    TimeZone["ROME"] = "Europe/Rome";
+    TimeZone["MADRID"] = "Europe/Madrid";
+    TimeZone["AMSTERDAM"] = "Europe/Amsterdam";
+    TimeZone["ZURICH"] = "Europe/Zurich";
+    // Asia
+    TimeZone["TOKYO"] = "Asia/Tokyo";
+    TimeZone["SHANGHAI"] = "Asia/Shanghai";
+    TimeZone["HONG_KONG"] = "Asia/Hong_Kong";
+    TimeZone["SINGAPORE"] = "Asia/Singapore";
+    TimeZone["MUMBAI"] = "Asia/Kolkata";
+    TimeZone["DUBAI"] = "Asia/Dubai";
+    // Australia
+    TimeZone["SYDNEY"] = "Australia/Sydney";
+    TimeZone["MELBOURNE"] = "Australia/Melbourne";
+    // Other major business centers
+    TimeZone["SAO_PAULO"] = "America/Sao_Paulo";
+    TimeZone["TORONTO"] = "America/Toronto";
+    TimeZone["VANCOUVER"] = "America/Vancouver";
+})(TimeZone || (TimeZone = {}));
+export const SenderDataZod = z.object({
+    senderName: z.string().nullable(),
+    senderEmail: z.string().nullable(),
+});
+export var JobState;
+(function (JobState) {
+    JobState["COMPLETED"] = "completed";
+    JobState["FAILED"] = "failed";
+    JobState["WAITING"] = "waiting";
+    JobState["ACTIVE"] = "active";
+    JobState["DELAYED"] = "delayed";
+    JobState["PRIORITIZED"] = "prioritized";
+    JobState["WAITING_CHILDREN"] = "waiting-children";
+})(JobState || (JobState = {}));
+export const SUBJECT_TYPE_MAP = {
+    [BulkExportType.INVESTOR_ACCOUNTS]: 'Investor Accounts',
+    [BulkExportType.TRADES]: 'Trades',
+    [BulkExportType.COMPLIANCE_TRADES]: 'Compliance Trades',
+    [BulkExportType.SECONDARY_CUSTOMERS]: 'Secondary Customers',
+    [BulkExportType.SECONDARY_TRADES]: 'Secondary Trades',
+};
+export const StringToBooleanSchema = z.preprocess((val) => val === 'true' || val === '1'
+    ? true
+    : val === 'false' || val === '0'
+        ? false
+        : val, z.boolean());
+/**
+ * Reusable email schema that validates email format, transforms to lowercase,
+ * and includes OpenAPI metadata.
+ *
+ * @example
+ * EmailSchema.parse('John.Doe@EXAMPLE.COM'); // returns 'john.doe@example.com'
+ * EmailSchema.optional().parse(undefined); // returns undefined
+ */
+export const EmailSchema = z
+    .string()
+    .email()
+    .transform((val) => val.toLowerCase())
+    .openapi({
+    example: 'neil@dalmoregroup.com',
+});
+//# sourceMappingURL=common.types.js.map