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

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

@@ -0,0 +1,31 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.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>;

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

@@ -145,3 +145,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) => {
@@ -309,6 +312,97 @@ export const DisbursementSummaryZod = z.object({
 });
 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(),

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,6 +194,10 @@ 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)
@@ -299,6 +305,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 +375,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/notification.types.ts

@@ -1,58 +1,268 @@
 import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { z } from 'zod';
 import { TypeID } from 'typeid-js';
-import { accountIdSchema } from './account.types';
+import { IBaseEntity } from './entity.types';
 
 extendZodWithOpenApi(z);
-export enum NotificationChannel {
+
+export enum NotificationChannelType {
   EMAIL = 'EMAIL',
   SLACK = 'SLACK',
+  WEBHOOK = 'WEBHOOK',
 }
-export enum NotificationType {
-  COMPLIANCE_TRADE_ALERT = 'COMPLIANCE_TRADE_ALERT',
-  TRADE_ALERT = 'TRADE_ALERT',
+
+export enum NotificationRecordStatus {
+  PENDING = 'PENDING',
+  SENT = 'SENT',
+  FAILED = 'FAILED',
 }
 
-export const notificationIdSchema = z.string().refine(
+export const notificationChannelIdSchema = z.string().refine(
   (value) => {
     try {
       const tid = TypeID.fromString(value);
-      return tid.getType() === 'notification';
+      return tid.getType() === 'notification_channel';
     } catch {
       return false;
     }
   },
   {
     message:
-      'Invalid notification ID format. Must be a valid TypeID with "notification" prefix.',
+      'Invalid notification channel ID format. Must be a valid TypeID with "notification_channel" prefix.',
   },
 );
 
-export const SendNotificationZod = z.object({
-  message: z.string(),
+export const notificationChannelTriggerIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'notification_channel_trigger';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid notification channel trigger ID format. Must be a valid TypeID with "notification_channel_trigger" prefix.',
+  },
+);
+
+export const notificationRecordIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'notification_record';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid notification record ID format. Must be a valid TypeID with "notification_record" prefix.',
+  },
+);
+
+export const EmailChannelSettingsSchema = z.object({
+  recipients: z.array(z.string().email()).min(1),
+  subjectTemplate: z.string().optional(),
+});
+export type EmailChannelSettings = z.infer<typeof EmailChannelSettingsSchema>;
+
+export const SlackChannelSettingsSchema = z
+  .object({
+    webhookUrl: z.string().url().optional(),
+    channelEmail: z.string().email().optional(),
+  })
+  .refine((data) => data.webhookUrl || data.channelEmail, {
+    message: 'Either webhookUrl or channelEmail is required',
+  });
+export type SlackChannelSettings = z.infer<typeof SlackChannelSettingsSchema>;
+
+export const WebhookChannelSettingsSchema = z.object({
+  url: z.string().url(),
+  method: z.enum(['POST', 'PUT']),
+  headers: z.record(z.string()).optional(),
+  authType: z.enum(['none', 'bearer', 'basic', 'api_key']).default('none'),
+  authValue: z.string().optional(),
+});
+export type WebhookChannelSettings = z.infer<
+  typeof WebhookChannelSettingsSchema
+>;
+
+export const NotificationChannelSettingsSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(NotificationChannelType.EMAIL),
+    config: EmailChannelSettingsSchema,
+  }),
+  z.object({
+    type: z.literal(NotificationChannelType.SLACK),
+    config: SlackChannelSettingsSchema,
+  }),
+  z.object({
+    type: z.literal(NotificationChannelType.WEBHOOK),
+    config: WebhookChannelSettingsSchema,
+  }),
+]);
+export type NotificationChannelSettings = z.infer<
+  typeof NotificationChannelSettingsSchema
+>;
+
+export const EmailNotificationPayloadSchema = z.object({
+  to: z.array(z.string().email()),
   subject: z.string(),
-  buttonText: z.string(),
-  link: z.string(),
-  debug: z.boolean().default(false),
-  notificationChannel: z.nativeEnum(NotificationChannel),
-  channelName: z.string(),
-  channelEmail: z.string().email(),
-  notificationType: z.nativeEnum(NotificationType),
+  body: z.string(),
+  html: z.string().optional(),
 });
-export type SendNotificationZod = z.infer<typeof SendNotificationZod>;
+export type EmailNotificationPayload = z.infer<
+  typeof EmailNotificationPayloadSchema
+>;
 
