@dalmore/api-contracts 1.0.8 → 1.0.10

package/README.md

@@ -2,73 +2,82 @@
 
 Type-safe API contracts for Dalmore Client Portal, powered by [ts-rest](https://ts-rest.com/).
 
-This package provides **full end-to-end type inference** by shipping TypeScript source files alongside compiled JavaScript.
-
 ## Installation
 
 ```bash
+# Production (stable releases from main branch)
 npm install @dalmore/api-contracts
-```
-
-### Peer Dependencies
 
-```bash
-npm install @ts-rest/core zod @anatine/zod-openapi @nestjs/common libphonenumber-js neverthrow typeid-js
+# Development (latest from dev branch)
+npm install @dalmore/api-contracts@dev
 ```
 
 ## Usage
 
+### Import from main entry
+
 ```typescript
 import { clientsContract } from '@dalmore/api-contracts';
+import type { IInvestorAccount } from '@dalmore/api-contracts';
+```
+
+### Import specific subpaths (recommended for tree-shaking)
+
+```typescript
+// 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 { clientsContract } from '@dalmore/api-contracts/clients';
 import { initClient } from '@ts-rest/core';
 
 const client = initClient(clientsContract, {
-  baseUrl: 'https://api.example.com',
+  baseUrl: 'https://platform.dalmoregroup.com',
   baseHeaders: {
-    'x-api-key': 'your-api-key',
+    'X-API-Key': `${apiKey}`,
   },
 });
 
-// Fully typed API calls with complete autocomplete
-const { status, body } = await client.accounts.getAccounts();
-
-// Access nested endpoints with full type inference
-const trade = await client.trades.getTrade({ params: { id: 'trade_123' } });
+// Fully typed API calls
+const { status, body } = await client.accounts.getAccounts({
+  query: { page: 1, limit: 10 },
+});
 ```
 
+## Peer Dependencies
+
+This package requires the following peer dependencies:
+
+- `@anatine/zod-openapi` ^1.14.2
+- `@ts-rest/core` ^3.52.1
+- `typeid-js` ^1.2.0
+- `zod` ^3.24.4
+
+## Available Exports
+
+- `clientsContract` - Client 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
 
-For optimal type inference, ensure your `tsconfig.json` includes:
+This package ships TypeScript source files for maximum type safety. Your `tsconfig.json` should include:
 
 ```json
 {
   "compilerOptions": {
-    "skipLibCheck": true, // Recommended for faster compilation
     "moduleResolution": "node",
     "esModuleInterop": true
   }
 }
 ```
-
-## Available Endpoints
-
-The `clientsContract` includes:
-
-| Endpoint           | Description             |
-| ------------------ | ----------------------- |
-| `accounts`         | Account management      |
-| `aic`              | AIC verification        |
-| `auth`             | Authentication          |
-| `apiKeys`          | API key management      |
-| `apiKeyLogs`       | API key usage logs      |
-| `assets`           | Asset management        |
-| `files`            | File uploads            |
-| `filesPublic`      | Public file access      |
-| `individuals`      | Individual management   |
-| `investorAccounts` | Investor accounts       |
-| `issuers`          | Issuer information      |
-| `legalEntities`    | Legal entity management |
-| `offerings`        | Offering data           |
-| `secureRequests`   | Secure request handling |
-| `sites`            | Site configuration      |
-| `trades`           | Trade management        |

package/common/helpers/index.ts

@@ -0,0 +1,59 @@
+/**
+ * Contract helpers - minimal subset for API documentation generation
+ */
+
+type CurlOptions = {
+  query?: Record<string, string>;
+  headers?: Record<string, string>;
+  body?: Record<string, unknown>;
+  formData?: Record<string, string>;
+};
+
+export const authHeader: CurlOptions['headers'] = {
+  Authorization: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+};
+
+const generateCurlExample = (
+  method: string,
+  path: string,
+  options: CurlOptions,
+) => {
+  const baseUrl = 'https://dalmore-client-portal-api-prod.onrender.com/api/v1';
+  let curl = `curl -X ${method.toUpperCase()} '${baseUrl}${path}`;
+  if (options.query) {
+    const queryString = new URLSearchParams(options.query).toString();
+    curl += `?${queryString}`;
+  }
+  curl += "'";
+  if (options.headers) {
+    Object.entries(options.headers).forEach(([key, value]) => {
+      curl += ` \\\n  --header '${key}: ${value}'`;
+    });
+  }
+  if (options.body) {
+    curl += ` \\\n  --header 'Content-Type: application/json'`;
+    curl += ` \\\n  --data '${JSON.stringify(options.body)}'`;
+  }
+  if (options.formData) {
+    Object.entries(options.formData).forEach(([key, value]) => {
+      curl += ` \\\n  --form '${key}=${value}'`;
+    });
+  }
+  return curl;
+};
+
+export const generateApiDescription = (
+  summary: string,
+  method: string,
+  path: string,
+  options: CurlOptions,
+) => {
+  const curlExample = generateCurlExample(method, path, options);
+  return `${summary}
+
+### Example curl request
+
+\`\`\`bash
+${curlExample}
+\`\`\``;
+};

package/{src/common → 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/{src/common → 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/{src/common → 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/{src/common → 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/{src/common → common}/types/api-key-logs.types.ts

@@ -12,7 +12,7 @@ export const ApiLogsFiltersZod = z.object({
   endpoint: z.string().optional(),
   apiKeyId: apiKeyIdSchema.optional(),
   method: z.nativeEnum(HttpMethod).optional(),
-  status: z.nativeEnum(HttpStatus).optional(),
+  status: z.preprocess(Number, z.nativeEnum(HttpStatus)).optional(),
   from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
   to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
 });

package/{src/common → common}/types/asset.types.ts

@@ -29,7 +29,7 @@ export const assetIdSchema = z.string().refine(
     message: `Invalid asset ID format. Must be a valid TypeID with "asset" prefix. Example: asset_01j5y5ghx5fg68d663j1fvy2x7`,
   },
 );
-export enum TemplateType {
+export enum AssetTemplateType {
   STANDARD = 'STANDARD',
   TIERED = 'TIERED',
 }
@@ -51,7 +51,7 @@ export const IAsset = IBaseEntity.extend({
     .lazy(() => IOffering)
     .optional()
     .nullable(), // Use z.lazy here
-  template: z.nativeEnum(TemplateType),
+  template: z.nativeEnum(AssetTemplateType),
   tiers: z.array(z.number().positive()).nullable(),
   enableBonus: z.boolean(),
 });
@@ -102,16 +102,16 @@ const PostAssetBase = z.object({
     .optional()
     .openapi({ example: DurationType.DAY }),
   template: z
-    .nativeEnum(TemplateType)
-    .default(TemplateType.STANDARD)
-    .openapi({ example: TemplateType.STANDARD }),
+    .nativeEnum(AssetTemplateType)
+    .default(AssetTemplateType.STANDARD)
+    .openapi({ example: AssetTemplateType.STANDARD }),
   tiers: z.array(z.number().positive()).nullable().optional(),
   enableBonus: z.boolean().default(false).openapi({ example: false }),
 });
 
-const postAssetRefinement = (data: any, ctx: any) => {
+export const postAssetRefinement = (data: any, ctx: any) => {
   // If type is bond, yield and duration must be provided (cannot be null or undefined)
-  if (data.type === AssetType.BOND) {
+  if (data.assetType === AssetType.BOND || data.type === AssetType.BOND) {
     if (data.yield === null || data.yield === undefined) {
       ctx.addIssue({
         path: ['yield'],
@@ -139,7 +139,7 @@ const postAssetRefinement = (data: any, ctx: any) => {
   }
 
   // If type is stock, yield and duration must be either null or undefined
-  if (data.type === AssetType.STOCK) {
+  if (data.assetType === AssetType.STOCK || data.type === AssetType.STOCK) {
     if (data.yield !== null && data.yield !== undefined) {
       ctx.addIssue({
         path: ['yield'],
@@ -162,7 +162,7 @@ const postAssetRefinement = (data: any, ctx: any) => {
       });
     }
   }
-  if (data.template === TemplateType.TIERED) {
+  if (data.template === AssetTemplateType.TIERED) {
     if (data.tiers === null || data.tiers === undefined) {
       ctx.addIssue({
         path: ['tiers'],
@@ -172,7 +172,7 @@ const postAssetRefinement = (data: any, ctx: any) => {
     }
   }
   // If template is STANDARD, tiers must be null or undefined
-  if (data.template === TemplateType.STANDARD) {
+  if (data.template === AssetTemplateType.STANDARD) {
     if (data.tiers !== null && data.tiers !== undefined) {
       ctx.addIssue({
         path: ['tiers'],
@@ -233,9 +233,9 @@ export const PutAsset = z.object({
     .optional()
     .openapi({ example: DurationType.DAY }),
   template: z
-    .nativeEnum(TemplateType)
-    .default(TemplateType.STANDARD)
-    .openapi({ example: TemplateType.STANDARD })
+    .nativeEnum(AssetTemplateType)
+    .default(AssetTemplateType.STANDARD)
+    .openapi({ example: AssetTemplateType.STANDARD })
     .nullable()
     .optional(),
   tiers: z.array(z.number().positive()).nullable().optional(),
@@ -262,7 +262,7 @@ export const AssetsIncludeQuery = z.object({
           assetsInclude.options.includes(include as any),
         ),
       {
-        message: `Invalid include option provided. Valid options are: ${assetsInclude.options.join(', ')}`,
+        message: `Invalid include option provided. Valid options are: ${assetsInclude.options.join(',')}`,
       },
     )
     .openapi({

package/{src/common → 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/{src/common → 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/{src/common → 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/{src/common → common}/types/common.types.ts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { TypeID } from 'typeid-js';
 import { ErrorHttpStatusCode } from '@ts-rest/core';
 import { TwoFactorMethod } from './sms.types';
-import { normalizeShortDate } from './contract-helpers';
+import { normalizeShortDate } from '../helpers';
 import { HttpStatus } from '@nestjs/common';
 
 extendZodWithOpenApi(z);
@@ -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/{src/common → 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/{src/common → 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()