@dalmore/api-contracts 1.0.0

package/common/types/trade.types.ts

@@ -0,0 +1,849 @@
+import { z } from 'zod';
+import {
+  InvestmentType,
+  IPaginationMeta,
+  FundingStatus,
+  TxnCheck,
+  PaginationOptionsZod,
+  dateSchema,
+  BaseStatus,
+  ComplianceReview,
+  OfferingType,
+  ManagedByType,
+  SignatureStatus,
+  TradeType,
+  TradeStatus,
+  SortOrder,
+  SortBy,
+  AicStatus,
+  AMLStatus,
+  KYCStatus,
+  createDateSchema,
+  AccountStatus,
+  SavedQuery,
+} from './common.types';
+import { offeringIdSchema } from './offering.types';
+import { IBaseEntity } from './entity.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import {
+  paymentMethodIdSchema,
+  PaymentMethodType,
+} from './payment-methods.types';
+import { investorAccountIdSchema } from './investor-account.types';
+import {
+  tradeLineItemIdSchema,
+  TradeLineItemZod,
+} from './trade-line-item.type';
+import { TradeAdjustmentZod } from './trade-adjustment.type';
+import { TransactionZod } from './transaction.types';
+import { accountIdSchema } from './account.types';
+import { userIdSchema } from './user.types';
+import { issuerIdSchema } from './issuer.types';
+
+extendZodWithOpenApi(z);
+export const CheckResultsSchema = z.object({
+  fundingStatus: z.boolean(),
+  agreementStatus: z.boolean(),
+  subscriptionAgreementCheck: z.boolean(),
+  kycStatus: z.boolean(),
+  sanctionsStatus: z.boolean(),
+  accreditationStatus: z.boolean(),
+  kybStatus: z.boolean(),
+});
+export type CheckResults = z.infer<typeof CheckResultsSchema>;
+
+export const TradeIdPrefix = 'trade';
+
+export const tradeIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === TradeIdPrefix;
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid trade ID format. Must be a valid TypeID with "trade" prefix. ex: trade_00041061050r3gg28a1c60t3gf',
+  },
+);
+
+export const tradeIdOrTidSchema = z.union([
+  z.string().refine(
+    (value) => {
+      try {
+        const tid = TypeID.fromString(value);
+        return tid.getType() === TradeIdPrefix;
+      } catch {
+        return false;
+      }
+    },
+    {
+      message:
+        'Invalid trade ID format. Must be a valid TypeID with "trade" prefix. ex: trade_00041061050r3gg28a1c60t3gf',
+    },
+  ),
+  z
+    .string()
+    .min(1)
+    .max(50)
+    .openapi({ example: 'tid_00041061050r3gg28a1c60t3gf' }),
+]);
+
+export enum SaStatus {
+  PENDING = BaseStatus.PENDING,
+  SIGNED = BaseStatus.SIGNED,
+  DECLINED = BaseStatus.DECLINED,
+  NEEDS_REVIEW = BaseStatus.NEEDS_REVIEW,
+}
+
+export enum TradeSystemLogType {
+  SUB_DOC_CHECK = 'Subscription Agreement Check',
+  ADDRESS_CHECK = 'Address Check',
+  COUNTRY_CHECK = 'Country Check',
+  CONCENTRATION_CHECK = 'Concentration Check',
+  KYC_CHECK = 'KYC Check',
+  AML_CHECK = 'AML Check',
+  AIC_CHECK = 'AIC Check',
+  // Data Integrity Checks For Imported Trades
+  SHARES_CHECK = 'Shares Check',
+  PRICE_PER_UNIT_CHECK = 'Price Per Unit Check',
+  ISSUER_CHECK = 'Issuer Check',
+  INVESTOR_CHECK = 'Investor Check',
+  OFFERING_CHECK = 'Offering Check',
+  ASSETS_CHECK = 'Assets Check',
+  INDIVIDUALS_CHECK = 'Individuals Check',
+}
+
+export enum SaCheck {
+  PENDING = BaseStatus.PENDING,
+  NEEDS_REVIEW = BaseStatus.NEEDS_REVIEW,
+  APPROVED = BaseStatus.APPROVED,
+  REJECTED = BaseStatus.REJECTED,
+}
+
+// cart NEEDS_INFO PLACED IN_REVIEW AWAITING_FUNDING CANCELLED SETTLED
+
+export enum SystemReviewCheck {
+  PENDING = BaseStatus.PENDING,
+  APPROVED = BaseStatus.APPROVED,
+  REJECTED = BaseStatus.REJECTED,
+  NEEDS_REVIEW = BaseStatus.NEEDS_REVIEW,
+  WARNING = BaseStatus.WARNING,
+  INCOMPLETE = BaseStatus.INCOMPLETE,
+}
+
+export enum Platforms {
+  DALMORE = 'DALMORE',
+  IMPORT = 'IMPORT',
+}
+
+export enum MatchResultStatus {
+  MATCHED = 'MATCHED',
+  UNMATCHED = 'UNMATCHED',
+}
+
+export enum TradeSystemReviewLogStatus {
+  PASSED = 'PASSED',
+  WARNING = 'WARNING',
+}
+
+export const matchResultSchema = z.object({
+  actual: z.string().min(1).max(200),
+  status: z.nativeEnum(MatchResultStatus),
+  extracted: z.string().min(1).max(200),
+  corrected: z.string().min(1).max(200).optional().nullable(),
+});
+export type matchResultSchema = z.infer<typeof matchResultSchema>;
+
+const saLogItemSchema = z.object({
+  tradeLineItemId: tradeLineItemIdSchema,
+  signerName: matchResultSchema.optional(),
+  totalAmount: matchResultSchema.optional(),
+  investorName: matchResultSchema.optional(),
+  numberOfShares: matchResultSchema.optional(),
+});
+
+export type saLogItemSchema = z.infer<typeof saLogItemSchema>;
+
+export const SaLogSchema = z.object({
+  finalStatus: z.nativeEnum(SaStatus),
+  matchResults: z.array(saLogItemSchema),
+});
+
+export type saLogSchema = z.infer<typeof SaLogSchema>;
+
+export const PatchSaLogSchema = z.object({
+  matchResults: z.array(saLogItemSchema),
+});
+
+export type PatchSaLogSchema = z.infer<typeof PatchSaLogSchema>;
+
+export const TradeZod = IBaseEntity.extend({
+  investorAccountId: z.lazy(() => investorAccountIdSchema.nullable()),
+  accountId: accountIdSchema.nullable(),
+  offeringId: z.lazy(() => offeringIdSchema.nullable()),
+  paymentMethodId: z.lazy(() => paymentMethodIdSchema).nullable(),
+  userId: z.lazy(() => userIdSchema.nullable()),
+  tradeNumber: z.string(),
+  ip: z.string().nullable(),
+  tid: z.string().nullable(),
+  investmentType: z.nativeEnum(InvestmentType),
+  numberOfShares: z.number().int(),
+  pricePerShare: z.number().multipleOf(0.01),
+  lineItems: z.array(z.lazy(() => TradeLineItemZod)),
+  adjustments: z.array(z.lazy(() => TradeAdjustmentZod)),
+  transactions: z.array(z.lazy(() => TransactionZod)),
+  totalAmount: z.number().multipleOf(0.01).nullable(),
+  tradeStatus: z.nativeEnum(TradeStatus),
+  tradeStatusUnmapped: z.string().nullable(),
+  tradeDate: z.date().nullable(),
+  saStatus: z.nativeEnum(SaStatus),
+  saStatusUnmapped: z.string().nullable(),
+  saUrl: z.string().nullable(),
+  saSignedAt: z.date().nullable(),
+  saExtractedNumberOfShares: z.string().nullable(),
+  saExtractedTotalAmount: z.string().nullable(),
+  saExtractedPricePerShare: z.string().nullable(),
+  saExtractedInvestorType: z.string().nullable(),
+  saExtractedSigner: z.string().nullable(),
+  saExtractedSignatureDate: z.date().nullable(),
+  saExtractedSigner2: z.string().nullable(),
+  saExtractedSignatureDate2: z.date().nullable(),
+  saCheck: z.nativeEnum(SaCheck),
+  saCheckedAt: z.date().nullable(),
+  saLog: SaLogSchema.nullable(),
+  txnTid: z.string().nullable(),
+  txnResponse: z.string().nullable(),
+  txnPaymentMethod: z.nativeEnum(PaymentMethodType).nullable(),
+  txnCurrencyCode: z.string().length(3).nullable(),
+  txnChargedAmount: z.number().multipleOf(0.01).nullable(),
+  txnDate: z.date().nullable(),
+  txnSettledDate: z.date().nullable(),
+  fundingStatus: z.nativeEnum(FundingStatus).nullable(),
+  fundingStatusUnmapped: z.string().nullable(),
+  txnCheck: z.nativeEnum(TxnCheck).nullable(),
+  txnCheckedAt: z.date().nullable(),
+  txnLog: z.string().nullable(),
+  systemReviewCheck: z.nativeEnum(SystemReviewCheck).nullable(),
+  systemReviewCheckedAt: z.date().nullable(),
+  systemReviewLog: z.string().nullable(),
+  complianceReview: z.nativeEnum(ComplianceReview).nullable(),
+  complianceReviewNotes: z.string().nullable(),
+  complianceReviewerId: z.string().nullable(),
+  issuerId: z.lazy(() => issuerIdSchema.nullable()),
+  complianceReviewName: z.string().nullable(),
+  complianceReviewAt: z.date().nullable(),
+  tradeType: z.nativeEnum(TradeType).nullable(),
+  placedAt: z.date().nullable(),
+  platform: z.string(),
+  cancelledAt: z.date().nullable(),
+  cancelledById: z.string().nullable(),
+  cancelledReason: z.string().nullable(),
+  cancellationPeriod: z.number().nullable(),
+  disbursed: z.boolean().optional(),
+  tradeAdjustments: z.number().nullable().optional(),
+  chargedAmount: z.number().nullable().optional(),
+  balance: z.number().nullable().optional(),
+  isUncleared24h: z.boolean(),
+});
+export type TradeZod = z.infer<typeof TradeZod>;
+
+export const IPaginatedTrade = z.object({
+  items: z.array(TradeZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedTrade = z.infer<typeof IPaginatedTrade>;
+
+export const IPaginatedReviewTrade = z.object({
+  totalCount: z.number().int(),
+  currentPosition: z.number().int(),
+  tradeIds: z.array(tradeIdSchema),
+});
+export type IPaginatedReviewTrade = z.infer<typeof IPaginatedReviewTrade>;
+
+export const TradeSummaryZod = z.object({
+  accountId: accountIdSchema,
+  accountName: z.string(),
+  regACount: z.number().int(),
+  regCfCount: z.number().int(),
+  regDCount: z.number().int(),
+  totalCount: z.number().int(),
+  totalReadyToApproveCount: z.number().int(),
+  regAReadyToApproveCount: z.number().int(),
+  regCfReadyToApproveCount: z.number().int(),
+  regDReadyToApproveCount: z.number().int(),
+});
+export type TradeSummaryZod = z.infer<typeof TradeSummaryZod>;
+
+export const IPaginatedTradeSummaryResponse = z.object({
+  items: z.array(TradeSummaryZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedTradeSummaryResponse = z.infer<
+  typeof IPaginatedTradeSummaryResponse
+>;
+
+export const TradeSummaryFilterZod = z.object({
+  reviewStatus: z.nativeEnum(ComplianceReview).optional(),
+  managedBy: z.nativeEnum(ManagedByType).optional(),
+});
+
+const tradeStatusValues = Object.values(TradeStatus) as string[];
+
+export const TradeFiltersZod = z.object({
+  investmentType: z.nativeEnum(InvestmentType).optional(),
+  tradeStatus: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (statuses) =>
+        statuses.every((status) => tradeStatusValues.includes(status as any)),
+      {
+        message: `Invalid trade status option provided. Valid options are: ${tradeStatusValues.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${tradeStatusValues.join(',')}`,
+    }),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  saStatus: z.nativeEnum(SaStatus).optional(),
+  saCheck: z.nativeEnum(SaCheck).optional(),
+  txnPaymentMethod: z.nativeEnum(PaymentMethodType).optional(),
+  fundingStatus: z.nativeEnum(FundingStatus).optional(),
+  txnCheck: z.nativeEnum(TxnCheck).optional(),
+  systemReviewCheck: z.nativeEnum(SystemReviewCheck).optional(),
+  complianceReview: z.nativeEnum(ComplianceReview).optional(),
+  beenDisbursed: z.enum(['true', 'false']).optional(),
+  search: z.string().max(50).optional(),
+  offeringId: z
+    .lazy(() => offeringIdSchema)
+    .optional()
+    .openapi({
+      example: 'offering_00041061050r3gg28a1c60t3gf',
+    }),
+  accountId: accountIdSchema.optional(),
+  issuerId: z
+    .lazy(() => issuerIdSchema)
+    .optional()
+    .openapi({
+      example: 'issuer_01jfw4q6qef30s6fpqtsxw94ya',
+    }),
+  offeringType: z.nativeEnum(OfferingType).optional(),
+  managedBy: z.nativeEnum(ManagedByType).optional(),
+  platform: z.nativeEnum(Platforms).optional(),
+  investorAccountId: z.lazy(() => investorAccountIdSchema).optional(),
+});
+
+export const ComplianceTradesFiltersZod = z.object({
+  kycStatus: z.nativeEnum(KYCStatus).optional(),
+  aicStatus: z.nativeEnum(AicStatus).optional(),
+  amlStatus: z.nativeEnum(AMLStatus).optional(),
+  accountStatus: z.nativeEnum(AccountStatus).optional(),
+  savedQuery: z.nativeEnum(SavedQuery).optional(),
+});
+
+export type ComplianceTradesFiltersZod = z.infer<
+  typeof ComplianceTradesFiltersZod
+>;
+
+export const TradeSortZod = z.object({
+  sort: z
+    .enum([SortBy.PLACEDAT, SortBy.CREATED_AT, SortBy.UPDATED_AT])
+    .optional(),
+  dir: z.nativeEnum(SortOrder).optional(),
+});
+export type TradeSortZod = z.infer<typeof TradeSortZod>;
+
+export const reviewTrades = z.object({
+  complianceReview: z.nativeEnum(ComplianceReview),
+  force: z.boolean().optional(),
+  forceApprovals: z
+    .array(z.enum(['kyc', 'aic', 'aml', 'subdoc']))
+    .optional()
+    .openapi({
+      example: ['kyc', 'aml'],
+    }), // items we are trying to force approve along with the trade
+  trades: z
+    .array(tradeIdSchema)
+    .min(1, 'At least one trade is required')
+    .max(1000, 'Maximum of 1000 trades allowed')
+    .openapi({
+      example: [
+        'trade_00041061050r3gg28a1c60t3gf',
+        'trade_00041061050r3gg28a1c60t3g',
+      ],
+    }),
+  rejectionReason: z.string().min(1).max(1000).optional().nullable(),
+});
+export type reviewTrades = z.infer<typeof reviewTrades>;
+
+export const reviewAllTrades = z.object({
+  complianceReview: z.enum([
+    ComplianceReview.APPROVED,
+  ]) /* only approved is supported for now */,
+});
+export type reviewAllTrades = z.infer<typeof reviewAllTrades>;
+
+export const PatchTradeStatus = z.object({
+  tradeStatus: z.nativeEnum(TradeStatus),
+});
+export type PatchTradeStatus = z.infer<typeof PatchTradeStatus>;
+
+export const tradesInclude = z.enum([
+  'tradeDisbursements',
+  'adjustments',
+  'account',
+  'issuer',
+  'lineItems',
+  'transactions',
+  'investorAccount',
+  'offering',
+  'paymentMethod',
+]);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
+ */
+export const TradesIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          tradesInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${tradesInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${tradesInclude.options.join(',')}`,
+    }),
+});
+
+export interface TradesIncludeQuery
+  extends z.infer<typeof TradesIncludeQuery> {}
+
+export enum TradeExportType {
+  PAGE = 'PAGE',
+  ALL = 'ALL',
+}
+
+export const ExportTradesQuery = PaginationOptionsZod.merge(TradeFiltersZod)
+  .merge(ComplianceTradesFiltersZod)
+  .merge(TradesIncludeQuery)
+  .merge(TradeSortZod)
+  .extend({
+    exportType: z
+      .nativeEnum(TradeExportType)
+      .optional()
+      .default(TradeExportType.PAGE),
+  });
+
+const tradesColumn = z.enum([
+  'id',
+  'investorAccountId',
+  'investorAccount',
+  'accountId',
+  'account',
+  'offeringId',
+  'offering',
+  'paymentMethodId',
+  'paymentMethod',
+  'userId',
+  'user',
+  'disbursementId',
+  'disbursement',
+  'tradeNumber',
+  'ip',
+  'tid',
+  'platform',
+  'investmentType',
+  'numberOfShares',
+  'pricePerShare',
+  'lineItems',
+  'transactions',
+  'totalAmount',
+  'tradeStatus',
+  'tradeStatusUnmapped',
+  'tradeDate',
+  'saStatus',
+  'saStatusUnmapped',
+  'saUrl',
+  'saSignedAt',
+  'saExtractedNumberOfShares',
+  'saExtractedTotalAmount',
+  'saExtractedPricePerShare',
+  'saExtractedInvestorType',
+  'saExtractedSigner',
+  'saExtractedSignatureDate',
+  'saExtractedSigner2',
+  'saExtractedSignatureDate2',
+  'saCheck',
+  'saCheckedAt',
+  'saLog',
+  'txnTid',
+  'txnResponse',
+  'txnPaymentMethod',
+  'txnCurrencyCode',
+  'txnChargedAmount',
+  'txnDate',
+  'txnSettledDate',
+  'fundingStatus',
+  'fundingStatusUnmapped',
+  'txnCheck',
+  'txnCheckedAt',
+  'txnLog',
+  'systemReviewCheck',
+  'systemReviewLog',
+  'complianceReview',
+  'complianceReviewNotes',
+  'complianceReviewerId',
+  'managedBy',
+  'complianceReviewer',
+  'issuer',
+  'issuerId',
+  'complianceReviewName',
+  'complianceReviewAt',
+  'tradeType',
+  'placedAt',
+  'cancelledAt',
+  'cancelledById',
+  'cancelledReason',
+  'cancellationPeriod',
+]);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
+ */
+export const TradesColumnQuery = z.object({
+  column: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (columns) =>
+        columns.every((col) => tradesColumn.options.includes(col as any)),
+      {
+        message: `Invalid column option provided. Valid options are: ${tradesColumn.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${tradesColumn.options.join(',')}`,
+    }),
+});
+
+export const InvestorsTradeFiltersZod = z.object({
+  investorAccountId: z.lazy(() => investorAccountIdSchema).optional(),
+  tradeStatus: z.nativeEnum(TradeStatus).optional(),
+  search: z.string().min(1).max(50).optional(),
+});
+
+const investorsTradesInclude = z.enum([
+  'lineItems',
+  'investorAccount',
+  'issuer',
+  'offering',
+]);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
+ */
+export const InvestorsTradesIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          investorsTradesInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${investorsTradesInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${investorsTradesInclude.options.join(',')}`,
+    }),
+});
+export interface InvestorsTradesIncludeQuery
+  extends z.infer<typeof InvestorsTradesIncludeQuery> {}
+
+export const InvestorsGetTradesQuery = PaginationOptionsZod.merge(
+  InvestorsTradeFiltersZod,
+).merge(InvestorsTradesIncludeQuery);
+
+export const UpdateTradeBody = z.object({
+  paymentMethodId: z.lazy(() => paymentMethodIdSchema),
+});
+
+export type UpdateTradeBodyType = z.infer<typeof UpdateTradeBody>;
+
+export const PostTradeBody = z.object({
+  investorAccountId: z.lazy(() => investorAccountIdSchema).optional(),
+  investmentType: z.nativeEnum(InvestmentType).optional(),
+});
+
+export type PostTradeBodyType = z.infer<typeof PostTradeBody>;
+
+export const InvestorsTradeResponse = IBaseEntity.extend({
+  investorAccountId: z.lazy(() => investorAccountIdSchema).nullable(),
+  accountId: z.string(),
+  offeringId: z.string().nullable(),
+  tid: z.string().nullable(),
+  investmentType: z.nativeEnum(InvestmentType),
+  numberOfShares: z.number().int(),
+  pricePerShare: z.number().multipleOf(0.01),
+  totalAmount: z.number().multipleOf(0.01).nullable(),
+  tradeStatus: z.nativeEnum(TradeStatus),
+  tradeStatusUnmapped: z.string().nullable(),
+  tradeDate: z.date().nullable(),
+  paymentMethodId: z.lazy(() => paymentMethodIdSchema).nullable(),
+});
+
+export const InvestorsPaginatedTrade = z.object({
+  items: z.array(InvestorsTradeResponse),
+  meta: IPaginationMeta,
+});
+export const IssuersTradeFiltersZod = z.object({
+  investmentType: z.nativeEnum(InvestmentType).optional(),
+  tradeStatus: z.nativeEnum(TradeStatus).optional(),
+  saStatus: z.nativeEnum(SaStatus).optional(),
+  saCheck: z.nativeEnum(SaCheck).optional(),
+  txnPaymentMethod: z.nativeEnum(PaymentMethodType).optional(),
+  fundingStatus: z.nativeEnum(FundingStatus).optional(),
+  txnCheck: z.nativeEnum(TxnCheck).optional(),
+  systemReviewCheck: z.nativeEnum(SystemReviewCheck).optional(),
+  complianceReview: z.nativeEnum(ComplianceReview).optional(),
+  beenDisbursed: z.enum(['true', 'false']).optional(),
+  search: z.string().optional().openapi({ example: 'Mike' }),
+  offeringId: z
+    .lazy(() => offeringIdSchema)
+    .optional()
+    .openapi({
+      example: 'offering_00041061050r3gg28a1c60t3gf',
+    }),
+  from: createDateSchema('START').optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: createDateSchema('END').optional().openapi({ example: 'MM/DD/YYYY' }),
+  minAmount: z
+    .string()
+    .transform((num) => Number(num))
+    .pipe(z.number().multipleOf(0.01).min(0.01).max(10000000000))
+    .optional()
+    .openapi({ example: '2500.00' }),
+  maxAmount: z
+    .string()
+    .transform((num) => Number(num))
+    .pipe(z.number().multipleOf(0.01).min(0.01).max(10000000000))
+    .optional()
+    .openapi({ example: '15000000.50' }),
+  managedBy: z.nativeEnum(ManagedByType).optional(),
+  investorAccountId: z.lazy(() => investorAccountIdSchema).optional(),
+});
+export type IssuersTradeFiltersZod = z.infer<typeof IssuersTradeFiltersZod>;
+
+/**
+ * Zod schema representing a union of all possible filter types based on portal type.
+ * This schema can be used for runtime validation of filter parameters.
+ */
+export const GetTradeFiltersSchema = z.union([
+  TradeFiltersZod,
+  IssuersTradeFiltersZod,
+  InvestorsTradeFiltersZod,
+]);
+
+/**
+ * Type representing the filters parameter for getTradeWithCalculatedFields.
+ * This is a union of all possible filter types based on portal type:
+ * - TradeFiltersZod (Compliance portal)
+ * - IssuersTradeFiltersZod (Issuer portal)
+ * - InvestorsTradeFiltersZod (Investor portal)
+ */
+export type GetTradeFiltersType = z.infer<typeof GetTradeFiltersSchema>;
+
+export const CancelTradeResponse = z.object({
+  message: z.string(),
+});
+export type CancelTradeResponse = z.infer<typeof CancelTradeResponse>;
+
+export const FailedTradeZod = z.object({
+  id: tradeIdSchema,
+  tradeNo: z.string(),
+  errors: z.string().array(),
+});
+
+export type FailedTradeZod = z.infer<typeof FailedTradeZod>;
+
+export const ReviewTradeZod = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  failedTrades: z.array(FailedTradeZod),
+});
+
+export type ReviewTradeZod = z.infer<typeof ReviewTradeZod>;
+
+export const CancelTradeZod = z.object({
+  reason: z
+    .string()
+    .min(2)
+    .max(1000)
+    .openapi({ example: 'cancellation reason' }),
+});
+
+export type CancelTradeZod = z.infer<typeof CancelTradeZod>;
+
+export const ComplianceCancelTradeZod = z.object({
+  reason: z
+    .string()
+    .min(2)
+    .max(1000)
+    .openapi({ example: 'cancellation reason' }),
+  accountId: accountIdSchema.openapi({
+    example: 'account_00041061050r3gg28a1c60t3gf',
+  }),
+});
+export type ComplianceCancelTradeZod = z.infer<typeof ComplianceCancelTradeZod>;
+
+export const ProcessPaymentZod = z.object({
+  tradeId: tradeIdSchema,
+  amount: z.number().min(0.01).max(10000000000),
+});
+
+export type ProcessPaymentZod = z.infer<typeof ProcessPaymentZod>;
+
+export const ProcessPaymentResponse = z.object({
+  success: z.boolean(),
+});
+
+export type ProcessPaymentResponse = z.infer<typeof ProcessPaymentResponse>;
+
+const TradeLineItemDataZod = z.object({
+  signaturePlatform: z.string(),
+  signatureDocumentId: z.string(),
+  signatureUrl: z.string(),
+  signatureStatus: z.nativeEnum(SignatureStatus),
+});
+
+export type TradeLineItemDataZod = z.infer<typeof TradeLineItemDataZod>;
+
+export const TradeSystemReviewLogZod = z.object({
+  type: z.nativeEnum(TradeSystemLogType),
+  data: z.record(z.string(), z.any()),
+  error: z.string().nullable(),
+  message: z.string().nullable(),
+  status: z.nativeEnum(TradeSystemReviewLogStatus),
+});
+export type TradeSystemReviewLogZod = z.infer<typeof TradeSystemReviewLogZod>;
+
+export enum BoldsignTemplateType {
+  INDIVIDUAL = 'INDIVIDUAL',
+  JOINT = 'JOINT',
+  ENTITY = 'ENTITY',
+}
+
+export const GetTemplateVariablesForTradeZod = z.object({
+  templateType: z.nativeEnum(BoldsignTemplateType),
+  templateId: z.string(),
+  mergeVars: z.array(
+    z.object({
+      field: z.string(),
+      value: z.string(),
+    }),
+  ),
+});
+
+export type GetTemplateVariablesForTradeZod = z.infer<
+  typeof GetTemplateVariablesForTradeZod
+>;
+
+/**
+ * Zod schema for CSV export data with all formatted fields ready for export
+ * All extraction and formatting logic is handled in trades.service.ts
+ */
+export const TradeForCsvExportZod = z.object({
+  tradeNumber: z.string(),
+  investorName: z.string(),
+  signerName: z.string(),
+  offeringName: z.string(),
+  tradeType: z.string(),
+  numberOfShares: z.number(),
+  pricePerShare: z.string(), // Formatted with $ prefix
+  totalAmount: z.string(), // Formatted with $ prefix
+  tradeStatus: z.string(),
+  fundingStatus: z.string(),
+  kycStatus: z.boolean(),
+  amlStatus: z.boolean(),
+  aicStatus: z.boolean(),
+  saStatus: z.string(),
+  placedAt: z.string(), // Formatted date string
+  closedAt: z.string(), // Formatted date string
+  txnPaymentMethod: z.string(),
+  txnChargedAmount: z.string(), // Formatted with $ prefix
+  registeredRepId: z.string(),
+  managedBy: z.string(),
+  platform: z.string(),
+  // Entity fields (for LEGAL_ENTITY type)
+  entityName: z.string(),
+  entityEin: z.string(),
+  entityAddress: z.string(),
+  entityAddress2: z.string(),
+  entityCity: z.string(),
+  entityCountry: z.string(),
+  entityState: z.string(),
+  entityZip: z.string(),
+  entityEmail: z.string(),
+  entityPhone: z.string(),
+  entityCompanyType: z.string(),
+  // Primary individual fields
+  primaryFirstName: z.string(),
+  primaryLastName: z.string(),
+  primaryDob: z.string(), // Formatted date string
+  primarySsn: z.string(), // Formatted SSN
+  primaryAddress: z.string(),
+  primaryAddress2: z.string(),
+  primaryCity: z.string(),
+  primaryCountry: z.string(),
+  primaryState: z.string(),
+  primaryZip: z.string(),
+  primaryEmail: z.string(),
+  primaryPhone: z.string(),
+  // Secondary individual fields (for JOINT and LEGAL_ENTITY types)
+  secondaryFirstName: z.string(),
+  secondaryLastName: z.string(),
+  secondaryDob: z.string(), // Formatted date string
+  secondarySsn: z.string(), // Formatted SSN
+  secondaryAddress: z.string(),
+  secondaryAddress2: z.string(),
+  secondaryCity: z.string(),
+  secondaryCountry: z.string(),
+  secondaryState: z.string(),
+  secondaryZip: z.string(),
+  secondaryEmail: z.string(),
+  secondaryPhone: z.string(),
+});
+
+export type TradeForCsvExport = z.infer<typeof TradeForCsvExportZod>;
+
+export const CANCELLABLE_TRADE_STATUSES = [
+  TradeStatus.PLACED,
+  TradeStatus.IN_REVIEW,
+  TradeStatus.NEEDS_INFO,
+  TradeStatus.FUNDING,
+];
+
+export const NON_CANCELABLE_COMPLIANCE_REVIEW_STATUSES = [
+  ComplianceReview.APPROVED,
+  ComplianceReview.REJECTED,
+  ComplianceReview.CANCELLED,
+];