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

package/common/types/trade.types.js

@@ -0,0 +1,787 @@
+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, AccountZod, } from './common.types.js';
+import { IOffering, offeringIdSchema } from './offering.types.js';
+import { IBaseEntity } from './entity.types.js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { paymentMethodIdSchema, PaymentMethodResponse, PaymentMethodType, } from './payment-methods.types.js';
+import { investorAccountIdSchema, IInvestorAccount, } from './investor-account.types.js';
+import { tradeLineItemIdSchema, TradeLineItemZod, } from './trade-line-item.types.js';
+import { TradeAdjustmentZod } from './trade-adjustment.type.js';
+import { TransactionZod } from './transaction.types.js';
+import { accountIdSchema } from './account.types.js';
+import { userIdSchema } from './user.types.js';
+import { issuerIdSchema } from './issuer.types.js';
+import { fileIdSchema } from './file.types.js';
+extendZodWithOpenApi(z);
+// Zod schemas for attach subdoc endpoints
+export const PostAttachSubdocBody = z.object({
+    lineItemId: tradeLineItemIdSchema.openapi({
+        example: 'trade_line_item_01kctsycw3fq7sj6hedvy62cja',
+    }),
+    fileId: z
+        .lazy(() => fileIdSchema)
+        .openapi({ example: 'file_01je6ht4b8fbmttkzh2hs82xqp' }),
+    primarySignatureStatus: z
+        .nativeEnum(SignatureStatus)
+        .openapi({ example: 'SIGNED' }),
+    secondarySignatureStatus: z
+        .nativeEnum(SignatureStatus)
+        .optional()
+        .openapi({ example: 'SIGNED' }),
+});
+export const PutAttachSubdocBody = z.object({
+    lineItemId: tradeLineItemIdSchema
+        .optional()
+        .openapi({ example: 'trade_line_item_01kctsycw3fq7sj6hedvy62cja' }),
+    fileId: z
+        .lazy(() => fileIdSchema)
+        .optional()
+        .openapi({ example: 'file_01je6ht4b8fbmttkzh2hs82xqp' }),
+    primarySignatureStatus: z
+        .nativeEnum(SignatureStatus)
+        .optional()
+        .openapi({ example: 'SIGNED' }),
+    secondarySignatureStatus: z
+        .nativeEnum(SignatureStatus)
+        .optional()
+        .openapi({ example: 'SIGNED' }),
+});
+export const PatchSubdocSignatureBody = z.object({
+    lineItemId: tradeLineItemIdSchema.optional().openapi({
+        example: 'trade_line_item_01kctsycw3fq7sj6hedvy62cja',
+        description: 'Optional. If not provided, updates the first line item with an attached subdoc. Required for trades with multiple line items.',
+    }),
+    primarySignatureStatus: z.nativeEnum(SignatureStatus).optional().openapi({
+        example: 'SIGNED',
+        description: 'Primary signer signature status',
+    }),
+    secondarySignatureStatus: z.nativeEnum(SignatureStatus).optional().openapi({
+        example: 'SIGNED',
+        description: 'Secondary signer signature status. Only applicable for JOINT investor accounts.',
+    }),
+});
+export const AttachSubdocResponse = z.object({
+    success: z.boolean(),
+    message: z.string(),
+});
+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 const TradeIdPrefix = 'trade';
+export const TradeSnapshotIdPrefix = 'trade_snapshot';
+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 const tradeSnapshotIdSchema = z.string().refine((value) => {
+    try {
+        const tid = TypeID.fromString(value);
+        return tid.getType() === TradeSnapshotIdPrefix;
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: 'Invalid trade snapshot ID format. Must be a valid TypeID with "trade_snapshot" prefix. ex: trade_snapshot_00041061050r3gg28a1c60t3gf',
+});
+export var SaStatus;
+(function (SaStatus) {
+    SaStatus["PENDING"] = "PENDING";
+    SaStatus["SIGNED"] = "SIGNED";
+    SaStatus["DECLINED"] = "DECLINED";
+    SaStatus["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+})(SaStatus || (SaStatus = {}));
+export var TradeSystemLogType;
+(function (TradeSystemLogType) {
+    TradeSystemLogType["SUB_DOC_CHECK"] = "Subscription Agreement Check";
+    TradeSystemLogType["ADDRESS_CHECK"] = "Address Check";
+    TradeSystemLogType["COUNTRY_CHECK"] = "Country Check";
+    TradeSystemLogType["CONCENTRATION_CHECK"] = "Concentration Check";
+    TradeSystemLogType["KYC_CHECK"] = "KYC Check";
+    TradeSystemLogType["AML_CHECK"] = "AML Check";
+    TradeSystemLogType["AIC_CHECK"] = "AIC Check";
+    TradeSystemLogType["USER_AGE_CHECK"] = "User Age Check";
+    TradeSystemLogType["KYC_NAME_CHECK"] = "KYC Name Check";
+    TradeSystemLogType["AML_NAME_CHECK"] = "AML Name Check";
+    TradeSystemLogType["AIC_NAME_CHECK"] = "AIC Name Check";
+    TradeSystemLogType["KYC_DOB_CHECK"] = "KYC DOB Check";
+    TradeSystemLogType["AIC_SSN_CHECK"] = "AIC SSN Check";
+    TradeSystemLogType["SIGNER_NAME_CHECK"] = "Signer Name Check";
+    // Data Integrity Checks For Imported Trades
+    TradeSystemLogType["SHARES_CHECK"] = "Shares Check";
+    TradeSystemLogType["PRICE_PER_UNIT_CHECK"] = "Price Per Unit Check";
+    TradeSystemLogType["ISSUER_CHECK"] = "Issuer Check";
+    TradeSystemLogType["INVESTOR_CHECK"] = "Investor Check";
+    TradeSystemLogType["OFFERING_CHECK"] = "Offering Check";
+    TradeSystemLogType["ASSETS_CHECK"] = "Assets Check";
+    TradeSystemLogType["INDIVIDUALS_CHECK"] = "Individuals Check";
+})(TradeSystemLogType || (TradeSystemLogType = {}));
+export var SaCheck;
+(function (SaCheck) {
+    SaCheck["PENDING"] = "PENDING";
+    SaCheck["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    SaCheck["APPROVED"] = "APPROVED";
+    SaCheck["REJECTED"] = "REJECTED";
+})(SaCheck || (SaCheck = {}));
+// cart NEEDS_INFO PLACED IN_REVIEW AWAITING_FUNDING CANCELLED SETTLED
+export var SystemReviewCheck;
+(function (SystemReviewCheck) {
+    SystemReviewCheck["PENDING"] = "PENDING";
+    SystemReviewCheck["APPROVED"] = "APPROVED";
+    SystemReviewCheck["REJECTED"] = "REJECTED";
+    SystemReviewCheck["NEEDS_REVIEW"] = "NEEDS_REVIEW";
+    SystemReviewCheck["WARNING"] = "WARNING";
+    SystemReviewCheck["INCOMPLETE"] = "INCOMPLETE";
+})(SystemReviewCheck || (SystemReviewCheck = {}));
+export var Platforms;
+(function (Platforms) {
+    Platforms["DALMORE"] = "DALMORE";
+    Platforms["IMPORT"] = "IMPORT";
+})(Platforms || (Platforms = {}));
+export var MatchResultStatus;
+(function (MatchResultStatus) {
+    MatchResultStatus["MATCHED"] = "MATCHED";
+    MatchResultStatus["UNMATCHED"] = "UNMATCHED";
+})(MatchResultStatus || (MatchResultStatus = {}));
+export var TradeSystemReviewLogStatus;
+(function (TradeSystemReviewLogStatus) {
+    TradeSystemReviewLogStatus["PASSED"] = "PASSED";
+    TradeSystemReviewLogStatus["WARNING"] = "WARNING";
+})(TradeSystemReviewLogStatus || (TradeSystemReviewLogStatus = {}));
+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(),
+});
+const saLogItemSchema = z.object({
+    tradeLineItemId: z.lazy(() => tradeLineItemIdSchema),
+    signerName: matchResultSchema.optional(),
+    totalAmount: matchResultSchema.optional(),
+    investorName: matchResultSchema.optional(),
+    numberOfShares: matchResultSchema.optional(),
+});
+export const SaLogSchema = z.object({
+    finalStatus: z.nativeEnum(SaStatus),
+    matchResults: z.array(saLogItemSchema),
+});
+export const PatchSaLogSchema = z.object({
+    matchResults: z.array(saLogItemSchema),
+});
+export const TradeBalanceResultZod = z.object({
+    tradeAdjustments: z.number().multipleOf(0.01),
+    chargedAmount: z.number().multipleOf(0.01),
+    balance: z.number().multipleOf(0.01),
+});
+export const TradeZod = IBaseEntity.extend({
+    investorAccountId: z.lazy(() => investorAccountIdSchema.nullable()),
+    investorAccount: z
+        .lazy(() => IInvestorAccount)
+        .optional()
+        .nullable(),
+    offering: z
+        .lazy(() => IOffering)
+        .optional()
+        .nullable(),
+    accountId: accountIdSchema.nullable(),
+    account: z.lazy(() => AccountZod).nullable(),
+    offeringId: z.lazy(() => offeringIdSchema.nullable()),
+    paymentMethodId: z.lazy(() => paymentMethodIdSchema).nullable(),
+    paymentMethod: z
+        .lazy(() => PaymentMethodResponse)
+        .optional()
+        .nullable(),
+    userId: z.lazy(() => userIdSchema.nullable()),
+    tradeNumber: z.string(),
+    ip: z.string().nullable(),
+    tid: z.string().nullable(),
+    investmentType: z.nativeEnum(InvestmentType),
+    purchasedShares: z.number().int(),
+    bonusShares: z.number().int().nullable(),
+    totalNumberOfShares: 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 var SnapshotEvent;
+(function (SnapshotEvent) {
+    SnapshotEvent["COMPLIANCE_APPROVED"] = "COMPLIANCE_APPROVED";
+    SnapshotEvent["COMPLIANCE_REJECTED"] = "COMPLIANCE_REJECTED";
+    SnapshotEvent["CANCELLED"] = "CANCELLED";
+    SnapshotEvent["PLACED"] = "PLACED";
+    SnapshotEvent["SETTLED"] = "SETTLED";
+})(SnapshotEvent || (SnapshotEvent = {}));
+export const GetTradeSnapshotEventsResponse = z.object({
+    events: z.array(z.nativeEnum(SnapshotEvent)),
+});
+export const IPaginatedTrade = z.object({
+    items: z.array(TradeZod),
+    meta: IPaginationMeta,
+});
+export const IPaginatedReviewTrade = z.object({
+    totalCount: z.number().int(),
+    currentPosition: z.number().int(),
+    tradeIds: z.array(tradeIdSchema),
+});
+export const TradeSummaryZod = z.object({
+    accountId: z.lazy(() => 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 const IPaginatedTradeSummaryResponse = z.object({
+    items: z.array(TradeSummaryZod),
+    meta: IPaginationMeta,
+});
+export const TradeSummaryFilterZod = z.object({
+    reviewStatus: z.nativeEnum(ComplianceReview).optional(),
+    managedBy: z.nativeEnum(ManagedByType).optional(),
+});
+const tradeStatusValues = Object.values(TradeStatus);
+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)), {
+        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',
+    }),
+    snapshotEvent: z.nativeEnum(SnapshotEvent).optional(),
+    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 const TradeSortZod = z.object({
+    sort: z
+        .enum([SortBy.PLACEDAT, SortBy.CREATED_AT, SortBy.UPDATED_AT])
+        .optional(),
+    dir: z.nativeEnum(SortOrder).optional(),
+});
+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 const reviewAllTrades = z.object({
+    complianceReview: z.enum([
+        ComplianceReview.APPROVED,
+    ]) /* only approved is supported for now */,
+});
+export const PatchTradeStatus = z.object({
+    tradeStatus: z.nativeEnum(TradeStatus),
+});
+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)), {
+        message: `Invalid include option provided. Valid options are: ${tradesInclude.options.join(',')}`,
+    })
+        .openapi({
+        example: `${tradesInclude.options.join(',')}`,
+    }),
+});
+export var TradeExportType;
+(function (TradeExportType) {
+    TradeExportType["PAGE"] = "PAGE";
+    TradeExportType["ALL"] = "ALL";
+})(TradeExportType || (TradeExportType = {}));
+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',
+    'purchasedShares',
+    'bonusShares',
+    'totalNumberOfShares',
+    '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)), {
+        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)), {
+        message: `Invalid include option provided. Valid options are: ${investorsTradesInclude.options.join(',')}`,
+    })
+        .openapi({
+        example: `${investorsTradesInclude.options.join(',')}`,
+    }),
+});
+export const InvestorsGetTradesQuery = PaginationOptionsZod.merge(InvestorsTradeFiltersZod).merge(InvestorsTradesIncludeQuery);
+export const UpdateTradeBody = z.object({
+    paymentMethodId: z.lazy(() => paymentMethodIdSchema),
+});
+export const PostTradeBody = z.object({
+    investorAccountId: z.lazy(() => investorAccountIdSchema).optional(),
+    investmentType: z.nativeEnum(InvestmentType).optional(),
+});
+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),
+    purchasedShares: z.number().int(),
+    bonusShares: z.number().int().nullable(),
+    totalNumberOfShares: 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(),
+});
+/**
+ * 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,
+]);
+export const CancelTradeResponse = z.object({
+    message: z.string(),
+});
+export const FailedTradeZod = z.object({
+    id: z.lazy(() => tradeIdSchema),
+    tradeNo: z.string(),
+    errors: z.string().array(),
+});
+export const ReviewTradeZod = z.object({
+    success: z.boolean(),
+    message: z.string(),
+    failedTrades: z.array(FailedTradeZod),
+});
+export const CancelTradeZod = z.object({
+    reason: z
+        .string()
+        .min(2)
+        .max(1000)
+        .openapi({ example: 'cancellation reason' }),
+});
+export const ComplianceCancelTradeZod = z.object({
+    reason: z
+        .string()
+        .min(2)
+        .max(1000)
+        .openapi({ example: 'cancellation reason' }),
+    accountId: accountIdSchema.openapi({
+        example: 'account_00041061050r3gg28a1c60t3gf',
+    }),
+});
+export const ProcessPaymentZod = z.object({
+    tradeId: z.lazy(() => tradeIdSchema),
+    amount: z.number().min(0.01).max(10000000000),
+});
+export const ProcessPaymentResponse = z.object({
+    success: z.boolean(),
+});
+const TradeLineItemDataZod = z.object({
+    signaturePlatform: z.string(),
+    signatureDocumentId: z.string(),
+    signatureUrl: z.string(),
+    signatureStatus: z.nativeEnum(SignatureStatus),
+});
+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 var BoldsignTemplateType;
+(function (BoldsignTemplateType) {
+    BoldsignTemplateType["INDIVIDUAL"] = "INDIVIDUAL";
+    BoldsignTemplateType["JOINT"] = "JOINT";
+    BoldsignTemplateType["ENTITY"] = "ENTITY";
+})(BoldsignTemplateType || (BoldsignTemplateType = {}));
+export const GetTemplateVariablesForTradeZod = z.object({
+    templateType: z.nativeEnum(BoldsignTemplateType),
+    templateId: z.string(),
+    mergeVars: z.array(z.object({
+        field: z.string(),
+        value: z.string(),
+    })),
+});
+/**
+ * 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(),
+    totalNumberOfShares: 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 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,
+];
+//# sourceMappingURL=trade.types.js.map