@dalmore/api-contracts 0.0.0-dev.b728a8d → 0.0.0-dev.bcc2eb2

package/common/types/investor-account.types.js

@@ -0,0 +1,931 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types.js';
+import { AccountZod, AicStatus, AMLStatus, BaseStatus, dateSchema, InvestorAccountType, IPaginationMeta, KYBStatus, KYCDocumentType, KYCStatus, numberFromStringOrNumber, RetirementAccountType, SetupStatusType, TradeType, TradeStatus, EmploymentStatus, dateSchemaWithNormalization, UserType, PaginationOptionsZod, SourceOfIncome, SortBy, SortOrder, AMLProvider, EmailSchema, } from './common.types.js';
+import { accountIdSchema } from './account.types.js';
+import { SaStatus, tradeIdSchema, TradeZod } from './trade.types.js';
+import { legalEntityIdSchema, LegalEntityZod } from './legal-entity.types.js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { offeringIdSchema } from './offering.types.js';
+import { userIdSchema, UserZod } from './user.types.js';
+import { IIndividualZod, individualIdSchema } from './individuals.types.js';
+import { TypeID } from 'typeid-js';
+import { ErrorResponseZod, TransactionStatus } from './common.types.js';
+import { PhoneZodSchema } from './phone.type.js';
+import { RequiredAddressSchema } from './address.types.js';
+import { PaymentMethodType } from './payment-methods.types.js';
+import { CanadaProvinceCode, StateCode } from './states.types.js';
+import { refineAddressZip } from './zip.type.js';
+import { CountryCode } from './countries.types.js';
+import { ITrustedContactZod } from './trusted-contact.types.js';
+extendZodWithOpenApi(z);
+export const investorAccountIdSchema = z.string().refine((value) => {
+    try {
+        const tid = TypeID.fromString(value);
+        return tid.getType() === 'investor_account';
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: 'Invalid investor_account ID format. Must be a valid TypeID with "investor_account" prefix.',
+});
+export var AccreditationVerificationRequestStatus;
+(function (AccreditationVerificationRequestStatus) {
+    AccreditationVerificationRequestStatus["PENDING"] = "PENDING";
+    AccreditationVerificationRequestStatus["APPROVED"] = "APPROVED";
+    AccreditationVerificationRequestStatus["DECLINED"] = "DECLINED";
+})(AccreditationVerificationRequestStatus || (AccreditationVerificationRequestStatus = {}));
+export const IInvestorAccount = IBaseEntity.extend({
+    tid: z.string().nullable(),
+    investorAccountType: z.nativeEnum(InvestorAccountType),
+    user: z.lazy(() => UserZod.nullish()),
+    userId: z.string().optional().nullable(),
+    email: z.string().email().optional().nullable(),
+    name: z.string().optional().nullable(),
+    regAQualified: z.boolean(),
+    regCfQualified: z.boolean(),
+    regDQualified: z.boolean(),
+    accountId: z.string(),
+    account: z.lazy(() => AccountZod).optional(),
+    trades: z.array(z.lazy(() => TradeZod)).optional(),
+    individuals: z.array(z.lazy(() => IIndividualZod)).optional(), // circular dependency requires lazy
+    legalEntities: z.array(z.lazy(() => LegalEntityZod)).optional(),
+    setupStatus: z.nativeEnum(SetupStatusType),
+    systemReviewLog: z.string().nullable(),
+    totalAmount: z.number().optional(),
+    statusCheck: z.lazy(() => InvestorStatusCheckZod).optional(),
+    trustedContacts: z.array(z.lazy(() => ITrustedContactZod)).optional(),
+});
+export const IInvestorAccountSummary = z.object({
+    liquidNetWorth: z.number(),
+    householdNetWorth: z.number(),
+    currentAnnualIncome: z.number(),
+    currentHouseholdIncome: z.number(),
+    totalInvestments: z.number(),
+    totalPending: z.number(),
+    concentrationLiquidNetWorth: z.number(),
+    concentrationTotalNetWorth: z.number(),
+    postTradeConcentration: z.number().optional(),
+});
+export const InvestorUpdatePathParamsSchema = z.object({
+    id: z.lazy(() => investorAccountIdSchema),
+});
+export const PostInvestorAccountBodySchema = z.object({
+    investorAccountType: z.nativeEnum(InvestorAccountType),
+    name: z.string().optional(),
+});
+export const PostClientInvestorAccountBodySchema = z.object({
+    investorAccountType: z.nativeEnum(InvestorAccountType),
+    email: z.string().email().optional(),
+    name: z.string().min(1).max(100).optional(),
+    tid: z.string().optional(),
+    userId: z.lazy(() => {
+        return userIdSchema;
+    }),
+});
+export const UpdateInvestorAccountBodySchema = z.object({
+    name: z.string().optional(),
+    email: EmailSchema.optional(),
+});
+export const IPaginatedInvestorAccounts = z.object({
+    items: z.array(IInvestorAccount),
+    meta: IPaginationMeta,
+});
+const investorAccountsInclude = z.enum([
+    'account',
+    'trades',
+    'individuals',
+    'legalEntities',
+    'trustedContacts',
+]);
+export const InvestorAccountsFiltersZod = z.object({
+    investorAccountType: z.nativeEnum(InvestorAccountType).optional(),
+    kycStatus: z.nativeEnum(KYCStatus).optional(),
+    kybStatus: z.nativeEnum(KYBStatus).optional(),
+    amlStatus: z.nativeEnum(AMLStatus).optional(),
+    aicStatus: z.nativeEnum(AicStatus).optional(),
+    offeringId: z.lazy(() => offeringIdSchema).optional(),
+    regAQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    regCfQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    regDQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    email: z.string().optional(),
+    accountId: accountIdSchema.optional(),
+    userType: z.nativeEnum(UserType).optional(),
+    startDate: dateSchema.optional(),
+    endDate: dateSchema.optional(),
+    userId: z.string().optional(),
+});
+export const InvestorAccountsSortZod = z.object({
+    sort: z.enum([SortBy.NAME, SortBy.CREATED_AT, SortBy.UPDATED_AT]).optional(),
+    dir: z.nativeEnum(SortOrder).optional(),
+});
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
+ */
+export const InvestorAccountsIncludeQuery = z.object({
+    include: z
+        .string()
+        .optional()
+        .transform((str) => (str ? str.split(',') : []))
+        .refine((includes) => includes.every((include) => investorAccountsInclude.options.includes(include)), {
+        message: `Invalid include option provided. Valid options are: ${investorAccountsInclude.options.join(',')}`,
+    })
+        .openapi({
+        example: `${investorAccountsInclude.options.join(',')}`,
+    }),
+});
+export const IssuerInvestorAccountsFiltersZod = z.object({
+    userType: z.nativeEnum(UserType).optional(),
+    investorAccountType: z.nativeEnum(InvestorAccountType).optional(),
+    kycStatus: z.nativeEnum(KYCStatus).optional(),
+    kybStatus: z.nativeEnum(KYBStatus).optional(),
+    amlStatus: z.nativeEnum(AMLStatus).optional(),
+    aicStatus: z.nativeEnum(AicStatus).optional(),
+    offeringId: z.lazy(() => offeringIdSchema).optional(),
+    regAQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    regCfQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    regDQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    email: z.string().optional(),
+    startDate: dateSchema.optional(),
+    endDate: dateSchema.optional(),
+    userId: z.string().optional(),
+});
+export const InvestorAccountsFilters = z.object({
+    investorAccountType: z.nativeEnum(InvestorAccountType).optional(),
+    regAQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    regCfQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    regDQualified: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+    withPortfolio: z.preprocess((val) => val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+            ? false
+            : val, z.boolean().optional()),
+});
+export const InvestorAccountExportFilters = IssuerInvestorAccountsFiltersZod.extend({
+    startDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+    endDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export const ComplianceInvestorAccountExportFilters = InvestorAccountsFiltersZod.extend({
+    startDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+    endDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+}).merge(InvestorAccountsSortZod);
+export const AmlReviewDetailsZod = z.object({
+    firstName: z.string(),
+    lastName: z.string().nullable(),
+    tid: z.string().nullable(),
+    provider: z.nativeEnum(AMLProvider).nullable(),
+    dashboardLink: z.string().nullable(),
+    reportLink: z.string().nullable(),
+    reviewedBy: z.lazy(() => UserZod.nullable()),
+    reviewedStatus: z.nativeEnum(AMLStatus),
+    reviewedAt: z.date().nullable(),
+});
+export const KycReviewDetailsZod = z.object({
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+    documentType: z.string(),
+    documentIssuer: z.string().nullable(),
+    documentNumber: z.string().nullable(),
+    issuedDate: z.string().nullable(),
+    expiredDate: z.string().nullable(),
+    reviewedBy: z.lazy(() => UserZod.nullable()),
+    reviewedStatus: z.nativeEnum(KYCStatus),
+});
+export const AicReviewDetailsZod = z.object({
+    accreditationType: z.string(),
+    expirationDate: z.date().nullable(),
+});
+export var InvestorAccountDetailsType;
+(function (InvestorAccountDetailsType) {
+    InvestorAccountDetailsType["AML"] = "AML";
+    InvestorAccountDetailsType["KYC"] = "KYC";
+    InvestorAccountDetailsType["AIC"] = "AIC";
+})(InvestorAccountDetailsType || (InvestorAccountDetailsType = {}));
+export const GetInvestorAccountDetailsQuery = z.object({
+    type: z.nativeEnum(InvestorAccountDetailsType),
+    individualId: z.lazy(() => individualIdSchema),
+});
+export const RegisteredInvestorUserZod = z.object({
+    id: z.string(),
+    email: z.string().email(),
+    name: z.string(),
+    userType: z.nativeEnum(UserType).nullable(),
+    numberOfTrades: z.number().default(0),
+    invested: z.number().default(0),
+    createdAt: z.date(),
+});
+export const IPaginatedRegisteredInvestorUserZod = z.object({
+    items: z.array(RegisteredInvestorUserZod),
+    meta: IPaginationMeta,
+});
+/**
+ * Schema for raw query result from queryRegisteredInvestorUsers
+ * Matches the structure returned by getRawMany() with JSON aggregations.
+ * PostgreSQL/TypeORM automatically parses JSON fields, so they come as arrays.
+ */
+const IndividualAggregationZod = z.object({
+    id: z.lazy(() => individualIdSchema),
+    phone: z.lazy(() => PhoneZodSchema),
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+});
+const LegalEntityAggregationZod = z.object({
+    id: z.lazy(() => legalEntityIdSchema),
+    phone: z.lazy(() => PhoneZodSchema),
+    name: z.string().nullable(),
+});
+export const RegisteredInvestorUserRawZod = z.object({
+    id: z.lazy(() => userIdSchema),
+    name: z.string(),
+    email: z.string().email(),
+    investorAccountType: z.nativeEnum(InvestorAccountType).nullable(),
+    numberOfTrades: z.coerce.number().default(0),
+    invested: z.coerce.number().default(0),
+    createdAt: z.coerce.date(),
+    type: z.nativeEnum(UserType).nullable(),
+    investorAccountId: z.string().nullable(),
+    individuals: z.array(IndividualAggregationZod),
+    legalEntities: z.array(LegalEntityAggregationZod),
+});
+export const RegisteredInvestorUserFiltersZod = z.object({
+    search: z.string().optional().openapi({ example: 'John Doe' }),
+    startDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+    endDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+    userType: z
+        .nativeEnum(UserType)
+        .optional()
+        .openapi({ example: UserType.INVESTOR }),
+});
+export const ExportInvestorAccountsResponse = z.object({
+    message: z.string(),
+});
+export const IndividualsValidationResponseZod = z.object({
+    errors: ErrorResponseZod,
+    regDFieldStatus: z.boolean(),
+});
+export const BaseIndividualValidationSchemaZod = z
+    .object({
+    lastName: z.string({ message: 'Last Name is required' }),
+    firstName: z.string({ message: 'First Name is required' }),
+    dob: z.coerce.date({ required_error: 'Date of Birth is required' }),
+    phone: PhoneZodSchema,
+    email: z.string().email('Email is required'),
+    ownership: numberFromStringOrNumber('Ownership').pipe(z.number().min(0, { message: 'Ownership is required' })),
+    liquidNetWorth: numberFromStringOrNumber('Liquid Net Worth').pipe(z.number().min(0, { message: 'Liquid Net Worth is required' })),
+    currentAnnualIncome: numberFromStringOrNumber('Current Annual Income').pipe(z.number().min(0, { message: 'Current Annual Income is required' })),
+    employerName: z.string().nullable().optional(),
+    sourceOfIncome: z.nativeEnum(SourceOfIncome, {
+        message: 'Source of Income is required',
+    }),
+    kycDocumentType: z.nativeEnum(KYCDocumentType, {
+        required_error: 'KYC Document Type is required',
+    }),
+    kycDocumentIssuer: z.string({ message: 'KYC Document Issuer is required' }),
+    kycExpirationDate: z.coerce.date({
+        required_error: 'KYC Expiration Date is required',
+    }),
+    kycIssuerDate: z.coerce.date({
+        required_error: 'KYC Issuer Date is required',
+    }),
+    kycDocumentNumber: z.string({ message: 'KYC Document Number is required' }),
+    kycStatus: z.nativeEnum(KYCStatus, {
+        required_error: 'KYC Status is required',
+    }),
+    kycProvider: z.string({ message: 'KYC Provider is required' }),
+    kycTid: z.string({ message: 'KYC TID is required' }),
+})
+    .and(RequiredAddressSchema)
+    .superRefine((data, ctx) => {
+    if (data.sourceOfIncome === SourceOfIncome.EMPLOYED) {
+        if (!data.employerName || (typeof data.employerName === 'string' && data.employerName.trim() === '')) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Employer Name is required when Source of Income is Employed',
+                path: ['employerName'],
+            });
+        }
+    }
+});
+// Schema for US citizens or green card holders
+export const UsCitizenSchemaZod = z.object({
+    ssn: z
+        .string()
+        .min(1, 'SSN is required for US citizens or green card holders')
+        .regex(/^(\d{3}-\d{2}-\d{4}|\d{9})$/, 'SSN must be 9 digits'),
+});
+// Schema for custodian managed retirement accounts
+export const CustodianManagedRetirementSchemaZod = z.object({
+    retirementAccountType: z.nativeEnum(RetirementAccountType, {
+        required_error: 'Retirement Account Type is required',
+    }),
+    custodianName: z.string().min(1, 'Custodian Name is required'),
+    custodianAccountNumber: z
+        .string()
+        .min(1, 'Custodian Account Number is required'),
+    custodianRepresentativeName: z
+        .string()
+        .min(1, 'Custodian Representative Name is required'),
+    custodianEmail: z.string().email('Custodian Email is required'),
+});
+export const SystemReviewLogZod = z.object({
+    regA: ErrorResponseZod,
+    regCf: ErrorResponseZod,
+    regD: ErrorResponseZod,
+});
+export var SeedType;
+(function (SeedType) {
+    SeedType["SYSTEM"] = "SYSTEM";
+    SeedType["EXTERNAL"] = "EXTERNAL";
+})(SeedType || (SeedType = {}));
+export const SeedInvestorAccountsForDemoUsersZod = z.object({
+    accountId: z.lazy(() => accountIdSchema),
+    seedType: z.nativeEnum(SeedType),
+});
+export const SeedTradeCsvRowZod = z.object({
+    id: z.lazy(() => tradeIdSchema),
+    tradeType: z.nativeEnum(TradeType).openapi({ example: TradeType.PURCHASE }),
+    issuer: z.string(),
+    offering: z.string(),
+    asset: z.string(),
+    numberOfShares: numberFromStringOrNumber('Number of Shares').pipe(z.number().int().min(1, { message: 'Number of Shares is required' })),
+    pricePerShare: numberFromStringOrNumber('Price Per Share').pipe(z.number().min(0, { message: 'Price Per Share is required' })),
+    totalAmount: numberFromStringOrNumber('Total Amount').pipe(z.number().min(0, { message: 'Total Amount is required' })),
+    tradeStatus: z.nativeEnum(TradeStatus).openapi({ example: TradeStatus.CART }),
+    placedAt: z.coerce.date(),
+    ip: z.string().ip(),
+    subAgreementStatus: z.nativeEnum(SaStatus),
+    subAgreementFile: z.string().url(),
+    tradeLog: z.string().nullable().optional(),
+});
+export const SeedTransactionCsvRowZod = z.object({
+    txnId: z.string().nullable().optional(),
+    txnResponse: z.string().nullable().optional(),
+    txnPaymentMethod: z.nativeEnum(PaymentMethodType),
+    txnCurrencyCode: z.string().nullable().optional(),
+    txnChargedAmount: numberFromStringOrNumber('Transaction Charged Amount').pipe(z.number().min(0, { message: 'Transaction Charged Amount is required' })),
+    txnDate: z
+        .string()
+        .transform((val) => (val === '' ? null : val))
+        .pipe(z.coerce.date())
+        .nullable()
+        .optional(),
+    txnSettledDate: z
+        .string()
+        .transform((val) => (val === '' ? null : val))
+        .pipe(z.coerce.date())
+        .nullable()
+        .optional(),
+    txnStatus: z.nativeEnum(TransactionStatus),
+    txnLog: z.string().nullable().optional(),
+});
+export const AdministrativeFieldsCsvRowZod = z.object({
+    closedAt: z.coerce.date().nullable().optional(),
+    cancellationPeriod: z.string().nullable().optional(),
+    cancelledAt: z.coerce.date().nullable().optional(),
+    cancelledReason: z.string().nullable().optional(),
+    rejectionReason: z.string().nullable().optional(),
+    registeredRep: z.string().nullable().optional(),
+});
+export const InvestorAccountCsvRowZod = z.object({
+    investorAccountId: z.lazy(() => investorAccountIdSchema),
+    email: z.string().email(),
+    name: z.string(),
+    investorAccountType: z.nativeEnum(InvestorAccountType),
+});
+export const PrimaryIndividualCsvRowZod = z
+    .object({
+    primary_id: z.string(),
+    primary_kycFirstName: z.string(),
+    primary_kycLastName: z.string(),
+    primary_kycDocumentType: z.nativeEnum(KYCDocumentType),
+    primary_kycProviderId: z.string(),
+    primary_kycDocumentNumber: z.string(),
+    primary_kycDocumentIssuer: z.string(),
+    primary_kycIssuerDate: dateSchemaWithNormalization,
+    primary_kycExpirationDate: dateSchemaWithNormalization,
+    primary_kycCheckedAt: z.coerce.date(),
+    primary_kycStatus: z.nativeEnum(KYCStatus),
+    primary_kycLog: z.string(),
+    primary_kycProvider: z.string(),
+    primary_firstName: z.string(),
+    primary_lastName: z.string(),
+    primary_dob: dateSchemaWithNormalization,
+    primary_ssn: z.string().regex(/^\d{9}$/, 'SSN must be 9 digits'),
+    primary_address: z.string().min(2, 'Address must be at least 2 characters'),
+    primary_address2: z
+        .string()
+        .max(100, 'Address2 cannot exceed 100 characters')
+        .nullable()
+        .optional(),
+    primary_city: z
+        .string()
+        .min(2, 'City must be at least 2 characters')
+        .max(50, 'City cannot exceed 50 characters'),
+    primary_state: z.string().min(2, 'State must be at least 2 characters'),
+    primary_zip: z.string().min(5, 'Zip must be at least 5 characters'),
+    primary_country: z.string().min(2, 'Country must be at least 2 characters'),
+    primary_email: z.string().email(),
+    primary_phone: PhoneZodSchema,
+    primary_citizenship: z
+        .string()
+        .min(2, 'Citizenship must be at least 2 characters'),
+    primary_currentAnnualIncome: numberFromStringOrNumber('Primary Current Annual Income').pipe(z
+        .number()
+        .min(0, { message: 'Primary Current Annual Income is required' })),
+    primary_currentHouseholdIncome: numberFromStringOrNumber('Primary Current Household Income').pipe(z
+        .number()
+        .min(0, { message: 'Primary Current Household Income is required' })),
+    primary_householdNetWorth: numberFromStringOrNumber('Primary Household Net Worth').pipe(z.number().min(0, { message: 'Primary Household Net Worth is required' })),
+    primary_liquidNetWorth: numberFromStringOrNumber('Primary Liquid Net Worth').pipe(z.number().min(0, { message: 'Primary Liquid Net Worth is required' })),
+    primary_investedInCrowdfunding: numberFromStringOrNumber('Primary Invested In Crowdfunding').pipe(z
+        .number()
+        .min(0, { message: 'Primary Invested In Crowdfunding is required' })),
+    primary_occupation: z.string().nullable().optional(),
+    primary_employmentStatus: z.nativeEnum(EmploymentStatus),
+    primary_employerName: z.string(),
+    primary_sourceOfIncome: z.nativeEnum(SourceOfIncome),
+    primary_isUsCitizenOrGreenCardHolder: z.coerce.boolean(),
+    primary_accredited: z.coerce.boolean(),
+})
+    .refine(({ primary_state, primary_country }) => {
+    if (primary_country === CountryCode['US']) {
+        return z.nativeEnum(StateCode).safeParse(primary_state).success;
+    }
+    if (primary_country === CountryCode['CA']) {
+        return z.nativeEnum(CanadaProvinceCode).safeParse(primary_state)
+            .success;
+    }
+    return z.string().min(2).max(35).safeParse(primary_state).success;
+}, {
+    message: `state value is not valid. It should be 2 uppercase letters representing the valid state for the country.`,
+})
+    .refine(({ primary_zip, primary_country }) => refineAddressZip(primary_country, primary_zip), {
+    message: 'zip value is not valid, it shall follow the US(12345 or 12345-6789), CANADA(A1A 1A1) format! it shall be a string for other states',
+});
+export const JointIndividualCsvRowZod = z
+    .object({
+    joint_id: z.string(),
+    joint_kycFirstName: z.string(),
+    joint_kycLastName: z.string(),
+    joint_kycDocumentType: z.nativeEnum(KYCDocumentType),
+    joint_kycDocumentIssuer: z.string(),
+    joint_kycDocumentNumber: z.string(),
+    joint_kycIssuerDate: dateSchemaWithNormalization,
+    joint_kycExpirationDate: dateSchemaWithNormalization,
+    joint_kycCheckedAt: z.string(),
+    joint_kycStatus: z.nativeEnum(KYCStatus),
+    joint_kycLog: z.string(),
+    joint_kycProviderId: z.string(),
+    joint_kycProvider: z.string(),
+    joint_firstName: z.string(),
+    joint_lastName: z.string(),
+    joint_dob: dateSchemaWithNormalization,
+    joint_ssn: z.string().regex(/^\d{9}$/, 'SSN must be 9 digits'),
+    joint_address: z.string().min(2, 'Address must be at least 2 characters'),
+    joint_address2: z
+        .string()
+        .max(100, 'Address2 cannot exceed 100 characters')
+        .nullable()
+        .optional(),
+    joint_city: z
+        .string()
+        .min(2, 'City must be at least 2 characters')
+        .max(50, 'City cannot exceed 50 characters'),
+    joint_state: z.string().min(2, 'State must be at least 2 characters'),
+    joint_zip: z.string().min(5, 'Zip must be at least 5 characters'),
+    joint_country: z.string().min(2, 'Country must be at least 2 characters'),
+    joint_email: z.string().email(),
+    joint_phone: PhoneZodSchema,
+    joint_citizenship: z
+        .string()
+        .min(2, 'Citizenship must be at least 2 characters'),
+    joint_currentAnnualIncome: numberFromStringOrNumber('Joint Current Annual Income').pipe(z.number().min(0, { message: 'Joint Current Annual Income is required' })),
+    joint_currentHouseholdIncome: numberFromStringOrNumber('Joint Current Household Income').pipe(z
+        .number()
+        .min(0, { message: 'Joint Current Household Income is required' })),
+    joint_householdNetWorth: numberFromStringOrNumber('Joint Household Net Worth').pipe(z.number().min(0, { message: 'Joint Household Net Worth is required' })),
+    joint_liquidNetWorth: numberFromStringOrNumber('Joint Liquid Net Worth').pipe(z.number().min(0, { message: 'Joint Liquid Net Worth is required' })),
+    joint_investedInCrowdfunding: numberFromStringOrNumber('Joint Invested In Crowdfunding').pipe(z
+        .number()
+        .min(0, { message: 'Joint Invested In Crowdfunding is required' })),
+    joint_occupation: z.string().nullable().optional(),
+    joint_employmentStatus: z.nativeEnum(EmploymentStatus),
+    joint_employerName: z.string(),
+    joint_sourceOfIncome: z.nativeEnum(SourceOfIncome),
+    joint_isUsCitizenOrGreenCardHolder: z.coerce.boolean(),
+    joint_accredited: z.coerce.boolean(),
+})
+    .refine(({ joint_state, joint_country }) => {
+    if (joint_country === CountryCode['US']) {
+        return z.nativeEnum(StateCode).safeParse(joint_state).success;
+    }
+    if (joint_country === CountryCode['CA']) {
+        return z.nativeEnum(CanadaProvinceCode).safeParse(joint_state).success;
+    }
+    return z.string().min(2).max(35).safeParse(joint_state).success;
+}, {
+    message: `state value is not valid. It should be 2 uppercase letters representing the valid state for the country.`,
+})
+    .refine(({ joint_zip, joint_country }) => refineAddressZip(joint_country, joint_zip), {
+    message: 'zip value is not valid, it shall follow the US(12345 or 12345-6789), CANADA(A1A 1A1) format! it shall be a string for other states',
+});
+export const LegalEntityCsvRowZod = z
+    .object({
+    entity_id: z.string(),
+    entity_name: z.string(),
+    entity_ein: z.string(),
+    entity_entityType: z.string(),
+    entity_address: z.string().min(2, 'Address must be at least 2 characters'),
+    entity_address2: z
+        .string()
+        .max(100, 'Address2 cannot exceed 100 characters')
+        .nullable()
+        .optional(),
+    entity_city: z
+        .string()
+        .min(2, 'City must be at least 2 characters')
+        .max(50, 'City cannot exceed 50 characters'),
+    entity_state: z.string().min(2, 'State must be at least 2 characters'),
+    entity_zip: z.string().min(5, 'Zip must be at least 5 characters'),
+    entity_country: z.string().min(2, 'Country must be at least 2 characters'),
+    entity_dateOfIncorporation: dateSchemaWithNormalization,
+    entity_stateOfIncorporation: z
+        .string()
+        .min(2, 'State must be at least 2 characters'),
+    entity_phone: PhoneZodSchema,
+})
+    .refine(({ entity_state, entity_country }) => {
+    if (entity_country === CountryCode['US']) {
+        return z.nativeEnum(StateCode).safeParse(entity_state).success;
+    }
+    if (entity_country === CountryCode['CA']) {
+        return z.nativeEnum(CanadaProvinceCode).safeParse(entity_state).success;
+    }
+    return z.string().min(2).max(35).safeParse(entity_state).success;
+}, {
+    message: `state value is not valid. It should be 2 uppercase letters representing the valid state for the country.`,
+})
+    .refine(({ entity_zip, entity_country }) => refineAddressZip(entity_country, entity_zip), {
+    message: 'zip value is not valid, it shall follow the US(12345 or 12345-6789), CANADA(A1A 1A1) format! it shall be a string for other states',
+});
+export const RetirementAccountTypeCsvRowZod = z.object({
+    retirement_accountType: z.nativeEnum(RetirementAccountType),
+    retirement_custodianName: z.string(),
+    retirement_custodianAccountNumber: z.string(),
+    retirement_custodianRepresentativeName: z.string(),
+    retirement_custodianEmail: z.string().email(),
+});
+export const IParsedSeedDataZod = z.object({
+    ...SeedTradeCsvRowZod.shape,
+    ...SeedTransactionCsvRowZod.shape,
+    ...AdministrativeFieldsCsvRowZod.shape,
+    ...InvestorAccountCsvRowZod.shape,
+    primary_id: z.string(),
+    primary_kycFirstName: z.string(),
+    primary_kycLastName: z.string(),
+    primary_kycDocumentType: z.nativeEnum(KYCDocumentType),
+    primary_kycProviderId: z.string(),
+    primary_kycDocumentNumber: z.string(),
+    primary_kycDocumentIssuer: z.string(),
+    primary_kycIssuerDate: z.string(),
+    primary_kycExpirationDate: z.string(),
+    primary_kycCheckedAt: z.coerce.date(),
+    primary_kycStatus: z.nativeEnum(KYCStatus),
+    primary_kycLog: z.string(),
+    primary_kycProvider: z.string(),
+    primary_firstName: z.string(),
+    primary_lastName: z.string(),
+    primary_dob: z.string(),
+    primary_ssn: z.string().regex(/^\d{9}$/, 'SSN must be 9 digits'),
+    primary_address: z.string().min(2, 'Address must be at least 2 characters'),
+    primary_address2: z
+        .string()
+        .max(100, 'Address2 cannot exceed 100 characters')
+        .nullable()
+        .optional(),
+    primary_city: z
+        .string()
+        .min(2, 'City must be at least 2 characters')
+        .max(50, 'City cannot exceed 50 characters'),
+    primary_state: z.string().min(2, 'State must be at least 2 characters'),
+    primary_zip: z.string().min(5, 'Zip must be at least 5 characters'),
+    primary_country: z.string().min(2, 'Country must be at least 2 characters'),
+    primary_email: z.string().email(),
+    primary_phone: PhoneZodSchema,
+    primary_citizenship: z
+        .string()
+        .min(2, 'Citizenship must be at least 2 characters'),
+    primary_currentAnnualIncome: numberFromStringOrNumber('Primary Current Annual Income').pipe(z.number().min(0, { message: 'Primary Current Annual Income is required' })),
+    primary_currentHouseholdIncome: numberFromStringOrNumber('Primary Current Household Income').pipe(z
+        .number()
+        .min(0, { message: 'Primary Current Household Income is required' })),
+    primary_householdNetWorth: numberFromStringOrNumber('Primary Household Net Worth').pipe(z.number().min(0, { message: 'Primary Household Net Worth is required' })),
+    primary_liquidNetWorth: numberFromStringOrNumber('Primary Liquid Net Worth').pipe(z.number().min(0, { message: 'Primary Liquid Net Worth is required' })),
+    primary_investedInCrowdfunding: numberFromStringOrNumber('Primary Invested In Crowdfunding').pipe(z
+        .number()
+        .min(0, { message: 'Primary Invested In Crowdfunding is required' })),
+    primary_occupation: z.string().nullable().optional(),
+    primary_employmentStatus: z.nativeEnum(EmploymentStatus),
+    primary_employerName: z.string(),
+    primary_sourceOfIncome: z.nativeEnum(SourceOfIncome),
+    primary_isUsCitizenOrGreenCardHolder: z.coerce.boolean(),
+    primary_accredited: z.coerce.boolean(),
+    joint_id: z.string().nullable().optional(),
+    joint_kycFirstName: z.string().nullable().optional(),
+    joint_kycLastName: z.string().nullable().optional(),
+    joint_kycDocumentType: z.nativeEnum(KYCDocumentType).nullable().optional(),
+    joint_kycDocumentIssuer: z.string().nullable().optional(),
+    joint_kycDocumentNumber: z.string().nullable().optional(),
+    joint_kycIssuerDate: dateSchemaWithNormalization.nullable().optional(),
+    joint_kycExpirationDate: dateSchemaWithNormalization.nullable().optional(),
+    joint_kycCheckedAt: z.string().nullable().optional(),
+    joint_kycStatus: z.nativeEnum(KYCStatus).nullable().optional(),
+    joint_kycLog: z.string().nullable().optional(),
+    joint_kycProviderId: z.string().nullable().optional(),
+    joint_kycProvider: z.string().nullable().optional(),
+    joint_firstName: z.string().nullable().optional(),
+    joint_lastName: z.string().nullable().optional(),
+    joint_dob: dateSchemaWithNormalization.nullable().optional(),
+    joint_ssn: z
+        .string()
+        .regex(/^\d{9}$/, 'SSN must be 9 digits')
+        .nullable()
+        .optional(),
+    joint_address: z
+        .string()
+        .min(2, 'Address must be at least 2 characters')
+        .nullable()
+        .optional(),
+    joint_address2: z
+        .string()
+        .max(100, 'Address2 cannot exceed 100 characters')
+        .nullable()
+        .optional(),
+    joint_city: z
+        .string()
+        .min(2, 'City must be at least 2 characters')
+        .max(50, 'City cannot exceed 50 characters')
+        .nullable()
+        .optional(),
+    joint_state: z
+        .string()
+        .min(2, 'State must be at least 2 characters')
+        .nullable()
+        .optional(),
+    joint_zip: z
+        .string()
+        .min(5, 'Zip must be at least 5 characters')
+        .nullable()
+        .optional(),
+    joint_country: z
+        .string()
+        .min(2, 'Country must be at least 2 characters')
+        .nullable()
+        .optional(),
+    joint_email: z.string().email().nullable().optional(),
+    joint_phone: PhoneZodSchema.nullable().optional(),
+    joint_citizenship: z
+        .string()
+        .min(2, 'Citizenship must be at least 2 characters')
+        .nullable()
+        .optional(),
+    joint_currentAnnualIncome: numberFromStringOrNumber('Joint Current Annual Income')
+        .pipe(z.number().min(0, { message: 'Joint Current Annual Income is required' }))
+        .nullable()
+        .optional(),
+    joint_currentHouseholdIncome: numberFromStringOrNumber('Joint Current Household Income')
+        .pipe(z
+        .number()
+        .min(0, { message: 'Joint Current Household Income is required' }))
+        .nullable()
+        .optional(),
+    joint_householdNetWorth: numberFromStringOrNumber('Joint Household Net Worth')
+        .pipe(z.number().min(0, { message: 'Joint Household Net Worth is required' }))
+        .nullable()
+        .optional(),
+    joint_liquidNetWorth: numberFromStringOrNumber('Joint Liquid Net Worth')
+        .pipe(z.number().min(0, { message: 'Joint Liquid Net Worth is required' }))
+        .nullable()
+        .optional(),
+    joint_investedInCrowdfunding: numberFromStringOrNumber('Joint Invested In Crowdfunding')
+        .pipe(z
+        .number()
+        .min(0, { message: 'Joint Invested In Crowdfunding is required' }))
+        .nullable()
+        .optional(),
+    joint_occupation: z.string().nullable().optional(),
+    joint_employmentStatus: z.nativeEnum(EmploymentStatus).nullable().optional(),
+    joint_employerName: z.string().nullable().optional(),
+    joint_sourceOfIncome: z.nativeEnum(SourceOfIncome).nullable().optional(),
+    joint_isUsCitizenOrGreenCardHolder: z.coerce.boolean().nullable().optional(),
+    joint_accredited: z.coerce.boolean().nullable().optional(),
+    entity_id: z.string().nullable().optional(),
+    entity_name: z.string().nullable().optional(),
+    entity_ein: z.string().nullable().optional(),
+    entity_entityType: z.string().nullable().optional(),
+    entity_address: z
+        .string()
+        .min(2, 'Address must be at least 2 characters')
+        .nullable()
+        .optional(),
+    entity_address2: z
+        .string()
+        .max(100, 'Address2 cannot exceed 100 characters')
+        .nullable()
+        .optional(),
+    entity_city: z
+        .string()
+        .min(2, 'City must be at least 2 characters')
+        .max(50, 'City cannot exceed 50 characters')
+        .nullable()
+        .optional(),
+    entity_state: z
+        .string()
+        .min(2, 'State must be at least 2 characters')
+        .nullable()
+        .optional(),
+    entity_zip: z
+        .string()
+        .min(5, 'Zip must be at least 5 characters')
+        .nullable()
+        .optional(),
+    entity_country: z
+        .string()
+        .min(2, 'Country must be at least 2 characters')
+        .nullable()
+        .optional(),
+    entity_dateOfIncorporation: dateSchemaWithNormalization.nullable().optional(),
+    entity_stateOfIncorporation: z
+        .string()
+        .min(2, 'State must be at least 2 characters')
+        .nullable()
+        .optional(),
+    entity_phone: PhoneZodSchema.nullable().optional(),
+    retirement_accountType: z
+        .nativeEnum(RetirementAccountType)
+        .nullable()
+        .optional(),
+    retirement_custodianName: z.string().nullable().optional(),
+    retirement_custodianAccountNumber: z.string().nullable().optional(),
+    retirement_custodianRepresentativeName: z.string().nullable().optional(),
+    retirement_custodianEmail: z.string().email().nullable().optional(),
+});
+export const GetInvestorAccountsFilters = PaginationOptionsZod.merge(InvestorAccountsIncludeQuery).merge(InvestorAccountsFilters);
+export const InvestorStatusCheckZod = z.object({
+    entity: z
+        .object({
+        information: z.boolean().default(true),
+        address: z.boolean().default(true),
+    })
+        .optional(),
+    primary: z
+        .object({
+        account: z.boolean().default(true),
+        personal: z.boolean().default(true),
+        residential: z.boolean().default(true),
+        identity: z.boolean().default(true),
+        financial: z.boolean().default(true),
+        investorQuestionnaire: z.boolean().default(true),
+        accreditation: z.boolean().default(true),
+        trustedContact: z.boolean().default(true),
+        retirement: z.boolean().optional(),
+    })
+        .optional(),
+    secondary: z
+        .object({
+        personal: z.boolean().default(true),
+        residential: z.boolean().default(true),
+        identity: z.boolean().default(true),
+        financial: z.boolean().default(true),
+    })
+        .optional(),
+});
+export const INVESTOR_ACCOUNT_FIELDS_MAP = {
+    entity: {
+        information: [
+            'companyType',
+            'name',
+            'ein',
+            'dateOfIncorporation',
+            'stateOfIncorporation',
+        ],
+        address: ['address', 'address2', 'city', 'zip', 'state', 'country'],
+    },
+    primary: {
+        account: ['investorAccountType', 'name', 'email'],
+        personal: [
+            'firstName',
+            'lastName',
+            'email',
+            'phoneNumber',
+            'dob',
+            'citizenship',
+            'ssn',
+        ],
+        residential: [
+            'address',
+            'address2',
+            'city',
+            'postalCode',
+            'state',
+            'country',
+        ],
+        identity: [
+            'kycDocumentType',
+            'kycDocumentIssuer',
+            'kycDocumentNumber',
+            'kycIssuerDate',
+            'kycExpirationDate',
+            'kycStatus',
+            'kycProvider',
+            'kycTid',
+        ],
+        financial: [
+            'liquidNetWorth',
+            'currentAnnualIncome',
+            'sourceOfIncome',
+            'employerName',
+        ],
+        investorQuestionnaire: ['aicQuestionnaire'],
+        accreditation: ['accreditationFile'],
+        retirement: [
+            'retirementAccountType',
+            'retirementCustodianName',
+            'retirementCustodianAccountNumber',
+            'retirementCustodianRepresentativeName',
+            'retirementCustodianEmail',
+        ],
+    },
+    secondary: {
+        personal: [
+            'firstName',
+            'lastName',
+            'email',
+            'phoneNumber',
+            'dob',
+            'citizenship',
+            'ssn',
+        ],
+        residential: ['address', 'address2', 'city', 'zip', 'state', 'country'],
+        identity: [
+            'kycDocumentType',
+            'kycDocumentIssuer',
+            'kycDocumentNumber',
+            'kycIssuerDate',
+            'kycExpirationDate',
+            'kycStatus',
+            'kycProvider',
+            'kycTid',
+        ],
+        financial: [
+            'liquidNetWorth',
+            'currentAnnualIncome',
+            'sourceOfIncome',
+            'employerName',
+        ],
+    },
+};
+export const ExportRegisteredInvestorUsersFiltersZod = z.object({
+    search: z.string().optional(),
+    startDate: dateSchema.optional(),
+    endDate: dateSchema.optional(),
+    userType: z.nativeEnum(UserType).optional(),
+});
+//# sourceMappingURL=investor-account.types.js.map