@dalmore/api-contracts 0.0.0-dev.2dc8e92 → 0.0.0-dev.4eac826

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/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/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/common/types/disbursements.types.ts

@@ -308,3 +308,25 @@ export const DisbursementSummaryZod = z.object({
   amountToBeTransferred: z.number(),
 });
 export type DisbursementSummaryZod = z.infer<typeof DisbursementSummaryZod>;
+
+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/file.types.ts

@@ -17,7 +17,7 @@ import { KybZod } from './kyb.types';
 import { IIndividualZod, individualIdSchema } from './individuals.types';
 import { LegalEntityZod } from './legal-entity.types';
 import { IInvestorAccount } from './investor-account.types';
-import { TradeZod } from './trade.types';
+import { tradeIdSchema, TradeZod } from './trade.types';
 
 extendZodWithOpenApi(z);
 
@@ -168,13 +168,13 @@ export type PostFileQueryParams = z.infer<typeof PostFileQueryParams>;
 
 /**
  * CLIENT portal specific schema for file uploads
- * Only allows INDIVIDUALS as target for file uploads
+ * Only allows INDIVIDUALS and TRADES as target for file uploads
  */
 export const ClientPostFileQueryParams = z.object({
   name: z.string().min(1).max(100).openapi({ example: 'file_name' }),
   category: z.string().max(50).openapi({ example: 'application' }),
   label: FileLabelsEnum.openapi({ example: FileLabels.OTHER }),
-  targetId: individualIdSchema.openapi({
+  targetId: z.union([individualIdSchema, tradeIdSchema]).openapi({
     example: 'individual_01kcrsny60fb9rjc8bbqc3b80c',
   }),
   metadata: metadataSchema.nullable().optional(),
@@ -314,8 +314,23 @@ export const reviewFiles = z.object({
 });
 export type reviewFiles = z.infer<typeof reviewFiles>;
 
+/**
+ * Zod preprocessor that trims strings and converts empty/whitespace-only strings to null
+ */
+const trimAndNullifyString = z.preprocess((val) => {
+  if (typeof val === 'string') {
+    const trimmed = val.trim();
+    return trimmed === '' ? null : trimmed;
+  }
+  return val;
+}, z.unknown());
+
 export const PatchFileMetadata = z.object({
-  corrected: z.record(z.string(), z.unknown()),
+  corrected: z.record(z.string(), trimAndNullifyString),
+  expectedCorrected: z
+    .record(z.string(), trimAndNullifyString)
+    .nullable()
+    .optional(),
 });
 export type PatchFileMetadata = z.infer<typeof PatchFileMetadata>;
 
@@ -343,6 +358,7 @@ export const FileMetadataSchema = z.object({
       },
     ),
   corrected: z.record(z.any()).optional(),
+  expectedCorrected: z.record(z.any()).optional(),
 });
 export type FileMetadata = z.infer<typeof FileMetadataSchema>;
 

package/common/types/i-will-do-it-later.types.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { PortalType, TargetTableEnum } from './common.types';
+import { TaskPriority, TaskType } from './task.types';
+
+export enum IWillDoItLaterType {
+  KYC = 'KYC',
+  // Future types can be added here:
+  // AIC = 'AIC',
+  // AML = 'AML',
+}
+
+export const IWillDoItLaterBodySchema = z.object({
+  type: z.nativeEnum(IWillDoItLaterType).default(IWillDoItLaterType.KYC),
+});
+
+export type IWillDoItLaterBodyType = z.infer<typeof IWillDoItLaterBodySchema>;
+
+export const IWillDoItLaterResponseSchema = z.object({
+  message: z.string(),
+});
+
+export type IWillDoItLaterResponseType = z.infer<
+  typeof IWillDoItLaterResponseSchema
+>;
+
+/**
+ * @description Context required for processing "I'll do it later" actions.
+ */
+export interface IWillDoItLaterContext {
+  /** The ID of the target entity */
+  targetId: string;
+  /** The table name of the target entity */
+  targetTable: (typeof TargetTableEnum)[number];
+  /** The account ID associated with the action */
+  accountId: string;
+  /** The user ID who will be assigned the task */
+  assigneeId: string;
+}
+
+/**
+ * @description Configuration for each "I'll do it later" action type.
+ * Maps action types to their corresponding task configuration.
+ */
+export interface IWillDoItLaterTaskConfig {
+  taskType: TaskType;
+  portalType: PortalType;
+  title: string;
+  description: string;
+  priority: TaskPriority;
+}
+
+/**
+ * @description Mapping of "I'll do it later" types to their task configurations.
+ * This allows for easy extension of new action types without modifying the service logic.
+ */
+export const IWillDoItLaterTaskConfigMap: Record<
+  IWillDoItLaterType,
+  IWillDoItLaterTaskConfig
+> = {
+  [IWillDoItLaterType.KYC]: {
+    taskType: TaskType.COMPLETE_KYC,
+    portalType: PortalType.INVESTOR,
+    title: 'Complete KYC',
+    description:
+      'We are unable to verify your KYC information. Please complete your KYC.',
+    priority: TaskPriority.HIGH,
+  },
+};

package/common/types/index.ts

@@ -42,6 +42,8 @@ export * from './domain-filter.types';
 export * from './aic.types';
 export * from './default-theme-config.types';
 export * from './offering-reports.types';
+export * from './i-will-do-it-later.types';
+export * from './payment-methods.types';
 
 export enum Versions {
   V1 = 'v1',

package/common/types/issuer-offering.types.ts

@@ -8,10 +8,12 @@ import {
   ManagedByType,
   OfferingVersioningType,
   ComplianceReview,
+  DurationType,
+  AssetType,
 } from './common.types';
 import { IBaseEntity } from './entity.types';
 import { IIssuer, issuerIdSchema } from './issuer.types';
-import { IAsset } from './asset.types';
+import { IAsset, postAssetRefinement, AssetTemplateType } from './asset.types';
 import { fileIdSchema, FileZod } from './file.types';
 import { accountIdSchema } from './account.types';
 
@@ -128,20 +130,59 @@ export const PostIssuerOffering = z
       .nullable()
       .openapi({ example: 'This is a description of the offering.' }),
     managedBy: z.nativeEnum(ManagedByType).optional(),
+    assetName: z.string().min(2).max(50).openapi({ example: 'Asset name' }),
+    assetType: z.nativeEnum(AssetType).openapi({ example: AssetType.STOCK }),
+    pricePerUnit: z
+      .number()
+      .min(0.01)
+      .max(10000000000)
+      .nullable()
+      .openapi({ example: 2000 }),
+    totalUnits: z
+      .number()
+      .min(1)
+      .max(10000000000)
+      .nullable()
+      .openapi({ example: 5200 }),
+    yield: z
+      .number()
+      .min(0.01)
+      .max(10000000000)
+      .nullable()
+      .optional()
+      .openapi({ example: 1200 }),
+    duration: z
+      .number()
+      .min(1)
+      .max(1000)
+      .nullable()
+      .optional()
+      .openapi({ example: 1 }),
+    durationType: z
+      .nativeEnum(DurationType)
+      .nullable()
+      .optional()
+      .openapi({ example: DurationType.DAY }),
+    template: z
+      .nativeEnum(AssetTemplateType)
+      .default(AssetTemplateType.STANDARD)
+      .openapi({ example: AssetTemplateType.STANDARD }),
+    tiers: z.array(z.number().positive()).nullable().optional(),
   })
-  .refine(
-    (data) => {
-      // Check if both values are present, and if so, ensure minInvestment is less than maxInvestment
-      if (data.minInvestment && data.maxInvestment) {
-        return data.minInvestment < data.maxInvestment;
+  .superRefine((data, ctx) => {
+    // Check if both values are present, and if so, ensure minInvestment is less than maxInvestment
+    if (data.minInvestment && data.maxInvestment) {
+      if (data.minInvestment >= data.maxInvestment) {
+        ctx.addIssue({
+          path: ['minInvestment'],
+          message: 'Minimum investment must be less than maximum investment.',
+          code: z.ZodIssueCode.custom,
+        });
       }
-      return true; // If one or both values are undefined, skip this check
-    },
-    {
-      message: 'Minimum investment must be less than maximum investment.',
-      path: ['minInvestment'],
-    },
-  );
+    }
+    // Apply asset-specific refinements
+    postAssetRefinement(data, ctx);
+  });
 
 export type PostIssuerOffering = z.infer<typeof PostIssuerOffering>;
 export const PatchIssuerOffering = z.object({
@@ -212,6 +253,52 @@ export const PatchIssuerOffering = z.object({
   managedBy: z.nativeEnum(ManagedByType).optional(),
   showTotalRaised: z.boolean().optional(),
   issuerId: issuerIdSchema.optional(),
+  assetName: z.string().min(2).max(50).optional().openapi({ example: 'Z' }),
+  assetType: z
+    .nativeEnum(AssetType)
+    .optional()
+    .openapi({ example: AssetType.STOCK }),
+  pricePerUnit: z
+    .number()
+    .min(0.01)
+    .max(10000000000)
+    .nullable()
+    .optional()
+    .openapi({ example: 2000 }),
+  totalUnits: z
+    .number()
+    .min(1)
+    .max(10000000000)
+    .nullable()
+    .optional()
+    .openapi({ example: 5200 }),
+  yield: z
+    .number()
+    .min(0.01)
+    .max(10000000000)
+    .nullable()
+    .optional()
+    .openapi({ example: 1200 }),
+  duration: z
+    .number()
+    .min(1)
+    .max(1000)
+    .nullable()
+    .optional()
+    .openapi({ example: 1 }),
+  durationType: z
+    .nativeEnum(DurationType)
+    .nullable()
+    .optional()
+    .openapi({ example: DurationType.DAY }),
+  template: z
+    .nativeEnum(AssetTemplateType)
+    .default(AssetTemplateType.STANDARD)
+    .openapi({ example: AssetTemplateType.STANDARD })
+    .nullable()
+    .optional(),
+  tiers: z.array(z.number().positive()).nullable().optional(),
+  enabled: z.boolean().optional(),
 });
 export type PatchIssuerOffering = z.infer<typeof PatchIssuerOffering>;
 

package/common/types/issuer-payment-method.types.ts

@@ -222,10 +222,51 @@ export type IPaginatedIssuerPaymentMethod = z.infer<
   typeof IPaginatedIssuerPaymentMethod
 >;
 
+const issuerPaymentMethodsInclude = z.enum(['issuer', 'integration']);
+
+/**
+ * @description Query parameters for including related entities
+ * @example in contract use as -> query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(IssuerPaymentMethodsIncludeQuery)
+ */
+export const IssuerPaymentMethodsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          issuerPaymentMethodsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${issuerPaymentMethodsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${issuerPaymentMethodsInclude.options.join(',')}`,
+    }),
+});
+export type IssuerPaymentMethodsIncludeQuery = z.infer<
+  typeof IssuerPaymentMethodsIncludeQuery
+>;
+
 export const GetIssuerPaymentMethodZod = z.object({
   issuerId: issuerIdSchema.openapi({
     example: 'issuer_01jdq2crwke8xskjd840cj79pw',
   }),
+  enabled: z
+    .string()
+    .optional()
+    .refine((v) => !v || v === 'true' || v === 'false', {
+      message: 'enabled must be a boolean string',
+    })
+    .transform((v) => {
+      if (!v) return undefined;
+      return v === 'true';
+    })
+    .openapi({
+      example: 'true',
+    }),
 });
 export type GetIssuerPaymentMethodZod = z.infer<
   typeof GetIssuerPaymentMethodZod

package/common/types/issuer.types.ts

@@ -152,6 +152,10 @@ export const PutIssuerZod = z
       .lazy(() => fileIdSchema)
       .optional()
       .nullable(),
+    formationDocumentFileId: z
+      .lazy(() => fileIdSchema)
+      .optional()
+      .nullable(),
     coverArtId: z
       .lazy(() => fileIdSchema)
       .optional()
@@ -188,6 +192,11 @@ export const IIssuer = IBaseEntity.extend({
   accountId: z.string(),
   account: AccountZod.optional().nullable(),
   ss4LetterFileId: z.string().nullable(),
+  formationDocumentFileId: z.string().nullable(),
+  formationDocument: z
+    .lazy(() => FileZod)
+    .nullable()
+    .optional(),
   status: z
     .nativeEnum(IssuerStatus)
     .openapi({ example: IssuerStatus.SUBMITTED }),

package/common/types/offering.types.ts

@@ -15,6 +15,8 @@ import {
   SortBy,
   OfferingVersioningType,
   OfferingOnboardingStatus,
+  AssetType,
+  DurationType,
 } from './common.types';
 import { IBaseEntity } from './entity.types';
 import { fileIdSchema, FileZod } from './file.types';
@@ -24,6 +26,7 @@ import {
   InvestorsOfferingsIncludeQuery,
 } from './investors-offering.types';
 import { OfferingStatus } from './issuer-offering.types';
+import { postAssetRefinement, AssetTemplateType } from './asset.types';
 
 export enum OfferingFeeType {
   FIXED = 'FIXED',
@@ -115,7 +118,7 @@ export const IPaginatedOffering = z.object({
 });
 export type IPaginatedOffering = z.infer<typeof IPaginatedOffering>;
 
-export const PatchOffering = z.object({
+export const PatchOfferingBase = z.object({
   name: z.string().optional(),
   description: z.string().nullable().optional(),
   tid: z.string().optional(),
@@ -148,8 +151,8 @@ export const PatchOffering = z.object({
     .openapi({ example: 5000 })
     .optional()
     .nullable(),
-  startAt: dateSchema.optional(),
-  endAt: dateSchema.optional(),
+  startAt: dateSchema.optional().openapi({ example: '10/20/2024' }),
+  endAt: dateSchema.optional().openapi({ example: '10/27/2024' }),
   platform: z.string().optional(),
   coverArtId: z
     .lazy(() => fileIdSchema)
@@ -175,16 +178,106 @@ export const PatchOffering = z.object({
   showTotalRaised: z.boolean().optional(),
   issuerId: issuerIdSchema.optional(),
 });
-
+export const PatchOffering = PatchOfferingBase.merge(
+  z.object({
+    assetName: z
+      .string()
+      .min(2)
+      .max(50)
+      .optional()
+      .openapi({ example: 'Asset name' }),
+    assetType: z
+      .nativeEnum(AssetType)
+      .optional()
+      .openapi({ example: AssetType.STOCK }),
+    pricePerUnit: z
+      .number()
+      .min(0.01)
+      .max(10000000000)
+      .nullable()
+      .optional()
+      .openapi({ example: 2000 }),
+    totalUnits: z
+      .number()
+      .min(1)
+      .max(10000000000)
+      .nullable()
+      .optional()
+      .openapi({ example: 5200 }),
+    yield: z
+      .number()
+      .min(0.01)
+      .max(10000000000)
+      .nullable()
+      .optional()
+      .openapi({ example: 1200 }),
+    duration: z
+      .number()
+      .min(1)
+      .max(1000)
+      .nullable()
+      .optional()
+      .openapi({ example: 1 }),
+    durationType: z
+      .nativeEnum(DurationType)
+      .nullable()
+      .optional()
+      .openapi({ example: DurationType.DAY }),
+    template: z
+      .nativeEnum(AssetTemplateType)
+      .default(AssetTemplateType.STANDARD)
+      .openapi({ example: AssetTemplateType.STANDARD })
+      .nullable()
+      .optional(),
+    tiers: z.array(z.number().positive()).nullable().optional(),
+  }),
+);
 export type PatchOffering = z.infer<typeof PatchOffering>;
 
-export const PostComplianceOffering = PatchOffering.merge(
+export const PostComplianceOffering = PatchOfferingBase.merge(
   z.object({
     accountId: accountIdSchema,
+    managedBy: z.nativeEnum(ManagedByType).optional(),
+    assetName: z.string().min(2).max(50).openapi({ example: 'Asset name' }),
+    assetType: z.nativeEnum(AssetType).openapi({ example: AssetType.STOCK }),
+    pricePerUnit: z
+      .number()
+      .min(0.01)
+      .max(10000000000)
+      .nullable()
+      .openapi({ example: 2000 }),
+    totalUnits: z
+      .number()
+      .min(1)
+      .max(10000000000)
+      .nullable()
+      .openapi({ example: 5200 }),
+    yield: z
+      .number()
+      .min(0.01)
+      .max(10000000000)
+      .nullable()
+      .optional()
+      .openapi({ example: 1200 }),
+    duration: z
+      .number()
+      .min(1)
+      .max(1000)
+      .nullable()
+      .optional()
+      .openapi({ example: 1 }),
+    durationType: z
+      .nativeEnum(DurationType)
+      .nullable()
+      .optional()
+      .openapi({ example: DurationType.DAY }),
+    template: z
+      .nativeEnum(AssetTemplateType)
+      .default(AssetTemplateType.STANDARD)
+      .openapi({ example: AssetTemplateType.STANDARD }),
+    tiers: z.array(z.number().positive()).nullable().optional(),
   }),
-).extend({
-  managedBy: z.nativeEnum(ManagedByType).optional(),
-});
+).superRefine(postAssetRefinement);
 export type PostComplianceOffering = z.infer<typeof PostComplianceOffering>;
 
 export const offeringsInclude = z.enum([
@@ -546,11 +639,9 @@ export type PaginatedPendingOfferingSummaryResponse = z.infer<
 >;
 
 export type OfferingUpdateFields = {
-  platform?: string;
-  platformSettings?: string | null;
   managedBy?: ManagedByType | null;
-  enabled?: boolean;
   showTotalRaised?: boolean;
+  enabled?: boolean;
 };
 
 export const ReviewOfferingOnboarding = z.object({

package/common/types/trade.types.ts

@@ -55,8 +55,71 @@ import {
 } from './secondary-trade.types';
 import { InvestorAccount } from '../../investor-accounts/entities/investor-account.entity';
 import { Trade } from '../../trades/entities/trade.entity';
+import { fileIdSchema } from './file.types';
 
 extendZodWithOpenApi(z);
+
+// Zod schemas for attach subdoc endpoints
+export const PostAttachSubdocBody = z.object({
+  lineItemId: tradeLineItemIdSchema.openapi({
+    example: 'trade_line_item_01kctsycw3fq7sj6hedvy62cja',
+  }),
+  fileId: z
+    .lazy(() => fileIdSchema)
+    .openapi({ example: 'file_01je6ht4b8fbmttkzh2hs82xqp' }),
+  primarySignatureStatus: z
+    .nativeEnum(SignatureStatus)
+    .openapi({ example: 'SIGNED' }),
+  secondarySignatureStatus: z
+    .nativeEnum(SignatureStatus)
+    .optional()
+    .openapi({ example: 'SIGNED' }),
+});
+export type PostAttachSubdocBody = z.infer<typeof PostAttachSubdocBody>;
+
+export const PutAttachSubdocBody = z.object({
+  lineItemId: tradeLineItemIdSchema
+    .optional()
+    .openapi({ example: 'trade_line_item_01kctsycw3fq7sj6hedvy62cja' }),
+  fileId: z
+    .lazy(() => fileIdSchema)
+    .optional()
+    .openapi({ example: 'file_01je6ht4b8fbmttkzh2hs82xqp' }),
+  primarySignatureStatus: z
+    .nativeEnum(SignatureStatus)
+    .optional()
+    .openapi({ example: 'SIGNED' }),
+  secondarySignatureStatus: z
+    .nativeEnum(SignatureStatus)
+    .optional()
+    .openapi({ example: 'SIGNED' }),
+});
+export type PutAttachSubdocBody = z.infer<typeof PutAttachSubdocBody>;
+
+export const PatchSubdocSignatureBody = z.object({
+  lineItemId: tradeLineItemIdSchema.optional().openapi({
+    example: 'trade_line_item_01kctsycw3fq7sj6hedvy62cja',
+    description:
+      'Optional. If not provided, updates the first line item with an attached subdoc. Required for trades with multiple line items.',
+  }),
+  primarySignatureStatus: z.nativeEnum(SignatureStatus).optional().openapi({
+    example: 'SIGNED',
+    description: 'Primary signer signature status',
+  }),
+  secondarySignatureStatus: z.nativeEnum(SignatureStatus).optional().openapi({
+    example: 'SIGNED',
+    description:
+      'Secondary signer signature status. Only applicable for JOINT investor accounts.',
+  }),
+});
+export type PatchSubdocSignatureBody = z.infer<typeof PatchSubdocSignatureBody>;
+
+export const AttachSubdocResponse = z.object({
+  success: z.boolean(),
+  message: z.string(),
+});
+export type AttachSubdocResponse = z.infer<typeof AttachSubdocResponse>;
+
 export const CheckResultsSchema = z.object({
   fundingStatus: z.boolean(),
   agreementStatus: z.boolean(),
@@ -202,6 +265,13 @@ export const PatchSaLogSchema = z.object({
 
 export type PatchSaLogSchema = z.infer<typeof PatchSaLogSchema>;
 
+export const TradeBalanceResultZod = z.object({
+  tradeAdjustments: z.number().multipleOf(0.01),
+  chargedAmount: z.number().multipleOf(0.01),
+  balance: z.number().multipleOf(0.01),
+});
+export type TradeBalanceResultZod = z.infer<typeof TradeBalanceResultZod>;
+
 export const TradeZod = IBaseEntity.extend({
   investorAccountId: z.lazy(() => investorAccountIdSchema.nullable()),
   accountId: accountIdSchema.nullable(),

package/contracts/clients/cart/index.ts

@@ -0,0 +1,60 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  BadRequestError,
+  InternalError,
+  TradeZod,
+  userIdSchema,
+  tradeIdSchema,
+} from '../../../common/types';
+import { PatchCartBody } from '../../../common/types/cart.types';
+
+const c = initContract();
+
+export const cartContract = c.router(
+  {
+    getTradeCart: {
+      summary: 'Get carts (Trade.status = CART)',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchCart: {
+      summary: 'Patch a cart',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: PatchCartBody,
+      responses: {
+        200: TradeZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'carts',
+  },
+);

package/contracts/clients/index.ts

@@ -3,6 +3,7 @@ import { accountsContract } from './accounts';
 import { apiKeysContract } from './api-keys';
 import { clientApiKeyLogsContract } from './api-key-logs';
 import { assetsContract } from './assets';
+import { cartContract } from './cart';
 import { filesContract } from './files';
 import { individualsContract } from './individuals';
 import { investorAccountsContract } from './investor-accounts';
@@ -15,6 +16,9 @@ import { secureRequestContract } from './secure-requests';
 import { aicContract } from './aic';
 import { authContract } from './auth';
 import { sitesContract } from './sites';
+import { paymentMethodsContract } from './payment-methods';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { tradeLineItemsContract } from './trade-line-items';
 
 const c = initContract();
 
@@ -27,15 +31,19 @@ export const clientsContract = c.router(
     apiKeys: apiKeysContract,
     apiKeyLogs: clientApiKeyLogsContract,
     assets: assetsContract,
+    cart: cartContract,
     files: filesContract,
     filesPublic: filesPublicContract,
     individuals: individualsContract,
     investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
     issuers: issuersContract,
     legalEntities: legalEntityContract,
     offerings: offeringsContract,
+    paymentMethods: paymentMethodsContract,
     secureRequests: secureRequestContract,
     sites: sitesContract,
+    tradeLineItems: tradeLineItemsContract,
     trades: tradesContract,
   },
   {

package/contracts/clients/issuer-payment-methods/index.ts

@@ -0,0 +1,39 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IPaginatedIssuerPaymentMethod,
+  IssuerPaymentMethodsIncludeQuery,
+  PaginationOptionsZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerPaymentMethodsContract = c.router(
+  {
+    getIssuerPaymentMethods: {
+      summary: 'Get issuer payment methods',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(
+        IssuerPaymentMethodsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/clients/payment-methods/index.ts

@@ -0,0 +1,85 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  userIdSchema,
+  BadRequestError,
+  InternalError,
+} from '../../../common/types';
+import {
+  PaymentMethodResponseArray,
+  PaymentMethodResponse,
+  PostPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
+} from '../../../common/types/payment-methods.types';
+
+const c = initContract();
+
+export const paymentMethodsContract = c.router(
+  {
+    getPaymentMethods: {
+      summary: 'Get payment methods for a user',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: PaymentMethodResponseArray,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createPaymentMethod: {
+      summary: 'Create payment method for a user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSetupIntent: {
+      summary: 'Create payment method setup intent for a user',
+      method: 'POST',
+      path: '/intent',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostSetupIntentBody,
+      responses: {
+        201: SetupIntentResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'payment-methods',
+  },
+);

package/contracts/clients/trade-line-items/index.ts

@@ -0,0 +1,66 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  userIdSchema,
+} from '../../../common/types';
+import {
+  PostTradeLineItem,
+  TradeLineItemParams,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+  TradeLineItemUpdate,
+} from '../../../common/types/trade-line-item.type';
+
+const c = initContract();
+
+export const tradeLineItemsContract = c.router(
+  {
+    postTradeLineItem: {
+      summary: 'Create Trade Line Item',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeLineItem,
+      query: TradeLineItemQuery.merge(
+        z.object({
+          userId: userIdSchema,
+        }),
+      ),
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateTradeLineItem: {
+      summary: 'Update Trade Line Item - Can delete if you pass quantity = 0',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: TradeLineItemParams,
+      body: TradeLineItemUpdate,
+      responses: {
+        200: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+        400: BadRequestError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trade-line-items',
+  },
+);

package/contracts/clients/trades/index.ts

@@ -16,6 +16,10 @@ import {
   tradeIdOrTidSchema,
   TradesIncludeQuery,
   TradeZod,
+  PostAttachSubdocBody,
+  PutAttachSubdocBody,
+  PatchSubdocSignatureBody,
+  AttachSubdocResponse,
 } from '../../../common/types/trade.types';
 import { z } from 'zod';
 import {
@@ -115,6 +119,66 @@ export const tradesContract = c.router(
         500: InternalError,
       },
     },
+    postAttachSubdoc: {
+      summary: 'Attach subdoc to trade',
+      method: 'POST',
+      path: '/:id/attach-subdoc',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PostAttachSubdocBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    putAttachSubdoc: {
+      summary: 'Update attached subdoc for trade',
+      method: 'PUT',
+      path: '/:id/attach-subdoc',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PutAttachSubdocBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchSubdocSign: {
+      summary: 'Update subdoc signature statuses for trade',
+      method: 'PATCH',
+      path: '/:id/sign',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PatchSubdocSignatureBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'trades',

package/contracts/investors/individuals/index.ts

@@ -14,6 +14,8 @@ import {
   IIndividualZod,
   BadRequestError,
   InternalError,
+  IWillDoItLaterBodySchema,
+  IWillDoItLaterResponseSchema,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -92,6 +94,26 @@ export const individualsContract = c.router(
         403: ForbiddenError,
       },
     },
+    iWillDoItLater: {
+      summary: "I'll do it later - Create a task for later completion",
+      method: 'POST',
+      path: '/:id/defer',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      body: IWillDoItLaterBodySchema,
+      responses: {
+        201: IWillDoItLaterResponseSchema,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'individuals',

package/contracts/issuers/disbursements/index.ts

@@ -19,7 +19,9 @@ import {
   DisbursementsMissingConfigQuery,
   DisbursementSummaryZod,
   DisbursementZod,
+  EligibleOfferingsFiltersZod,
   IPaginatedDisbursement,
+  IPaginatedEligibleOffering,
   PostDisbursementBalanceZod,
   PostDisbursementSummaryZod,
   PostDisbursementZod,
@@ -146,6 +148,22 @@ export const disbursementsContract = c.router(
         500: InternalError,
       },
     },
+    getEligibleOfferings: {
+      summary: 'Get eligible offerings for disbursement',
+      method: 'GET',
+      path: '/eligible-offerings',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(EligibleOfferingsFiltersZod),
+      responses: {
+        200: IPaginatedEligibleOffering,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'disbursements',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmore/api-contracts",
-  "version": "0.0.0-dev.2dc8e92",
+  "version": "0.0.0-dev.4eac826",
   "description": "Type-safe API contracts for Dalmore Client Portal",
   "main": "./contracts/index.ts",
   "types": "./contracts/index.ts",