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

package/README.md

@@ -14,32 +14,33 @@ npm install @dalmore/api-contracts@dev
 
 ## Usage
 
-### Import specific contracts (recommended for tree-shaking)
+### Import from main entry
 
 ```typescript
-import { complianceContract } from '@dalmore/api-contracts/compliance';
-import { investorsContract } from '@dalmore/api-contracts/investors';
-import { issuersContract } from '@dalmore/api-contracts/issuers';
-import { clientsContract } from '@dalmore/api-contracts/clients';
+import { clientsContract } from '@dalmore/api-contracts';
+import type { IInvestorAccount } from '@dalmore/api-contracts';
 ```
 
-### Import types
+### Import specific subpaths (recommended for tree-shaking)
 
 ```typescript
-import type { IInvestorAccount } from '@dalmore/api-contracts/types/investor-account.types';
-import type { ITrade } from '@dalmore/api-contracts/types/trade.types';
+// Import clients contract
+import { clientsContract } from '@dalmore/api-contracts/clients';
+
+// Import types
+import type { IInvestorAccount, ITrade } from '@dalmore/api-contracts/types';
 ```
 
 ### Create a typed client
 
 ```typescript
-import { complianceContract } from '@dalmore/api-contracts/compliance';
+import { clientsContract } from '@dalmore/api-contracts/clients';
 import { initClient } from '@ts-rest/core';
 
-const client = initClient(complianceContract, {
+const client = initClient(clientsContract, {
   baseUrl: 'https://platform.dalmoregroup.com',
   baseHeaders: {
-    Authorization: `Bearer ${token}`,
+    'X-API-Key': `${apiKey}`,
   },
 });
 
@@ -53,17 +54,20 @@ const { status, body } = await client.accounts.getAccounts({
 
 This package requires the following peer dependencies:
 
-- `@ts-rest/core` ^3.0.0
-- `zod` ^3.0.0
+- `@anatine/zod-openapi` ^1.14.2
+- `@ts-rest/core` ^3.52.1
+- `typeid-js` ^1.2.0
+- `zod` ^3.24.4
 
-## Available Contracts
+## Available Exports
 
-- `complianceContract` - Compliance portal API
-- `investorsContract` - Investor portal API
-- `issuersContract` - Issuer portal API
 - `clientsContract` - Client API (API key auth)
-- `secondariesContract` - Secondaries API
-- `complianceApiKeyContract` - Compliance API (API key auth)
+
+## Available Subpath Exports
+
+- `@dalmore/api-contracts` - Main entry (clients contract and types)
+- `@dalmore/api-contracts/clients` - Clients contract
+- `@dalmore/api-contracts/types` - All common types
 
 ## TypeScript Configuration
 

package/common/types/account-contact.types.ts

@@ -6,6 +6,7 @@ import { PhoneZodSchema } from './phone.type';
 import {
   AccountContactType,
   AccountZod,
+  EmailSchema,
   IPaginationMeta,
 } from './common.types';
 import { IBaseEntity } from './entity.types';
@@ -60,7 +61,7 @@ export const PatchAccountContactZod = z.object({
     .openapi({ example: 'Mr' }),
   firstName: z.string().min(1).max(150).openapi({ example: 'John' }),
   lastName: z.string().min(1).max(150).openapi({ example: 'Doe' }),
-  email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+  email: EmailSchema.openapi({ example: 'john.doe@example.com' }),
   phone: PhoneZodSchema.nullable()
     .optional()
     .openapi({ example: '+12124567890' }),

package/common/types/account-manager.types.ts

@@ -4,7 +4,7 @@ import { TypeID } from 'typeid-js';
 import { IBaseEntity } from './entity.types';
 import { PhoneNumberData } from './sms.types';
 import { userIdSchema, UserZod } from './user.types';
-import { IPaginationMeta } from './common.types';
+import { EmailSchema, IPaginationMeta } from './common.types';
 import { PhoneZodSchema } from './phone.type';
 
 extendZodWithOpenApi(z);
@@ -68,7 +68,7 @@ export type IAccountManagerZod = z.infer<typeof IAccountManagerZod>;
 export const PostAccountManagerZod = z.object({
   firstName: z.string().min(1).max(255).openapi({ example: 'John' }),
   lastName: z.string().min(1).max(255).openapi({ example: 'Doe' }),
-  email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+  email: EmailSchema,
   phone: PhoneZodSchema.nullable()
     .optional()
     .openapi({ example: '+12124567890' }),
@@ -80,11 +80,7 @@ export type PostAccountManagerZod = z.infer<typeof PostAccountManagerZod>;
 export const PatchAccountManagerZod = z.object({
   firstName: z.string().min(1).max(255).optional().openapi({ example: 'John' }),
   lastName: z.string().min(1).max(255).optional().openapi({ example: 'Doe' }),
-  email: z
-    .string()
-    .email()
-    .optional()
-    .openapi({ example: 'john.doe@example.com' }),
+  email: EmailSchema.optional(),
   phone: PhoneZodSchema.nullable()
     .optional()
     .openapi({ example: '+12124567890' }),

package/common/types/account-setting.types.ts

@@ -0,0 +1,65 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta } from './common.types';
+import { accountIdSchema } from './account.types';
+
+extendZodWithOpenApi(z);
+
+export const accountSettingIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'account_setting';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid account setting ID format. Must be a valid TypeID with "account_setting" prefix.',
+  },
+);
+
+export const IAccountSettingZod = IBaseEntity.extend({
+  id: accountSettingIdSchema.openapi({
+    example: 'account_setting_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  accountId: z.string().openapi({
+    example: 'account_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+});
+export type IAccountSettingZod = z.infer<typeof IAccountSettingZod>;
+
+export const IPaginatedAccountSetting = z.object({
+  items: z.array(IAccountSettingZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedAccountSetting = z.infer<typeof IPaginatedAccountSetting>;
+
+export const AccountSettingsFilters = z.object({
+  accountId: accountIdSchema.optional(),
+});
+export type AccountSettingsFilters = z.infer<typeof AccountSettingsFilters>;
+
+export const accountSettingsInclude = z.enum(['notificationChannels']);
+
+export const AccountSettingsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          accountSettingsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include value. Valid values are: ${accountSettingsInclude.options.join(', ')}`,
+      },
+    ),
+});
+export type AccountSettingsIncludeQuery = z.infer<
+  typeof AccountSettingsIncludeQuery
+>;