-const SlackSettingsSchema = z.object({
-  channelName: z.string().min(1).max(50),
-  channelEmail: z.string().email(),
+export const SlackNotificationPayloadSchema = z.object({
+  webhookUrl: z.string().url().optional(),
+  channelEmail: z.string().email().optional(),
+  message: z.string(),
+  blocks: z.array(z.record(z.unknown())).optional(),
 });
+export type SlackNotificationPayload = z.infer<
+  typeof SlackNotificationPayloadSchema
+>;
 
-export const PostNotificationZod = z.object({
-  accountId: accountIdSchema,
-  notificationChannel: z.literal(NotificationChannel.SLACK), // Only Slack for now
-  notificationType: z.nativeEnum(NotificationType),
-  enabled: z.boolean().default(true),
-  debug: z.boolean().default(false),
-  settings: SlackSettingsSchema,
+export const WebhookNotificationPayloadSchema = z.object({
+  url: z.string().url(),
+  method: z.enum(['POST', 'PUT']),
+  headers: z.record(z.string()),
+  body: z.record(z.unknown()),
 });
+export type WebhookNotificationPayload = z.infer<
+  typeof WebhookNotificationPayloadSchema
+>;
+
+export const NotificationPayloadSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(NotificationChannelType.EMAIL),
+    data: EmailNotificationPayloadSchema,
+  }),
+  z.object({
+    type: z.literal(NotificationChannelType.SLACK),
+    data: SlackNotificationPayloadSchema,
+  }),
+  z.object({
+    type: z.literal(NotificationChannelType.WEBHOOK),
+    data: WebhookNotificationPayloadSchema,
+  }),
+]);
+export type NotificationPayload = z.infer<typeof NotificationPayloadSchema>;
 
-export type PostNotificationZod = z.infer<typeof PostNotificationZod>;
+export const EmailNotificationResponseSchema = z.object({
+  messageId: z.string().optional(),
+  accepted: z.array(z.string()).optional(),
+  rejected: z.array(z.string()).optional(),
+});
+export type EmailNotificationResponse = z.infer<
+  typeof EmailNotificationResponseSchema
+>;
+
+export const SlackNotificationResponseSchema = z.object({
+  ok: z.boolean().optional(),
+  error: z.string().optional(),
+  responseBody: z.string().optional(),
+});
+export type SlackNotificationResponse = z.infer<
+  typeof SlackNotificationResponseSchema
+>;
+
+export const WebhookNotificationResponseSchema = z.object({
+  statusCode: z.number(),
+  headers: z.record(z.string()).optional(),
+  body: z.unknown().optional(),
+});
+export type WebhookNotificationResponse = z.infer<
+  typeof WebhookNotificationResponseSchema
+>;
+
+export const NotificationResponseSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(NotificationChannelType.EMAIL),
+    data: EmailNotificationResponseSchema,
+  }),
+  z.object({
+    type: z.literal(NotificationChannelType.SLACK),
+    data: SlackNotificationResponseSchema,
+  }),
+  z.object({
+    type: z.literal(NotificationChannelType.WEBHOOK),
+    data: WebhookNotificationResponseSchema,
+  }),
+]);
+export type NotificationResponse = z.infer<typeof NotificationResponseSchema>;
+
+export const INotificationChannelZod = IBaseEntity.extend({
+  id: notificationChannelIdSchema.openapi({
+    example: 'notification_channel_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  accountSettingsId: z.string().openapi({
+    example: 'account_setting_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  channelType: z.nativeEnum(NotificationChannelType).openapi({
+    example: NotificationChannelType.SLACK,
+  }),
+  name: z.string().openapi({
+    example: 'Compliance Alerts',
+  }),
+  enabled: z.boolean().openapi({
+    example: true,
+  }),
+  settings: NotificationChannelSettingsSchema,
+});
+export type INotificationChannelZod = z.infer<typeof INotificationChannelZod>;
+
+export const INotificationChannelTriggerZod = IBaseEntity.extend({
+  id: notificationChannelTriggerIdSchema.openapi({
+    example: 'notification_channel_trigger_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  notificationChannelId: notificationChannelIdSchema.openapi({
+    example: 'notification_channel_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  activityTypeId: z.string().openapi({
+    example: 'activity_type_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  enabled: z.boolean().openapi({
+    example: true,
+  }),
+});
+export type INotificationChannelTriggerZod = z.infer<
+  typeof INotificationChannelTriggerZod
+>;
+
+export const INotificationRecordZod = IBaseEntity.extend({
+  id: notificationRecordIdSchema.openapi({
+    example: 'notification_record_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  notificationChannelId: notificationChannelIdSchema.openapi({
+    example: 'notification_channel_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  activityId: z.string().nullable().openapi({
+    example: 'activity_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  targetTable: z.string().openapi({
+    example: 'trades',
+  }),
+  targetId: z.string().openapi({
+    example: 'trade_01j5y5ghx8fvc83dmx3pznq7hv',
+  }),
+  status: z.nativeEnum(NotificationRecordStatus).openapi({
+    example: NotificationRecordStatus.SENT,
+  }),
+  payload: NotificationPayloadSchema,
+  response: NotificationResponseSchema.nullable(),
+  errorMessage: z.string().nullable().openapi({
+    example: null,
+  }),
+  retryCount: z.number().openapi({
+    example: 0,
+  }),
+  sentAt: z.date().nullable().openapi({
+    example: new Date(),
+  }),
+});
+export type INotificationRecordZod = z.infer<typeof INotificationRecordZod>;

