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

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

@@ -111,6 +111,10 @@ export enum HttpMethod {
   OPTIONS = 'OPTIONS',
 }
 
+export enum UserStatus {
+  ACTIVE = 'ACTIVE',
+  LOCKED = 'LOCKED',
+}
 export const SENSITIVE_PATTERNS = [
   /password/i,
   /credit.*card/i,
@@ -200,11 +204,6 @@ export enum UserType {
   DEMO = 'DEMO',
 }
 
-export enum UserStatus {
-  ACTIVE = 'ACTIVE',
-  LOCKED = 'LOCKED',
-}
-
 export enum UserRole {
   API_KEY = 'API_KEY',
   IMPORT = 'IMPORT',
@@ -306,7 +305,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(),
@@ -1518,3 +1517,14 @@ 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>;

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

@@ -10,6 +10,7 @@ import {
   ComplianceReview,
   DurationType,
   AssetType,
+  StringToBooleanSchema,
 } from './common.types';
 import { IBaseEntity } from './entity.types';
 import { IIssuer, issuerIdSchema } from './issuer.types';
@@ -168,6 +169,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
@@ -192,38 +194,39 @@ export const PatchIssuerOffering = z.object({
     .max(100)
     .optional()
     .openapi({ example: 'Airbnb IPO' }),
+  type: z
+    .nativeEnum(OfferingType)
+    .optional()
+    .openapi({ example: OfferingType.REG_D }),
   targetAmount: z
     .number()
     .min(0)
     .max(10000000000)
     .optional()
     .openapi({ example: 120000 }),
-  raiseAmount: z
-    .number()
-    .min(0)
-    .max(10000000000)
-    .optional()
-    .openapi({ example: 200000 }),
   minInvestment: z
     .number()
     .min(0)
     .max(10000000000)
+    .nullable()
     .optional()
     .openapi({ example: 1000 }),
   maxInvestment: z
     .number()
     .min(0)
     .max(10000000000)
+    .nullable()
     .optional()
     .openapi({ example: 20000 }),
   contingencyAmount: z
     .number()
     .min(0)
     .max(10000000000)
+    .nullable()
     .optional()
     .openapi({ example: 5000 }),
-  startAt: dateSchema.optional().openapi({ example: '10/20/2024' }),
-  endAt: dateSchema.optional().openapi({ example: '10/27/2024' }),
+  startAt: dateSchema.nullable().optional().openapi({ example: '10/20/2024' }),
+  endAt: dateSchema.nullable().optional().openapi({ example: '10/27/2024' }),
   cancellationPeriod: z
     .number()
     .min(1)
@@ -299,6 +302,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>;
 
@@ -368,15 +372,7 @@ export const IssuerOfferingsFilterZod = z.object({
   issuerId: z.lazy(() => issuerIdSchema).optional(),
   type: z.nativeEnum(OfferingType).optional(),
   status: z.nativeEnum(ComplianceReview).optional(),
-  enabled: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
+  enabled: StringToBooleanSchema.optional(),
   managedBy: z.nativeEnum(ManagedByType).optional(),
   versioningType: z.nativeEnum(OfferingVersioningType).optional(),
   combinedStatus: z.nativeEnum(OfferingStatus).optional(),

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 }),