@dalmore/api-contracts 0.0.0-dev.d30d175 → 0.0.0-dev.d4be84e

package/common/types/offering.types.js

@@ -0,0 +1,829 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { sanitizeHtmlWithPurify } from '../helpers/index.js';
+import { accountIdSchema } from './account.types.js';
+import { capShareClassIdSchema } from './cap-table.types.js';
+import { AccountZod, ComplianceReview, dateSchema, IPaginationMeta, OfferingType, ManagedByType, PaginationOptionsZod, UrlSchema, SortOrder, SortBy, OfferingVersioningType, OfferingOnboardingStatus, AssetType, DurationType, StringToBooleanSchema, HttpMethod, numberPrecisionSchema, WarrantSharesCalculationMethod, } from './common.types.js';
+import { IBaseEntity } from './entity.types.js';
+import { fileIdSchema, FileZod } from './file.types.js';
+import { IIssuer, issuerIdSchema } from './issuer.types.js';
+import { InvestorsOfferingFiltersZod, InvestorsOfferingsIncludeQuery, } from './investors-offering.types.js';
+import { escrowValidationRefinement, postOfferingRefinement, warrantsValidationRefinement, } from './issuer-offering.types.js';
+import { postAssetRefinement, AssetTemplateType } from './asset.types.js';
+import { IIssuerBankAccount, issuerBankAccountIdSchema, } from './issuer-bank-account.types.js';
+import { escrowAccountIdSchema, IEscrowAccount } from './escrow-account.types.js';
+import { BonusTierListZod, postBonusTierRefinement } from './bonus-tier.types.js';
+export var OfferingFeeType;
+(function (OfferingFeeType) {
+    OfferingFeeType["FIXED"] = "FIXED";
+    OfferingFeeType["PERCENTAGE"] = "PERCENTAGE";
+})(OfferingFeeType || (OfferingFeeType = {}));
+extendZodWithOpenApi(z);
+export const offeringIdSchema = z.string().refine((value) => {
+    try {
+        const tid = TypeID.fromString(value);
+        return tid.getType() === 'offering';
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: `Invalid offering ID format. Must be a valid TypeID with "offering" prefix. Example: offering_01j5y5ghx5fg68d663j1fvy2x7`,
+});
+export const offeringRevisionIdSchema = z.string().refine((value) => {
+    try {
+        const tid = TypeID.fromString(value);
+        return tid.getType() === 'offering_revision';
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: `Invalid offering revision ID format. Must be a valid TypeID with "offering_revision" prefix. Example: offering_revision_01j5y5ghx5fg68d663j1fvy2x7`,
+});
+export const OfferingPlatformSettings = z.object({
+    backOfficePortal: z.string(),
+    username: z.string().nullable(),
+    password: z.string().nullable(),
+    apiKey: z.string().nullable(),
+});
+export const IOffering = IBaseEntity.extend({
+    name: z.string(),
+    tid: z.string().nullable(),
+    type: z.nativeEnum(OfferingType).nullable(),
+    description: z.string().nullable(),
+    raiseAmount: z.number().nullable(),
+    targetAmount: z.number().nullable(),
+    minInvestment: z.number().nullable(),
+    maxInvestment: z.number().nullable(),
+    contingencyAmount: z.number().nullable(),
+    startAt: z.date().nullable(),
+    endAt: z.date().nullable(),
+    platform: z.string(),
+    platformSettings: z.string().nullable(),
+    enabled: z.boolean(),
+    accountId: z.string().nullable(),
+    account: AccountZod.optional().nullable(),
+    issuer: z
+        .lazy(() => IIssuer)
+        .optional()
+        .nullable(), // Use z.lazy here
+    issuerId: z.string().nullable(),
+    coverArtId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    coverArt: z.lazy(() => FileZod).nullable(),
+    cancellationPeriod: z.number().nullable(),
+    memorandumId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    subscriptionAgreementId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    managedBy: z.nativeEnum(ManagedByType).nullable(),
+    valuationCap: z.number().nullable(),
+    showTotalRaised: z.boolean().optional(),
+    hasEscrow: z.boolean().optional(),
+    escrowAgreementFileId: z.string().nullable().optional(),
+    bankAccountId: z.string().nullable().optional(),
+    bankAccount: z
+        .lazy(() => IIssuerBankAccount)
+        .nullable()
+        .optional(),
+    escrowAccountId: z.string().nullable().optional(),
+    escrowAccount: z
+        .lazy(() => IEscrowAccount)
+        .nullable()
+        .optional(),
+    warrantsEnabled: z.boolean().optional(),
+    totalShares: z.number().nullable().optional(),
+    warrantTermYears: z.number().nullable().optional(),
+    exercisePrice: z.number().nullable().optional(),
+    warrantPercentage: z.number().nullable().optional(),
+    calculationMethod: z
+        .nativeEnum(WarrantSharesCalculationMethod)
+        .nullable()
+        .optional(),
+    incrementThreshold: z.number().nullable().optional(),
+    fullyDilutedShares: z.number().nullable().optional(),
+    shareClassId: z.string().nullable().optional(),
+    soldOut: z.boolean().optional(),
+});
+export const QueueSoldOutOfferingsCheckResponseSchema = z.object({
+    message: z.string(),
+});
+export const IPaginatedOffering = z.object({
+    items: z.array(IOffering),
+    meta: IPaginationMeta,
+});
+export const OfferingDescriptionZod = z
+    .string()
+    .max(15000, {
+    message: 'Description must be 15,000 characters or less before sanitization',
+})
+    .nullable()
+    .optional()
+    .transform((val) => {
+    if (!val)
+        return val;
+    return sanitizeHtmlWithPurify(val);
+})
+    .superRefine((val, ctx) => {
+    if (val && val.length > 10000) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Description must be 10,000 characters or less after sanitization found ${val.length} characters`,
+        });
+    }
+})
+    .openapi({ example: 'This is a description of the offering.' });
+export const PatchOfferingBase = z.object({
+    name: z.string().optional(),
+    description: OfferingDescriptionZod,
+    tid: z.string().optional(),
+    type: z.nativeEnum(OfferingType).optional(),
+    targetAmount: z.number().min(0.01).max(10000000000).optional(),
+    raiseAmount: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .openapi({ example: 5000 })
+        .optional(),
+    minInvestment: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .openapi({ example: 5000 })
+        .optional()
+        .nullable(),
+    maxInvestment: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .openapi({ example: 5000 })
+        .optional()
+        .nullable(),
+    contingencyAmount: z
+        .number()
+        .min(0.0)
+        .max(10000000000)
+        .openapi({ example: 5000 })
+        .optional()
+        .nullable(),
+    startAt: dateSchema.optional().openapi({ example: '10/20/2024' }),
+    endAt: dateSchema.optional().openapi({ example: '10/27/2024' }),
+    platform: z.string().optional(),
+    coverArtId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    platformSettings: OfferingPlatformSettings.optional().transform((val) => val ? JSON.stringify(val) : null),
+    enabled: z.boolean().optional(),
+    entitySubscriptionAgreementTemplateId: z.string().optional().nullable(),
+    managedBy: z.nativeEnum(ManagedByType).optional(),
+    subscriptionAgreementTemplateId: z.string().optional().nullable(),
+    memorandumId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    subscriptionAgreementId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    jointSubscriptionAgreementTemplateId: z.string().optional().nullable(),
+    cancellationPeriod: z.number().min(1).max(30).optional().nullable(),
+    showTotalRaised: z.boolean().optional(),
+    issuerId: issuerIdSchema.optional(),
+    shareClassId: z
+        .lazy(() => capShareClassIdSchema)
+        .nullable()
+        .optional(),
+});
+export const PatchOffering = PatchOfferingBase.merge(z.object({
+    assetName: z
+        .string()
+        .min(2)
+        .max(50)
+        .optional()
+        .openapi({ example: 'Asset name' }),
+    assetType: z
+        .nativeEnum(AssetType)
+        .optional()
+        .openapi({ example: AssetType.STOCK }),
+    pricePerUnit: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 2000 }),
+    totalUnits: z
+        .number()
+        .min(1)
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 5200 }),
+    yield: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 1200 }),
+    duration: z
+        .number()
+        .min(1)
+        .max(1000)
+        .nullable()
+        .optional()
+        .openapi({ example: 1 }),
+    durationType: z
+        .nativeEnum(DurationType)
+        .nullable()
+        .optional()
+        .openapi({ example: DurationType.DAY }),
+    template: z
+        .nativeEnum(AssetTemplateType)
+        .default(AssetTemplateType.STANDARD)
+        .openapi({ example: AssetTemplateType.STANDARD })
+        .nullable()
+        .optional(),
+    tiers: z.array(z.number().positive()).nullable().optional(),
+    enableBonus: z.boolean().optional(),
+    interestRate: z
+        .number()
+        .min(0.01)
+        .max(100)
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    bonusTiers: BonusTierListZod.optional(),
+    hasEscrow: z.boolean().optional(),
+    bankAccountId: z
+        .lazy(() => issuerBankAccountIdSchema)
+        .nullable()
+        .optional(),
+    escrowAccountId: z
+        .lazy(() => escrowAccountIdSchema)
+        .nullable()
+        .optional(),
+    escrowAgreementFileId: z
+        .lazy(() => fileIdSchema)
+        .nullable()
+        .optional(),
+    warrantsEnabled: z.boolean().optional().openapi({ example: false }),
+    totalShares: z
+        .number()
+        .int()
+        .positive()
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 1000 }),
+    warrantTermYears: z
+        .number()
+        .int()
+        .positive()
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    exercisePrice: numberPrecisionSchema(2, z.number().min(0.01).max(10000000000))
+        .nullable()
+        .optional()
+        .openapi({ example: 100 }),
+    warrantPercentage: numberPrecisionSchema(2, z.number().positive().max(100))
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    calculationMethod: z
+        .nativeEnum(WarrantSharesCalculationMethod)
+        .nullable()
+        .optional()
+        .openapi({ example: WarrantSharesCalculationMethod.NONE }),
+    incrementThreshold: numberPrecisionSchema(2, z.number().min(0.01).max(10000000000))
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+}));
+/**
+ * Optional params for resolveAndValidateOfferingUpdateFields.
+ * All fields are optional and nullable; resolution merges with offering/asset values.
+ */
+export const ResolveOfferingUpdateFieldsParamsZod = z.object({
+    minInvestment: z.number().nullable().optional(),
+    maxInvestment: z.number().nullable().optional(),
+    targetAmount: z.number().nullable().optional(),
+    pricePerUnit: z.number().nullable().optional(),
+});
+/**
+ * Resolved, validated offering update fields (price per unit, target amount, min/max investment).
+ * Returned by resolveAndValidateOfferingUpdateFields and passed into validateBonusTiersForUpdate.
+ */
+export const ResolvedOfferingUpdateFieldsZod = z.object({
+    pricePerUnit: z.number(),
+    targetAmount: z.number(),
+    minInvestment: z.number().nullable(),
+    maxInvestment: z.number().nullable(),
+});
+export const PostComplianceOffering = PatchOfferingBase.merge(z.object({
+    accountId: z.lazy(() => accountIdSchema),
+    managedBy: z.nativeEnum(ManagedByType).optional(),
+    shareClassId: z
+        .lazy(() => capShareClassIdSchema)
+        .nullable()
+        .optional()
+        .openapi({ example: 'cap_table_share_class_01j1xgme...' }),
+    assetName: z.string().min(2).max(50).openapi({ example: 'Asset name' }),
+    assetType: z.nativeEnum(AssetType).openapi({ example: AssetType.STOCK }),
+    pricePerUnit: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .nullable()
+        .openapi({ example: 2000 }),
+    totalUnits: z
+        .number()
+        .min(1)
+        .max(10000000000)
+        .nullable()
+        .openapi({ example: 5200 }),
+    yield: z
+        .number()
+        .min(0.01)
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 1200 }),
+    duration: z
+        .number()
+        .min(1)
+        .max(1000)
+        .nullable()
+        .optional()
+        .openapi({ example: 1 }),
+    durationType: z
+        .nativeEnum(DurationType)
+        .nullable()
+        .optional()
+        .openapi({ example: DurationType.DAY }),
+    template: z
+        .nativeEnum(AssetTemplateType)
+        .default(AssetTemplateType.STANDARD)
+        .openapi({ example: AssetTemplateType.STANDARD }),
+    tiers: z.array(z.number().positive()).nullable().optional(),
+    enableBonus: z.boolean().default(false).optional(),
+    hasEscrow: z.boolean().optional(),
+    bankAccountId: z
+        .lazy(() => issuerBankAccountIdSchema)
+        .nullable()
+        .optional(),
+    escrowAccountId: z
+        .lazy(() => escrowAccountIdSchema)
+        .nullable()
+        .optional(),
+    interestRate: z
+        .number()
+        .min(0.01)
+        .max(100)
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    bonusTiers: BonusTierListZod.optional(),
+    warrantsEnabled: z
+        .boolean()
+        .optional()
+        .default(false)
+        .openapi({ example: false }),
+    totalShares: z
+        .number()
+        .int()
+        .positive()
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 1000 }),
+    warrantTermYears: z
+        .number()
+        .int()
+        .positive()
+        .max(10000000000)
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    exercisePrice: numberPrecisionSchema(2, z.number().min(0.01).max(10000000000))
+        .nullable()
+        .optional()
+        .openapi({ example: 100 }),
+    warrantPercentage: numberPrecisionSchema(2, z.number().positive().max(100))
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    calculationMethod: z
+        .nativeEnum(WarrantSharesCalculationMethod)
+        .nullable()
+        .optional()
+        .openapi({ example: WarrantSharesCalculationMethod.NONE }),
+    incrementThreshold: numberPrecisionSchema(2, z.number().min(0.01).max(10000000000))
+        .nullable()
+        .optional()
+        .openapi({ example: 10 }),
+    showTotalRaised: z
+        .boolean()
+        .default(true)
+        .optional()
+        .openapi({ example: true }),
+})).superRefine((data, ctx) => {
+    postOfferingRefinement(data, ctx);
+    postAssetRefinement(data, ctx);
+    escrowValidationRefinement(data, ctx, HttpMethod.POST);
+    postBonusTierRefinement(data, ctx);
+    warrantsValidationRefinement(data, ctx);
+});
+export const offeringsInclude = z.enum([
+    'account',
+    'issuer',
+    'trades',
+    'assets',
+    'disbursements',
+    'draftVersion',
+    'publishedVersion',
+    'revisions',
+    'onboardingReviewedBy',
+    'bankAccount',
+    'escrowAccount',
+    'shareClass',
+]);
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
+ */
+export const OfferingsIncludeQuery = z.object({
+    include: z
+        .string()
+        .optional()
+        .transform((str) => (str ? str.split(',') : []))
+        .refine((includes) => includes.every((include) => offeringsInclude.options.includes(include)), {
+        message: `Invalid include option provided. Valid options are: ${offeringsInclude.options.join(',')}`,
+    })
+        .openapi({
+        example: `${offeringsInclude.options.join(',')}`,
+    }),
+});
+/**
+ * Filters supported for querying offerings.
+ *
+ * Available fields:
+ * - `issuerName`: (string, optional) Filter by name of the issuer.
+ * - `name`: (string, optional) Filter by offering name.
+ * - `accountId`: (AccountId, optional) Filter by tenant/account ID.
+ * - `issuerId`: (IssuerId, optional) Filter by issuer ID.
+ * - `type`: (OfferingType, optional) Filter by offering type.
+ * - `status`: (ComplianceReview, optional) Filter by compliance review status.
+ * - `enabled`: (boolean, optional) Filter for enabled/active offerings.
+ * - `managedBy`: (ManagedByType, optional) Filter by which system or user manages the offering.
+ * - `versioningType`: (OfferingVersioningType, optional) Filter by versioning strategy.
+ * - `onboardingStatus`: (OfferingOnboardingStatus, optional) Filter by issuer onboarding status.
+ *
+ * @remarks
+ * These filters can be combined to query offerings across multiple dimensions.
+ *
+ * Example use:
+ * ```ts
+ * { issuerName: "ABC Capital", type: OfferingType.REG_A }
+ * ```
+ */
+export const OfferingFiltersZod = z.object({
+    issuerName: z.string().optional(),
+    name: z.string().optional(),
+    accountId: accountIdSchema.optional(),
+    issuerId: z.lazy(() => issuerIdSchema).optional(),
+    type: z.nativeEnum(OfferingType).optional(),
+    status: z.nativeEnum(ComplianceReview).optional(),
+    enabled: StringToBooleanSchema.optional(),
+    managedBy: z.nativeEnum(ManagedByType).optional(),
+    versioningType: z.nativeEnum(OfferingVersioningType).optional(),
+    onboardingStatus: z.nativeEnum(OfferingOnboardingStatus).optional(),
+    complianceReview: z.nativeEnum(ComplianceReview).optional(),
+});
+export const OfferingSortZod = z.object({
+    sort: z.enum([SortBy.NAME, SortBy.CREATED_AT, SortBy.UPDATED_AT]).optional(),
+    dir: z.nativeEnum(SortOrder).optional(),
+});
+export const OfferingSummaryFiltersZod = z.object({
+    accountId: accountIdSchema.optional(),
+    hasPendingTrades: z.coerce.boolean().optional(),
+});
+export const OfferingSummaryResponseZod = z.object({
+    id: z.lazy(() => offeringIdSchema),
+    name: z.string(),
+    account: z.object({ id: z.lazy(() => accountIdSchema), name: z.string() }),
+    trades: z.object({
+        total: z.number(),
+        tradeReview: z.number(),
+        readyForDisbursement: z.number(),
+    }),
+});
+export const PaginatedOfferingSummaryResponseZod = z.object({
+    items: z.array(OfferingSummaryResponseZod),
+    meta: IPaginationMeta,
+});
+const BaseOfferingSettings = z.object({
+    settingsBrokerageFeeValue: z.number().nonnegative().nullable().optional(),
+    settingsBrokerageFeeType: z.nativeEnum(OfferingFeeType).nullable().optional(),
+    settingsCardFeeValue: z.number().nonnegative().nullable().optional(),
+    settingsCardFeeType: z.nativeEnum(OfferingFeeType).nullable().optional(),
+    settingsDisbursementFeeValue: z.number().nonnegative().nullable().optional(),
+    settingsDisbursementFeeType: z
+        .nativeEnum(OfferingFeeType)
+        .nullable()
+        .optional(),
+    settingsRefundPoolFeeValue: z.number().nonnegative().nullable().optional(),
+    settingsRefundPoolFeeType: z
+        .nativeEnum(OfferingFeeType)
+        .nullable()
+        .optional(),
+    serviceChargesType: z.nativeEnum(OfferingFeeType).nullable().optional(),
+    serviceCharges: z.number().nonnegative().nullable().optional(),
+});
+export const OfferingSettings = BaseOfferingSettings.refine((data) => (data.settingsBrokerageFeeType === null &&
+    data.settingsBrokerageFeeValue === null) ||
+    (data.settingsBrokerageFeeType !== null &&
+        data.settingsBrokerageFeeValue !== null), {
+    message: 'settingsBrokerageFeeType and settingsBrokerageFeeValue must both be either null or not-null',
+})
+    .refine((data) => (data.serviceChargesType === null && data.serviceCharges === null) ||
+    (data.serviceChargesType !== null && data.serviceCharges !== null), {
+    message: 'serviceChargesType and serviceCharges must both be either null or not-null',
+})
+    .refine((data) => (data.settingsCardFeeType === null &&
+    data.settingsCardFeeValue === null) ||
+    (data.settingsCardFeeType !== null && data.settingsCardFeeValue !== null), {
+    message: 'settingsCardFeeType and settingsCardFeeValue must both be either null or not-null',
+})
+    .refine((data) => (data.settingsDisbursementFeeType === null &&
+    data.settingsDisbursementFeeValue === null) ||
+    (data.settingsDisbursementFeeType !== null &&
+        data.settingsDisbursementFeeValue !== null), {
+    message: 'settingsDisbursementFeeType and settingsDisbursementFeeValue must both be either null or not-null',
+})
+    .refine((data) => (data.settingsRefundPoolFeeType === null &&
+    data.settingsRefundPoolFeeValue === null) ||
+    (data.settingsRefundPoolFeeType !== null &&
+        data.settingsRefundPoolFeeValue !== null), {
+    message: 'settingsRefundPoolFeeType and settingsRefundPoolFeeValue must both be either null or not-null',
+})
+    .refine((data) => data.settingsBrokerageFeeType !== OfferingFeeType.PERCENTAGE ||
+    (data.settingsBrokerageFeeValue !== null &&
+        data.settingsBrokerageFeeValue <= 100), {
+    message: 'settingsBrokerageFeeValue must be less than or equal to 100',
+})
+    .refine((data) => data.settingsRefundPoolFeeType !== OfferingFeeType.PERCENTAGE ||
+    (data.settingsRefundPoolFeeValue !== null &&
+        data.settingsRefundPoolFeeValue <= 100), {
+    message: 'settingsRefundPoolFeeValue must be less than or equal to 100',
+})
+    .refine((data) => data.settingsCardFeeType !== OfferingFeeType.PERCENTAGE ||
+    (data.settingsCardFeeValue !== null && data.settingsCardFeeValue <= 100), {
+    message: 'settingsCardFeeValue must be less than or equal to 100',
+})
+    .refine((data) => data.settingsDisbursementFeeType !== OfferingFeeType.PERCENTAGE ||
+    (data.settingsDisbursementFeeValue !== null &&
+        data.settingsDisbursementFeeValue <= 100), {
+    message: 'settingsDisbursementFeeValue must be less than 100',
+});
+export const PatchComplianceOffering = z
+    .intersection(PatchOffering, OfferingSettings)
+    .superRefine((data, ctx) => {
+    // Check if both values are present, and if so, ensure minInvestment is less than maxInvestment
+    if (typeof data.minInvestment === 'number' &&
+        typeof data.maxInvestment === 'number') {
+        if (data.minInvestment >= data.maxInvestment) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Minimum investment must be less than maximum investment.',
+                path: ['minInvestment'],
+            });
+        }
+    }
+    if (data.type === OfferingType.REG_CF) {
+        if (data.contingencyAmount === null ||
+            data.contingencyAmount === undefined ||
+            (typeof data.contingencyAmount === 'number' && data.contingencyAmount <= 0)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Contingency amount is required for REG_CF offerings.',
+            });
+        }
+    }
+    // Apply escrow-specific refinements
+    escrowValidationRefinement(data, ctx, HttpMethod.PATCH);
+    // Apply bonus-tier-specific refinements
+    postBonusTierRefinement(data, ctx);
+});
+export const IComplianceOffering = z.intersection(IOffering, OfferingSettings);
+export const IPaginatedComplianceOffering = z.object({
+    items: z.array(IComplianceOffering),
+    meta: IPaginationMeta,
+});
+export const ReviewOfferings = z.object({
+    complianceReview: z.enum([
+        ComplianceReview.APPROVED,
+        ComplianceReview.REJECTED,
+    ]),
+    offerings: z
+        .array(offeringIdSchema)
+        .min(1, 'At least one offering is required')
+        .max(50, 'Maximum of 50 offerings allowed')
+        .openapi({
+        example: [
+            'offering_01jjsdrx1seqfse7z4z47sgdp5',
+            'offering_01jjsdrx27enkszq5cnc3hdhrf',
+        ],
+    }),
+});
+export const OfferingDetailsResponseZod = z.object({
+    raisedAmount: z.number(),
+    investors: z.number().int(),
+    minInvestment: z.number(),
+    maxInvestment: z.number(),
+    valuationCap: z.number(),
+    targetAmount: z.number(),
+});
+export const OfferingsArrayQueryZod = z.object({
+    offerings: z
+        .string()
+        .optional()
+        .transform((val) => {
+        if (!val)
+            return undefined;
+        return val.split(',').map((id) => id.trim());
+    })
+        .pipe(z
+        .array(z.string())
+        .optional()
+        .refine((val) => {
+        if (!val)
+            return true;
+        return val.every((id) => {
+            try {
+                const tid = TypeID.fromString(id);
+                return tid.getType() === 'offering';
+            }
+            catch {
+                return false;
+            }
+        });
+    }, {
+        message: 'Invalid offering IDs format. Must be a valid TypeID with "offering" prefix.',
+    })),
+});
+export const OfferingRaiseAmountResponseZod = z.object({
+    offeringId: z.lazy(() => offeringIdSchema),
+    totalRaisedAmount: z.number(),
+});
+export const PublicOfferingFiltersZod = PaginationOptionsZod.merge(InvestorsOfferingsIncludeQuery)
+    .merge(InvestorsOfferingFiltersZod)
+    .extend({
+    url: UrlSchema,
+});
+export const PendingOfferingSummaryResponseZod = z.object({
+    id: z.lazy(() => offeringIdSchema),
+    name: z.string(),
+    assets: z.number(),
+    issuerName: z.string(),
+    issuerId: z.string(),
+    accountName: z.string(),
+    accountId: z.string(),
+    targetAmount: z.number().nullable(),
+    startAt: z.date().nullable(),
+    offeringType: z.nativeEnum(OfferingType),
+});
+export const PaginatedPendingOfferingSummaryResponseZod = z.object({
+    items: z.array(PendingOfferingSummaryResponseZod),
+    meta: IPaginationMeta,
+});
+export const ReviewOfferingOnboarding = z.object({
+    onboardingStatus: z.nativeEnum(OfferingOnboardingStatus),
+});
+export const OnboardingOfferingSummaryZod = z.object({
+    accountId: z.lazy(() => accountIdSchema),
+    accountName: z.string(),
+    offeringName: z.string(),
+    offeringId: z.string(),
+    memorandumId: z.string().nullable(),
+    subscriptionAgreementId: z.string().nullable(),
+    subscriptionAgreementTemplateId: z.string().nullable(),
+    jointSubscriptionAgreementTemplateId: z.string().nullable(),
+    entitySubscriptionAgreementTemplateId: z.string().nullable(),
+});
+export const OnboardingOfferingSummaryFilterZod = z.object({
+    search: z.string().optional(),
+    offeringId: offeringIdSchema.optional(),
+});
+export const IPaginatedOnboardingOfferingSummaryResponse = z.object({
+    items: z.array(OnboardingOfferingSummaryZod),
+    meta: IPaginationMeta,
+});
+/**
+ * Maps asset types to fields that should be reset (nullified) when converting
+ * from one asset type to another. This ensures incompatible fields from the
+ * previous type are cleared when the asset type changes.
+ */
+export const ESCROW_ENABLED_OFFERING_FIELD_RESETS = {
+    bankAccountId: null,
+    escrowAccountId: null,
+    escrowAgreementFileId: null,
+};
+/**
+ * Schema for escrow validation data input
+ */
+export const EscrowValidationDataZod = z.object({
+    hasEscrow: z.boolean().optional(),
+    bankAccountId: z.string().nullable().optional(),
+    escrowAccountId: z.string().nullable().optional(),
+    escrowAgreementFileId: z.string().nullable().optional(),
+});
+/**
+ * Schema for escrow validation context
+ */
+export const EscrowValidationContextZod = z.object({
+    accountId: z.string(),
+    issuerId: z.string(),
+    offeringId: z.string(),
+    currentBankAccountId: z.string().nullable(),
+    currentEscrowAccountId: z.string().nullable(),
+    currentEscrowAgreementFileId: z.string().nullable(),
+});
+/**
+ * Shape of warrant fields shared by Offering and OfferingRevision for validation.
+ */
+export const WarrantSharesBaseZod = z.object({
+    warrantsEnabled: z.boolean(),
+    totalShares: z.number().nullable(),
+    warrantTermYears: z.number().nullable(),
+    exercisePrice: z.number().nullable(),
+    warrantPercentage: z.number().nullable(),
+    calculationMethod: z.nativeEnum(WarrantSharesCalculationMethod).nullable(),
+    incrementThreshold: z.number().nullable(),
+    fullyDilutedShares: z.number().nullable(),
+});
+/**
+ * All warrant field keys used when picking warrant data from base or patch.
+ */
+export const WARRANT_FIELD_KEYS = [
+    'warrantsEnabled',
+    'totalShares',
+    'warrantTermYears',
+    'exercisePrice',
+    'warrantPercentage',
+    'calculationMethod',
+    'incrementThreshold',
+    'fullyDilutedShares',
+];
+/**
+ * Warrant field keys required when enabling warrants (turning warrants on).
+ */
+export const WARRANT_REQUIRED_WHEN_ENABLED_KEYS = [
+    'totalShares',
+    'warrantTermYears',
+    'exercisePrice',
+    'warrantPercentage',
+    'calculationMethod',
+];
+/**
+ * Patch input for warrant validation (optional warrant fields from PATCH body).
+ */
+export const WarrantValidationDataZod = z.object({
+    warrantsEnabled: z.boolean().optional(),
+    totalShares: z.number().nullable().optional(),
+    warrantTermYears: z.number().nullable().optional(),
+    exercisePrice: z.number().nullable().optional(),
+    warrantPercentage: z.number().nullable().optional(),
+    calculationMethod: z
+        .nativeEnum(WarrantSharesCalculationMethod)
+        .nullable()
+        .optional(),
+    incrementThreshold: z.number().nullable().optional(),
+    fullyDilutedShares: z.number().nullable().optional(),
+});
+/**
+ * Warrant-related fields to reset (nullify) when warrants are disabled.
+ * Used when warrantsEnabled is set to false so revision and offering stay in sync.
+ */
+export const WARRANT_DISABLED_FIELD_RESETS = {
+    warrantsEnabled: false,
+    totalShares: null,
+    warrantTermYears: null,
+    exercisePrice: null,
+    warrantPercentage: null,
+    calculationMethod: null,
+    incrementThreshold: null,
+    fullyDilutedShares: null,
+};
+//# sourceMappingURL=offering.types.js.map