@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/investor-account.types.ts

@@ -0,0 +1,1239 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import {
+  AccountZod,
+  AicStatus,
+  AMLStatus,
+  BaseStatus,
+  dateSchema,
+  InvestorAccountType,
+  IPaginationMeta,
+  KYBStatus,
+  KYCDocumentType,
+  KYCStatus,
+  numberFromStringOrNumber,
+  RetirementAccountType,
+  SetupStatusType,
+  TradeType,
+  TradeStatus,
+  EmploymentStatus,
+  dateSchemaWithNormalization,
+  UserType,
+  PaginationOptionsZod,
+  SourceOfIncome,
+  SortBy,
+  SortOrder,
+  AMLProvider,
+} from './common.types';
+import { accountIdSchema } from './account.types';
+import { SaStatus, tradeIdSchema, TradeZod } from './trade.types';
+import { legalEntityIdSchema, LegalEntityZod } from './legal-entity.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { offeringIdSchema } from './offering.types';
+import { userIdSchema, UserZod } from './user.types';
+import { IIndividualZod, individualIdSchema } from './individuals.types';
+import { TypeID } from 'typeid-js';
+import { ErrorResponseZod } from './common.types';
+import { PhoneZodSchema } from './phone.type';
+import { RequiredAddressSchema } from './address.types';
+import { PaymentMethodType } from './payment-methods.types';
+import { TransactionStatus } from './transaction.types';
+import { CanadaProvinceCode, StateCode } from './states.types';
+import { refineAddressZip } from './zip.type';
+import { CountryCode } from './countries.types';
+
+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 enum AccreditationVerificationRequestStatus {
+  PENDING = BaseStatus.PENDING,
+  APPROVED = BaseStatus.APPROVED,
+  DECLINED = BaseStatus.DECLINED,
+}
+
+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(),
+});
+
+export type IInvestorAccount = z.infer<typeof IInvestorAccount>;
+
+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 type IInvestorAccountSummary = z.infer<typeof IInvestorAccountSummary>;
+
+export const InvestorUpdatePathParamsSchema = z.object({
+  id: investorAccountIdSchema,
+});
+
+export const PostInvestorAccountBodySchema = z.object({
+  investorAccountType: z.nativeEnum(InvestorAccountType),
+  name: z.string().optional(),
+});
+
+export type PostInvestorAccountBody = z.infer<
+  typeof PostInvestorAccountBodySchema
+>;
+
+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 type PostClientInvestorAccountBody = z.infer<
+  typeof PostClientInvestorAccountBodySchema
+>;
+
+export const UpdateInvestorAccountBodySchema = z.object({
+  name: z.string().optional(),
+  email: z.string().email().optional(),
+});
+export type UpdateInvestorAccountBody = z.infer<
+  typeof UpdateInvestorAccountBodySchema
+>;
+
+export const IPaginatedInvestorAccounts = z.object({
+  items: z.array(IInvestorAccount),
+  meta: IPaginationMeta,
+});
+export type IPaginatedInvestorAccounts = z.infer<
+  typeof IPaginatedInvestorAccounts
+>;
+
+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(),
+});
+export type InvestorAccountsSortZod = z.infer<typeof InvestorAccountsSortZod>;
+
+/**
+ * @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 as any),
+        ),
+      {
+        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 type InvestorAccountExportFilters = z.infer<
+  typeof InvestorAccountExportFilters
+>;
+
+export const ComplianceInvestorAccountExportFilters =
+  InvestorAccountsFiltersZod.extend({
+    startDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+    endDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  }).merge(InvestorAccountsSortZod);
+
+export type ComplianceInvestorAccountExportFilters = z.infer<
+  typeof ComplianceInvestorAccountExportFilters
+>;
+
+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 type AmlReviewDetailsZod = z.infer<typeof AmlReviewDetailsZod>;
+
+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 type KycReviewDetailsZod = z.infer<typeof KycReviewDetailsZod>;
+
+export const AicReviewDetailsZod = z.object({
+  accreditationType: z.string(),
+  expirationDate: z.date().nullable(),
+});
+
+export type AicReviewDetailsZod = z.infer<typeof AicReviewDetailsZod>;
+
+export enum InvestorAccountDetailsType {
+  AML = 'AML',
+  KYC = 'KYC',
+  AIC = 'AIC',
+}
+export const GetInvestorAccountDetailsQuery = z.object({
+  type: z.nativeEnum(InvestorAccountDetailsType),
+  individualId: z.lazy(() => individualIdSchema),
+});
+
+export type GetInvestorAccountDetailsQuery = z.infer<
+  typeof GetInvestorAccountDetailsQuery
+>;
+
+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 type RegisteredInvestorUserZod = z.infer<
+  typeof RegisteredInvestorUserZod
+>;
+
+export const IPaginatedRegisteredInvestorUserZod = z.object({
+  items: z.array(RegisteredInvestorUserZod),
+  meta: IPaginationMeta,
+});
+
+export type IPaginatedRegisteredInvestorUserZod = z.infer<
+  typeof IPaginatedRegisteredInvestorUserZod
+>;
+
+/**
+ * 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 type RegisteredInvestorUserRawZod = z.infer<
+  typeof RegisteredInvestorUserRawZod
+>;
+
+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 type RegisteredInvestorUserFiltersZod = z.infer<
+  typeof RegisteredInvestorUserFiltersZod
+>;
+
+export const ExportInvestorAccountsResponse = z.object({
+  message: z.string(),
+});
+
+export type ExportInvestorAccountsResponse = z.infer<
+  typeof ExportInvestorAccountsResponse
+>;
+
+export const IndividualsValidationResponseZod = z.object({
+  errors: ErrorResponseZod,
+  regDFieldStatus: z.boolean(),
+});
+export type IndividualsValidationResponseZod = z.infer<
+  typeof IndividualsValidationResponseZod
+>;
+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 || 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 type SystemReviewLogZod = z.infer<typeof SystemReviewLogZod>;
+
+export enum SeedType {
+  SYSTEM = 'SYSTEM',
+  EXTERNAL = 'EXTERNAL',
+}
+
+export const SeedInvestorAccountsForDemoUsersZod = z.object({
+  accountId: accountIdSchema,
+  seedType: z.nativeEnum(SeedType),
+});
+
+export type SeedInvestorAccountsForDemoUsersZod = z.infer<
+  typeof SeedInvestorAccountsForDemoUsersZod
+>;
+
+export const SeedTradeCsvRowZod = z.object({
+  id: 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: 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 type IParsedSeedDataZod = z.infer<typeof IParsedSeedDataZod>;
+
+export const GetInvestorAccountsFilters = PaginationOptionsZod.merge(
+  InvestorAccountsIncludeQuery,
+).merge(InvestorAccountsFilters);
+
+export type GetInvestorAccountsFilters = z.infer<
+  typeof GetInvestorAccountsFilters
+>;
+
+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 type InvestorStatusCheckZod = z.infer<typeof InvestorStatusCheckZod>;
+
+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(),
+});
+
+export type ExportRegisteredInvestorUsersFiltersZod = z.infer<
+  typeof ExportRegisteredInvestorUsersFiltersZod
+>;