package/common/types/offering.types.ts

@@ -17,6 +17,7 @@ import {
   OfferingOnboardingStatus,
   AssetType,
   DurationType,
+  StringToBooleanSchema,
 } from './common.types';
 import { IBaseEntity } from './entity.types';
 import { fileIdSchema, FileZod } from './file.types';
@@ -230,6 +231,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 +278,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>;
@@ -344,15 +347,7 @@ export const OfferingFiltersZod = 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/site.types.ts

@@ -5,6 +5,7 @@ import {
   AccountStatus,
   AccountZod,
   IPaginationMeta,
+  StringToBooleanSchema,
   UrlSchema,
 } from './common.types';
 import { accountIdSchema } from './account.types';
@@ -73,15 +74,7 @@ export const SitesParamSchema = z.object({
 export const SitesFiltersZod = z.object({
   url: z.string().optional(),
   accountId: accountIdSchema.optional(),
-  enabled: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
+  enabled: StringToBooleanSchema.optional(),
 });
 
 const sitesInclude = z.enum(['account']);

package/common/types/{trade-line-item.type.ts → trade-line-item.types.ts}

@@ -8,6 +8,7 @@ import {
   IPaginationMeta,
   OfferingType,
   SignatureStatus,
+  StringToBooleanSchema,
 } from './common.types';
 import { fileIdSchema } from './file.types';
 import { accountIdSchema } from './account.types';
@@ -107,15 +108,7 @@ export type TradeLineItemQuery = z.infer<typeof TradeLineItemQuery>;
 
 export const TradeLineItemFiltersQuery = z.object({
   accountId: accountIdSchema.optional(),
-  hasSubdoc: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
+  hasSubdoc: StringToBooleanSchema.optional(),
   saStatus: z.nativeEnum(SignatureStatus).optional(),
   offeringId: z.lazy(() => offeringIdSchema).optional(),
   search: z.string().max(50).optional(),

package/common/types/trade.types.ts

@@ -39,7 +39,7 @@ import {
 import {
   tradeLineItemIdSchema,
   TradeLineItemZod,
-} from './trade-line-item.type';
+} from './trade-line-item.types';
 import { TradeAdjustmentZod } from './trade-adjustment.type';
 import { TransactionZod } from './transaction.types';
 import { accountIdSchema } from './account.types';

package/common/types/transaction.types.ts

@@ -1,10 +1,11 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { TypeID } from 'typeid-js';
 import {
   dateSchema,
   InvestorAccountType,
   numberPrecisionSchema,
 } from './common.types';
-import { z } from 'zod';
 import { IBaseEntity } from './entity.types';
 import { accountIdSchema } from './account.types';
 import {
@@ -18,7 +19,9 @@ import {
   investorAccountIdSchema,
 } from './investor-account.types';
 import { TransactionStatus, TransactionType } from './common.types';
+import { userIdSchema } from './user.types';
 export { TransactionStatus, TransactionType };
+extendZodWithOpenApi(z);
 
 export enum RefundPaymentMethod {
   CHECK = 'CHECK',
@@ -115,6 +118,14 @@ export type InvestorPostTransactionZod = z.infer<
   typeof InvestorPostTransactionZod
 >;
 
+export const ClientPostTransactionZod = InvestorPostTransactionZod.extend({
+  userId: z
+    .lazy(() => userIdSchema)
+    .openapi({ example: 'user_01j5y5ghx5fg68d663j1fvy2x7' }),
+});
+
+export type ClientPostTransactionZod = z.infer<typeof ClientPostTransactionZod>;
+
 export const refundTransactionIdSchema = z.string().refine(
   (value) => {
     try {

package/common/types/user.types.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import {
   AccountStatus,
   AccountWithoutUsersZod,
@@ -7,12 +8,11 @@ import {
   ManagedByType,
   OfferingType,
   PortalType,
+  StringToBooleanSchema,
   UserRole,
-  UserStatus,
   UserType,
 } from './common.types';
 import { dateOrString, IBaseEntity } from './entity.types';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { PhoneZodSchema } from './phone.type';
 import { IInvestorAccount } from './investor-account.types';
 import { TradeZod } from './trade.types';
@@ -51,6 +51,11 @@ export const UserDeleteResponse = z.object({
 });
 export type UserDeleteResponse = z.infer<typeof UserDeleteResponse>;
 
+export const UserRestoreResponse = z.object({
+  message: z.string(),
+});
+export type UserRestoreResponse = z.infer<typeof UserRestoreResponse>;
+
 export const GetMeResponse = IBaseEntity.extend({
   accountId: z.string().nullable(),
   accountName: z.string().nullable(),
@@ -59,7 +64,7 @@ export const GetMeResponse = IBaseEntity.extend({
   email: z.string().email(),
   provider: z.string(),
   active: z.boolean(),
-  status: z.lazy(() => z.nativeEnum(UserStatus)),
+  locked: z.boolean(),
   lastLoginAt: dateOrString.nullable(),
   loginCount: z.number(),
   role: z.string(),
@@ -157,7 +162,7 @@ export const UserZod = IBaseEntity.extend({
   onboarding: z.string().nullable(),
   account: AccountWithoutUsersZod.optional(),
   active: z.boolean(),
-  status: z.nativeEnum(UserStatus),
+  locked: z.boolean(),
   userLogin: IBaseEntity.extend({
     firstName: z.string(),
     lastName: z.string(),
@@ -179,27 +184,9 @@ export const UserFiltersZod = z.object({
   search: z.string().max(50).optional(),
   role: z.nativeEnum(UserRole).optional(),
   portal: z.string().optional(),
-  status: z.nativeEnum(UserStatus).optional(),
-  active: z
-    .string()
-    .optional()
-    .refine((v) => !v || v === 'true' || v === 'false', {
-      message: 'active must be a boolean string',
-    })
-    .transform((v) => {
-      if (!v) return undefined;
-      return v === 'true';
-    }),
-  twoFactorEnabled: z
-    .string()
-    .optional()
-    .refine((v) => !v || v === 'true' || v === 'false', {
-      message: 'twoFactorEnabled must be a boolean string',
-    })
-    .transform((v) => {
-      if (!v) return undefined;
-      return v === 'true';
-    }),
+  locked: StringToBooleanSchema.optional(),
+  active: StringToBooleanSchema.optional(),
+  twoFactorEnabled: StringToBooleanSchema.optional(),
 });
 
 const usersInclude = z.enum(['account', 'role']);
@@ -274,7 +261,7 @@ export type IssuerUsersStatusUpdateResponse = z.infer<
 >;
 
 export const UpdateLockedStatus = z.object({
-  status: z.nativeEnum(UserStatus),
+  locked: z.boolean(),
 });
 
 export type UpdateLockedStatus = z.infer<typeof UpdateLockedStatus>;
@@ -285,7 +272,7 @@ export const UsersSummaryFilterZod = z.object({
   portalType: z.nativeEnum(PortalType).optional(),
   search: z.string().trim().max(50).optional(),
   selectRole: z.nativeEnum(UserRole).optional(),
-  status: z.nativeEnum(UserStatus).optional(),
+  locked: StringToBooleanSchema.optional(),
 });
 export type UsersSummaryFilterZod = z.infer<typeof UsersSummaryFilterZod>;
 
@@ -299,7 +286,7 @@ export const UsersSummaryZod = z.object({
   portalType: z.string(),
   loginCount: z.number().int(),
   lastLogin: z.date(),
-  status: z.nativeEnum(UserStatus),
+  locked: z.boolean(),
 });
 export type UsersSummaryZod = z.infer<typeof UsersSummaryZod>;
 

package/contracts/clients/cart/index.ts

@@ -10,7 +10,11 @@ import {
   userIdSchema,
   tradeIdSchema,
 } from '../../../common/types';
-import { PatchCartBody } from '../../../common/types/cart.types';
+import {
+  PatchCartBody,
+  ClientPlacetradeBody,
+  PlaceTradeResponse,
+} from '../../../common/types/cart.types';
 
 const c = initContract();
 
@@ -34,6 +38,22 @@ export const cartContract = c.router(
         500: InternalError,
       },
     },
+    postCheckout: {
+      summary: 'Place a trade (checkout button)',
+      method: 'POST',
+      path: '/checkout',
+      metadata: {
+        auth: true,
+      },
+      body: ClientPlacetradeBody,
+      responses: {
+        200: PlaceTradeResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
     patchCart: {
       summary: 'Patch a cart',
       method: 'PATCH',

package/contracts/clients/index.ts

@@ -19,6 +19,7 @@ import { sitesContract } from './sites';
 import { paymentMethodsContract } from './payment-methods';
 import { issuerPaymentMethodsContract } from './issuer-payment-methods';
 import { tradeLineItemsContract } from './trade-line-items';
+import { clientsTransactionsContract } from './transactions';
 
 const c = initContract();
 
@@ -45,6 +46,7 @@ export const clientsContract = c.router(
     sites: sitesContract,
     tradeLineItems: tradeLineItemsContract,
     trades: tradesContract,
+    transactions: clientsTransactionsContract,
   },
   {
     pathPrefix: '/clients/api/v1/',

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

@@ -14,7 +14,7 @@ import {
   TradeLineItemQuery,
   TradeLineItemResponse,
   TradeLineItemUpdate,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/clients/trades/index.ts

@@ -26,7 +26,7 @@ import {
   PostTradeLineItem,
   TradeLineItemQuery,
   TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/clients/transactions/index.ts

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ClientPostTransactionZod,
+  TransactionZod,
+} from '../../../common/types/transaction.types';
+
+const c = initContract();
+
+export const clientsTransactionsContract = c.router(
+  {
+    postTransaction: {
+      summary: 'Create a transaction',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: ClientPostTransactionZod,
+      responses: {
+        201: TransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'transactions',
+  },
+);

package/contracts/compliance/bonus-tiers/index.ts

@@ -10,6 +10,8 @@ import {
   EstimateBonusTierCalculationResponseZod,
   EstimateBonusTierCalculationZod,
   IBonusTierList,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -32,6 +34,23 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary:
+        '[ADMIN] Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
     postBonusTier: {
       summary: 'Create a new bonus tier',
       method: 'POST',

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

@@ -13,7 +13,7 @@ import {
   ReviewTradeLineItemStatus,
   TradeLineItemFiltersQuery,
   TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 import { z } from 'zod';
 const c = initContract();

package/contracts/compliance/users/index.ts

@@ -21,6 +21,7 @@ import {
   IssuersActiveStatusUpdateZod,
   UpdateLockedStatus,
   UpdateUserRoleZod,
+  UserRestoreResponse,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -143,6 +144,26 @@ export const usersContract = c.router(
         500: InternalError,
       },
     },
+    restoreUser: {
+      summary: 'Restore user by id',
+      method: 'POST',
+      path: '/:id/restore',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: UserRestoreResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
     updateActiveStatus: {
       summary: '[Admin] Update user active status',
       method: 'PATCH',

package/contracts/investors/bonus-tiers/index.ts

@@ -8,6 +8,8 @@ import {
 import {
   EstimateBonusTierCalculationResponseZod,
   EstimateBonusTierCalculationZod,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -30,6 +32,22 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary: 'Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'bonus-tiers',

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

@@ -13,7 +13,7 @@ import {
   TradeLineItemResponse,
   TradeLineItemUpdate,
   TradeLineItemSignStatusUpdate,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/issuers/bonus-tiers/index.ts

@@ -10,6 +10,8 @@ import {
   EstimateBonusTierCalculationZod,
   IBonusTierList,
   PostBonusTierZod,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -32,6 +34,22 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary: 'Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
     postBonusTier: {
       summary: 'Create a new bonus tier',
       method: 'POST',

package/contracts/issuers/disbursements/index.ts

@@ -17,8 +17,10 @@ import {
   DisbursementMissingConfigZod,
   DisbursementsIncludeQuery,
   DisbursementsMissingConfigQuery,
+  DisbursementPreviewZod,
   DisbursementSummaryZod,
   DisbursementZod,
+  GetDisbursementPreviewQueryZod,
   EligibleOfferingsFiltersZod,
   IPaginatedDisbursement,
   IPaginatedEligibleOffering,
@@ -148,6 +150,22 @@ 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',

package/package.json

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