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

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

@@ -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/individuals.types.ts

@@ -12,9 +12,7 @@ import {
   InvestorAccountType,
   SetupStatusType,
   SetupStepType,
-  ComplianceReview,
   RetirementAccountType,
-  TradeStatus,
   EmploymentStatus,
   SourceOfIncome,
   AMLProvider,
@@ -60,8 +58,8 @@ export enum aicQuestionnaireQuestionType {
 }
 
 export enum FilterBy {
-  TRADE = 'TRADE',
-  INVESTOR = 'INVESTOR',
+  ALL = 'ALL',
+  PENDING_TRADES = 'PENDING_TRADES',
 }
 
 export const aicQuestionnaireQuestion = z.object({
@@ -243,17 +241,6 @@ export const IndividualFiltersZod = z.object({
 
 export const ComplianceIndividualFiltersZod = IndividualFiltersZod.extend({
   filterBy: z.nativeEnum(FilterBy).optional(),
-  tradeStatus: z.nativeEnum(TradeStatus).optional(),
-  complianceReview: z.nativeEnum(ComplianceReview).optional(),
-  hasPendingTrades: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
 });
 
 /**

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

@@ -168,6 +168,7 @@ export const PostIssuerOffering = z
       .default(AssetTemplateType.STANDARD)
       .openapi({ example: AssetTemplateType.STANDARD }),
     tiers: z.array(z.number().positive()).nullable().optional(),
+    enableBonus: z.boolean().default(false).optional(),
   })
   .superRefine((data, ctx) => {
     // Check if both values are present, and if so, ensure minInvestment is less than maxInvestment
@@ -299,6 +300,7 @@ export const PatchIssuerOffering = z.object({
     .optional(),
   tiers: z.array(z.number().positive()).nullable().optional(),
   enabled: z.boolean().optional(),
+  enableBonus: 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

@@ -230,6 +230,7 @@ export const PatchOffering = PatchOfferingBase.merge(
       .nullable()
       .optional(),
     tiers: z.array(z.number().positive()).nullable().optional(),
+    enableBonus: z.boolean().optional(),
   }),
 );
 export type PatchOffering = z.infer<typeof PatchOffering>;
@@ -276,6 +277,7 @@ export const PostComplianceOffering = PatchOfferingBase.merge(
       .default(AssetTemplateType.STANDARD)
       .openapi({ example: AssetTemplateType.STANDARD }),
     tiers: z.array(z.number().positive()).nullable().optional(),
+    enableBonus: z.boolean().default(false).optional(),
   }),
 ).superRefine(postAssetRefinement);
 export type PostComplianceOffering = z.infer<typeof PostComplianceOffering>;

package/contracts/clients/index.ts

@@ -16,6 +16,8 @@ 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();
@@ -34,9 +36,11 @@ export const clientsContract = c.router(
     filesPublic: filesPublicContract,
     individuals: individualsContract,
     investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
     issuers: issuersContract,
     legalEntities: legalEntityContract,
     offerings: offeringsContract,
+    paymentMethods: paymentMethodsContract,
     secureRequests: secureRequestContract,
     sites: sitesContract,
     tradeLineItems: tradeLineItemsContract,

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/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

@@ -17,9 +17,13 @@ import {
   DisbursementMissingConfigZod,
   DisbursementsIncludeQuery,
   DisbursementsMissingConfigQuery,
+  DisbursementPreviewZod,
   DisbursementSummaryZod,
   DisbursementZod,
+  GetDisbursementPreviewQueryZod,
+  EligibleOfferingsFiltersZod,
   IPaginatedDisbursement,
+  IPaginatedEligibleOffering,
   PostDisbursementBalanceZod,
   PostDisbursementSummaryZod,
   PostDisbursementZod,
@@ -146,6 +150,38 @@ export const disbursementsContract = c.router(
         500: InternalError,
       },
     },
+    getDisbursementPreview: {
+      summary: 'Get disbursement preview data for Step 2',
+      method: 'GET',
+      path: '/preview',
+      metadata: {
+        auth: true,
+      },
+      query: GetDisbursementPreviewQueryZod,
+      responses: {
+        200: DisbursementPreviewZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        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.d07da18",
+  "version": "0.0.0-dev.eb820f7",
   "description": "Type-safe API contracts for Dalmore Client Portal",
   "main": "./contracts/index.ts",
   "types": "./contracts/index.ts",