package/common/types/account.types.ts

@@ -91,6 +91,7 @@ export const AccountFiltersZod = z.object({
 const accountsInclude = z.enum([
   'accountManager',
   'accountIntegrations',
+  'accountSettings',
   'apiKeys',
   'assets',
   'dataRooms',

package/common/types/activity.types.ts

@@ -199,7 +199,7 @@ export const ActivityZod = IBaseEntity.extend({
   userId: z.string().nullable(),
   activityTypeId: z.string(),
   accountId: z.string().nullable(),
-  user: UserForActivityZod,
+  user: UserForActivityZod.nullable(),
   activityType: ActivityTypeZod,
   targetObject: z.string().nullable().optional(),
   __entity: z.string().optional(),

package/common/types/auth.types.ts

@@ -8,6 +8,7 @@ import {
   ManagedByType,
   UserRole,
   createUrlSchema,
+  EmailSchema,
 } from './common.types';
 import { TypeID } from 'typeid-js';
 import { TwoFactorMethod } from './sms.types';
@@ -60,13 +61,7 @@ const BaseAuthBody = z.object({
     .openapi({
       example: 'Armstrong',
     }),
-  email: z
-    .string()
-    .email()
-    .transform((val) => val.toLowerCase())
-    .openapi({
-      example: 'neil@dalmoregroup.com',
-    }),
+  email: EmailSchema,
   password: PasswordSchema,
 });
 
@@ -99,13 +94,7 @@ export const IChangePasswordBodyZod = z
   });
 
 export const LoginBody = z.object({
-  email: z
-    .string()
-    .email()
-    .transform((val) => val.toLowerCase())
-    .openapi({
-      example: 'neil@dalmoregroup.com',
-    }),
+  email: EmailSchema,
   password: z.string().openapi({
     example: 'Secretpassword6#',
   }),
@@ -297,7 +286,7 @@ export const RegisterBodyInvestors = BaseAuthBody.extend({
 });
 
 export const ResetPasswordVerifyBody = z.object({
-  email: z.string().email(),
+  email: EmailSchema,
   code: z.string().length(6, 'code is not 6 characters').openapi({
     example: '123456',
   }),
@@ -315,7 +304,7 @@ export type ResetPasswordVerifyResponseType = z.infer<
 >;
 
 export const ResetPasswordBody = z.object({
-  email: z.string().email(),
+  email: EmailSchema,
   code: z.string().length(6, 'code is not 6 characters').openapi({
     example: '123456',
   }),
@@ -337,7 +326,7 @@ export type ClientAuthSuccessResponse = z.infer<
 >;
 
 export const AdminForgotPasswordRequestZod = z.object({
-  email: z.string().email(),
+  email: EmailSchema,
   portal: z.nativeEnum(PortalType),
 });
 export type AdminForgotPasswordRequestZod = z.infer<
@@ -345,7 +334,7 @@ export type AdminForgotPasswordRequestZod = z.infer<
 >;
 
 export const InvestorForgotPasswordRequestZod = z.object({
-  email: z.string().email(),
+  email: EmailSchema,
   url: createUrlSchema({ strict: true }),
 });
 export type InvestorForgotPasswordRequestZod = z.infer<

package/common/types/bonus-tier.types.ts

@@ -98,6 +98,15 @@ export type EstimateBonusTierCalculationZod = z.infer<
   typeof EstimateBonusTierCalculationZod
 >;
 
+export const ComplianceEstimateBonusTierCalculationZod =
+  EstimateBonusTierCalculationZod.and(
+    z.object({
+      accountId: accountIdSchema,
+    }),
+  );
+export type ComplianceEstimateBonusTierCalculationZod = z.infer<
+  typeof ComplianceEstimateBonusTierCalculationZod
+>;
 export const EstimateBonusTierCalculationResponseZod = z.object({
   bonusTierId: bonusTierIdSchema
     .nullable()
@@ -145,3 +154,27 @@ export const CompliancePostBonusTierZod = PostBonusTierZod.extend({
 export type CompliancePostBonusTierZod = z.infer<
   typeof CompliancePostBonusTierZod
 >;
+export const PurchaseCalculationZod = z.object({
+  assetId: assetIdSchema,
+  totalAmount: z.number().positive().openapi({ example: 1000 }),
+  purchasedShares: z.number().positive().int().openapi({ example: 100 }),
+});
+export type PurchaseCalculationZod = z.infer<typeof PurchaseCalculationZod>;
+
+export const PurchaseCalculationResponseZod = z.object({
+  bonusTierId: bonusTierIdSchema
+    .nullable()
+    .openapi({ example: 'bonus_tier_01j5y5ghx5fg68d663j1fvy2x7' }),
+  assetId: assetIdSchema.openapi({
+    example: 'asset_00041061050r3gg28a1c60t3gf',
+  }),
+  type: z
+    .nativeEnum(BonusType)
+    .nullable()
+    .openapi({ example: BonusType.PERCENTAGE }),
+  bonusShares: z.number().int().openapi({ example: 100 }),
+});
+
+export type PurchaseCalculationResponseZod = z.infer<
+  typeof PurchaseCalculationResponseZod
+>;

package/common/types/cart.types.ts

@@ -3,6 +3,7 @@ import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { TradeStatus } from './common.types';
 import { investorAccountIdSchema } from './investor-account.types';
 import { paymentMethodIdSchema } from './payment-methods.types';
+import { userIdSchema } from './user.types';
 
 extendZodWithOpenApi(z);
 
@@ -10,7 +11,9 @@ export const PlaceTradeResponse = z.object({
   tradeStatus: z.nativeEnum(TradeStatus).optional(),
 });
 export const PlaceTradeBody = z.object({});
-
+export const ClientPlacetradeBody = z.object({
+  userId: userIdSchema,
+});
 export const PatchCartBody = z.object({
   investorAccountId: investorAccountIdSchema.optional(),
   paymentMethodId: paymentMethodIdSchema.optional(),

package/common/types/common.types.ts

@@ -69,6 +69,10 @@ export enum BaseStatus {
   VOIDED = 'VOIDED',
   JOIN = 'JOIN',
   RESTORE = 'RESTORE',
+  ACTIVE = 'ACTIVE',
+  LOCKED = 'LOCKED',
+  ENABLED = 'ENABLED',
+  DISABLED = 'DISABLED',
 }
 
 export const UserWithoutPasswordAccountZod = IBaseEntity.extend({
@@ -111,6 +115,10 @@ export enum HttpMethod {
   OPTIONS = 'OPTIONS',
 }
 
+export enum UserStatus {
+  ACTIVE = 'ACTIVE',
+  LOCKED = 'LOCKED',
+}
 export const SENSITIVE_PATTERNS = [
   /password/i,
   /credit.*card/i,
@@ -200,11 +208,6 @@ export enum UserType {
   DEMO = 'DEMO',
 }
 
-export enum UserStatus {
-  ACTIVE = 'ACTIVE',
-  LOCKED = 'LOCKED',
-}
-
 export enum UserRole {
   API_KEY = 'API_KEY',
   IMPORT = 'IMPORT',
@@ -306,7 +309,7 @@ export const AuthUserReq = BaseAuthReq.extend({
   lastName: z.string(),
   email: z.string().email(),
   provider: z.string(),
-  status: z.lazy(() => z.nativeEnum(UserStatus)),
+  locked: z.boolean(),
   lastLoginAt: z.date().nullable(),
   loginCount: z.number(),
   requiresTwoFactorSetup: z.boolean().optional(),
@@ -809,6 +812,8 @@ export enum EventField {
   SA_STATUS = 'saStatus',
   ONBOARDING_STATUS = 'onboardingStatus',
   TRANSACTION_STATUS = 'transactionStatus',
+  ACTIVE = 'active',
+  LOCKED = 'locked',
 }
 
 export enum EventName {
@@ -1518,3 +1523,30 @@ export const SUBJECT_TYPE_MAP: Record<BulkExportType, string> = {
   [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(),
+);
+export type StringToBooleanSchema = z.infer<typeof StringToBooleanSchema>;
+
+/**
+ * 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',
+  });

package/common/types/contact-us.types.ts

@@ -1,7 +1,11 @@
 import { z } from 'zod';
 import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { TypeID } from 'typeid-js';
-import { BaseContactUsOptions, createUrlSchema } from './common.types';
+import {
+  BaseContactUsOptions,
+  createUrlSchema,
+  EmailSchema,
+} from './common.types';
 extendZodWithOpenApi(z);
 
 export const contactUsIdSchema = z.string().refine(
@@ -55,7 +59,7 @@ export const InvestorPostContactUsZod = PostContactUsZod.extend({
 export type InvestorPostContactUsZod = z.infer<typeof InvestorPostContactUsZod>;
 
 export const PublicInvestorContactUsZod = PostContactUsZod.extend({
-  email: z.string().email().openapi({ example: 'email@example.com' }),
+  email: EmailSchema,
   firstName: z.string().min(1).max(100).openapi({ example: 'John' }),
   lastName: z.string().min(1).max(100).openapi({ example: 'Doe' }),
   contactOption: z.nativeEnum(InvestorContactOptions).openapi({

package/common/types/covered-person.types.ts

@@ -6,6 +6,7 @@ import {
   ComplianceReview,
   CoveredPersonsRoleType,
   CoveredPersonsStatus,
+  EmailSchema,
   IDType,
   IPaginationMeta,
 } from './common.types';
@@ -137,7 +138,7 @@ export const PatchCoveredPersonsZod = z
       .openapi({ example: CoveredPersonsRoleType.ACCOUNTING }),
 
     ownership: z.number().min(0).max(100).openapi({ example: 15 }).optional(),
-    email: z.string().nullable().optional(),
+    email: EmailSchema.nullable().optional(),
     idType: z
       .nativeEnum(IDType)
       .optional()

package/common/types/dashboard.types.ts

@@ -7,6 +7,7 @@ import {
   FileLabels,
   IPaginationMeta,
   OfferingType,
+  StringToBooleanSchema,
 } from './common.types';
 import { accountIdSchema } from './account.types';
 
@@ -330,15 +331,7 @@ export const GetInvestmentDashboardQueryZod = z.object({
   offerings: OfferingsArrayQueryZod.optional(),
   offeringTypes: OfferingTypesQueryZod.optional(),
   timeFilteringType: z.nativeEnum(DashboardTimeFilteringType),
-  debug: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
+  debug: StringToBooleanSchema.optional(),
 });
 export type GetInvestmentDashboardQueryZod = z.infer<
   typeof GetInvestmentDashboardQueryZod

package/common/types/disbursements.types.ts

@@ -11,14 +11,17 @@ import {
 import { tradeIdSchema } from './trade.types';
 import { accountIdSchema } from './account.types';
 import { TypeID } from 'typeid-js';
-import { issuerIdSchema } from './issuer.types';
-import { issuerBankAccountIdSchema } from './issuer-bank-account.types';
+import { IIssuer, issuerIdSchema } from './issuer.types';
+import {
+  IIssuerBankAccount,
+  issuerBankAccountIdSchema,
+} from './issuer-bank-account.types';
 import { userIdSchema, UserZod } from './user.types';
 import {
   PostDisbursementAdjustmentZod,
   DisbursementAdjustmentType,
 } from './disbursement-adjustment.types';
-import { escrowAccountIdSchema } from './escrow-account.types';
+import { IEscrowAccount, escrowAccountIdSchema } from './escrow-account.types';
 
 export const disbursementIdSchema = z.string().refine(
   (value) => {
@@ -308,3 +311,116 @@ export const DisbursementSummaryZod = z.object({
   amountToBeTransferred: z.number(),
 });
 export type DisbursementSummaryZod = z.infer<typeof DisbursementSummaryZod>;
+
+// GET /disbursements/preview query parameters
+export const GetDisbursementPreviewQueryZod = z.object({
+  offeringId: offeringIdSchema,
+  selectedTrades: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (ids) =>
+        ids.every((id) => {
+          try {
+            const tid = TypeID.fromString(id);
+            return tid.getType() === 'trade';
+          } catch {
+            return false;
+          }
+        }),
+      {
+        message: 'All selected trades must be valid trade IDs',
+      },
+    )
+    .openapi({
+      example: 'trade_01abc123,trade_01def456',
+    }),
+});
+export type GetDisbursementPreviewQueryZod = z.infer<
+  typeof GetDisbursementPreviewQueryZod
+>;
+
+// Context fields for disbursement preview
+export const DisbursementPreviewContextZod = z.object({
+  issuer: z.lazy(() => IIssuer).nullable(),
+  offering: z.lazy(() => IOffering).nullable(),
+  escrowAccount: z.lazy(() => IEscrowAccount).nullable(),
+  destinationBank: z.lazy(() => IIssuerBankAccount).nullable(),
+});
+export type DisbursementPreviewContextZod = z.infer<
+  typeof DisbursementPreviewContextZod
+>;
+
+// Balance values for disbursement preview
+export const DisbursementPreviewBalanceZod = z.object({
+  totalRaised: z.number(),
+  totalDisbursed: z.number(),
+  pending: z.number(),
+  refundPool: z.number(),
+  availableForDisbursement: z.number(),
+});
+export type DisbursementPreviewBalanceZod = z.infer<
+  typeof DisbursementPreviewBalanceZod
+>;
+
+// Trade summary for disbursement preview
+export const DisbursementPreviewTradeSummaryZod = z.object({
+  selectedTradesCount: z.number(),
+  selectedTradesTotalAmount: z.number(),
+});
+export type DisbursementPreviewTradeSummaryZod = z.infer<
+  typeof DisbursementPreviewTradeSummaryZod
+>;
+
+// Contingency validation result
+export const DisbursementPreviewContingencyZod = z.object({
+  contingencyPassed: z.boolean(),
+  contingencyMessage: z.string().nullable(),
+  contingencyAmount: z.number(),
+});
+export type DisbursementPreviewContingencyZod = z.infer<
+  typeof DisbursementPreviewContingencyZod
+>;
+
+// Amount defaults and constraints
+export const DisbursementPreviewAmountZod = z.object({
+  defaultAmount: z.number(),
+  minAmount: z.number(),
+  maxAmount: z.number(),
+});
+export type DisbursementPreviewAmountZod = z.infer<
+  typeof DisbursementPreviewAmountZod
+>;
+
+// Complete response for GET /disbursements/preview
+export const DisbursementPreviewZod = z.object({
+  context: DisbursementPreviewContextZod,
+  balance: DisbursementPreviewBalanceZod,
+  tradeSummary: DisbursementPreviewTradeSummaryZod,
+  contingency: DisbursementPreviewContingencyZod,
+  amount: DisbursementPreviewAmountZod,
+});
+export type DisbursementPreviewZod = z.infer<typeof DisbursementPreviewZod>;
+
+export const EligibleOfferingZod = z.object({
+  offeringId: offeringIdSchema,
+  offeringName: z.string(),
+  availableAmount: z.number(),
+});
+export type EligibleOfferingZod = z.infer<typeof EligibleOfferingZod>;
+
+export const IPaginatedEligibleOffering = z.object({
+  items: z.array(EligibleOfferingZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedEligibleOffering = z.infer<
+  typeof IPaginatedEligibleOffering
+>;
+
+export const EligibleOfferingsFiltersZod = z.object({
+  search: z.string().optional(),
+});
+export type EligibleOfferingsFiltersZod = z.infer<
+  typeof EligibleOfferingsFiltersZod
+>;

package/common/types/escrow-account.types.ts

@@ -1,6 +1,6 @@
 import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { z } from 'zod';
-import { AccountZod, IPaginationMeta } from './common.types';
+import { AccountZod, EmailSchema, IPaginationMeta } from './common.types';
 import { IBaseEntity } from './entity.types';
 import { TypeID } from 'typeid-js';
 import { accountIdSchema } from './account.types';
@@ -43,7 +43,7 @@ export const PostEscrowAccount = z.object({
   accountNumber: z.string().optional().nullable(),
   routingNumber: z.string().min(9).max(9).optional().nullable(),
   agentName: z.string().min(2).max(50),
-  agentEmail: z.string().email(),
+  agentEmail: EmailSchema,
 });
 
 export type PostEscrowAccount = z.infer<typeof PostEscrowAccount>;
@@ -65,7 +65,7 @@ export const PatchEscrowAccount = z.object({
   accountNumber: z.string().min(10).max(18).optional().nullable().optional(),
   routingNumber: z.string().min(9).max(9).optional().nullable().optional(),
   agentName: z.string().min(2).max(50).optional(),
-  agentEmail: z.string().email().optional(),
+  agentEmail: EmailSchema.optional(),
 });
 
 export type PatchEscrowAccount = z.infer<typeof PatchEscrowAccount>;