@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/common/types/disbursement-approval-user.types.ts

@@ -0,0 +1,100 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { accountIdSchema } from './account.types';
+import { AccountZod, IPaginationMeta } from './common.types';
+import { userIdSchema, UserZod } from './user.types';
+
+export const disbursementApprovalUserIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'disbursement_approval_user';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid disbursement approval user ID format. Must be a valid TypeID with "disbursement_approval_user" prefix.',
+  },
+);
+
+export enum DisbursementApprovalUsersRole {
+  CREATOR = 'CREATOR',
+  APPROVER = 'APPROVER',
+}
+
+export const DisbursementApprovalUserZod = IBaseEntity.extend({
+  role: z.nativeEnum(DisbursementApprovalUsersRole),
+  accountId: accountIdSchema,
+  account: z
+    .lazy(() => AccountZod)
+    .optional()
+    .nullable(),
+  userId: userIdSchema,
+  user: UserZod.optional().nullable(),
+});
+
+export type DisbursementApprovalUserZod = z.infer<
+  typeof DisbursementApprovalUserZod
+>;
+
+export const PostDisbursementApprovalUser = z.object({
+  role: z.nativeEnum(DisbursementApprovalUsersRole),
+  userId: userIdSchema,
+});
+export type PostDisbursementApprovalUser = z.infer<
+  typeof PostDisbursementApprovalUser
+>;
+
+export const PostComplianceDisbursementApprovalUser =
+  PostDisbursementApprovalUser.extend({
+    accountId: accountIdSchema.optional().openapi({
+      example: 'account_00041061050r3gg28a1c60t3gf',
+    }),
+  });
+export type PostComplianceDisbursementApprovalUser = z.infer<
+  typeof PostComplianceDisbursementApprovalUser
+>;
+
+export const DisbursementApprovalUserFiltersZod = z.object({
+  userId: userIdSchema.optional(),
+  role: z.nativeEnum(DisbursementApprovalUsersRole).optional(),
+  accountId: accountIdSchema.optional(),
+});
+
+export const IPaginatedDisbursementApprovalUser = z.object({
+  items: z.array(DisbursementApprovalUserZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDisbursementApprovalUser = z.infer<
+  typeof IPaginatedDisbursementApprovalUser
+>;
+
+const disbursementApprovalUsersInclude = z.enum(['user', 'account']);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(DisbursementApprovalUsersIncludeQuery),
+ */
+export const DisbursementApprovalUsersIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          disbursementApprovalUsersInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${disbursementApprovalUsersInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${disbursementApprovalUsersInclude.options.join(',')}`,
+    }),
+});
+export interface DisbursementApprovalUsersIncludeQuery
+  extends z.infer<typeof DisbursementApprovalUsersIncludeQuery> {}

package/src/common/types/disbursement-review.types.ts

@@ -0,0 +1,110 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { userIdSchema, UserZod } from './user.types';
+import {
+  disbursementIdSchema,
+  DisbursementStatus,
+} from './disbursements.types';
+import { IBaseEntity } from './entity.types';
+import { accountIdSchema } from './account.types';
+import { AccountZod, ComplianceReview, IPaginationMeta } from './common.types';
+
+export const disbursementReviewIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'disbursement_review';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid disbursement review ID format. Must be a valid TypeID with "disbursement_review" prefix.',
+  },
+);
+
+export const PostDisbursementReviewZod = z.object({
+  disbursementReview: z.enum(['APPROVED', 'REJECTED']),
+  disbursements: z
+    .array(disbursementIdSchema)
+    .min(1, 'disbursement is required')
+    .max(1, 'Maximum of 1 disbursement allowed')
+    .openapi({
+      example: ['disbursement_01jjsdrx1seqfse7z4z47sgdp5'],
+    }),
+});
+
+export type PostDisbursementReviewZod = z.infer<
+  typeof PostDisbursementReviewZod
+>;
+
+export const DisbursementReviewZod = IBaseEntity.extend({
+  accountId: accountIdSchema,
+  account: AccountZod.optional().nullable(),
+  userId: userIdSchema,
+  user: UserZod.optional().nullable(),
+  status: z.nativeEnum(DisbursementStatus),
+});
+
+export type DisbursementReviewZod = z.infer<typeof DisbursementReviewZod>;
+
+export const IPaginatedDisbursementReviews = z.object({
+  items: z.array(DisbursementReviewZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDisbursementReviews = z.infer<
+  typeof IPaginatedDisbursementReviews
+>;
+
+const disbursementReviewsInclude = z.enum(['user', 'account', 'disbursement']);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(DisbursementReviewsIncludeQuery),
+ */
+export const DisbursementReviewsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          disbursementReviewsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${disbursementReviewsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${disbursementReviewsInclude.options.join(',')}`,
+    }),
+});
+export interface DisbursementReviewsIncludeQuery
+  extends z.infer<typeof DisbursementReviewsIncludeQuery> {}
+
+export const DisbursementReviewFiltersZod = z.object({
+  disbursementId: disbursementIdSchema,
+});
+
+export const PostComplianceReviewDisbursementZod = z.object({
+  complianceReview: z.enum([
+    ComplianceReview.APPROVED,
+    ComplianceReview.REJECTED,
+  ]),
+  disbursements: z
+    .array(disbursementIdSchema)
+    .min(1, 'At least one disbursement is required')
+    .max(50, 'Maximum of 50 disbursements allowed')
+    .openapi({
+      example: [
+        'disbursement_01jjsdrx1seqfse7z4z47sgdp5',
+        'disbursement_01jjsdrx27enkszq5cnc3hdhrf',
+      ],
+    }),
+});
+
+export type PostComplianceReviewDisbursementZod = z.infer<
+  typeof PostComplianceReviewDisbursementZod
+>;

package/src/common/types/disbursement-transaction.types.ts

@@ -0,0 +1,72 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+
+import { accountIdSchema } from './account.types';
+import { IBaseEntity } from './entity.types';
+import { dateSchema } from './common.types';
+import { TransactionStatus, TransactionType } from './transaction.types';
+import { disbursementIdSchema, DisbursementZod } from './disbursements.types';
+
+export const disbursementTransactionIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'disbursement_transaction';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid disbursement transaction ID format. Must be a valid TypeID with "disbursement_transaction" prefix.`,
+  },
+);
+
+export const DisbursementTransactionZod = IBaseEntity.extend({
+  id: disbursementTransactionIdSchema,
+  accountId: accountIdSchema,
+  type: z.nativeEnum(TransactionType),
+  status: z.nativeEnum(TransactionStatus),
+  tid: z.string().nullable(),
+  amount: z.number(),
+  currencyCode: z.string(),
+  chargedAt: z.date().nullable(),
+  cancelledAt: z.date().nullable(),
+  disbursementId: z.lazy(() => disbursementIdSchema).nullable(),
+  disbursement: z
+    .lazy(() => DisbursementZod)
+    .optional()
+    .nullable(),
+});
+export type DisbursementTransactionZod = z.infer<
+  typeof DisbursementTransactionZod
+>;
+
+export const PostDisbursementTransactionZod = z.object({
+  tid: z.string().min(6).max(64).openapi({ example: 'TXN8A7B6C5' }),
+  type: z
+    .nativeEnum(TransactionType)
+    .openapi({ example: TransactionType.CHARGE }),
+  amount: z.number().min(0.01).max(10000000000).openapi({ example: 2000 }),
+  disbursementId: z
+    .lazy(() => disbursementIdSchema)
+    .openapi({
+      example: 'disbursement_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+});
+export type PostDisbursementTransactionZod = z.infer<
+  typeof PostDisbursementTransactionZod
+>;
+
+export const CompliancePostDisbursementTransactionZod =
+  PostDisbursementTransactionZod.merge(
+    z.object({
+      chargedAt: dateSchema.refine(
+        (date) => date instanceof Date && date <= new Date(),
+        { message: 'date cannot be in the future' },
+      ),
+      accountId: accountIdSchema,
+    }),
+  );
+export type CompliancePostDisbursementTransactionZod = z.infer<
+  typeof CompliancePostDisbursementTransactionZod
+>;

package/src/common/types/disbursements.types.ts

@@ -0,0 +1,310 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { IOffering, offeringIdSchema } from './offering.types';
+import {
+  AccountZod,
+  BaseStatus,
+  ComplianceReview,
+  dateSchema,
+  IPaginationMeta,
+} from './common.types';
+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 { userIdSchema, UserZod } from './user.types';
+import {
+  PostDisbursementAdjustmentZod,
+  DisbursementAdjustmentType,
+} from './disbursement-adjustment.types';
+import { escrowAccountIdSchema } from './escrow-account.types';
+
+export const disbursementIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'disbursement';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid disbursement ID format. Must be a valid TypeID with "disbursement" prefix.',
+  },
+);
+
+export enum DisbursementStatus {
+  PENDING = BaseStatus.PENDING,
+  APPROVED = BaseStatus.APPROVED,
+  REJECTED = BaseStatus.REJECTED,
+  SETTLED = BaseStatus.SETTLED,
+  COMPLETED = BaseStatus.COMPLETED,
+}
+
+export const DisbursementZod = IBaseEntity.extend({
+  name: z.string().openapi({ example: 'Dalmore' }),
+  status: z
+    .nativeEnum(DisbursementStatus)
+    .openapi({ example: DisbursementStatus.PENDING }),
+  requestedAmount: z.number().openapi({ example: 100 }),
+  netAmount: z.number().openapi({ example: 1000 }),
+  complianceReview: z.nativeEnum(ComplianceReview),
+  approversCount: z.number(),
+  disbursedAt: z.date().nullable(),
+  accountId: accountIdSchema,
+  account: z
+    .lazy(() => AccountZod)
+    .optional()
+    .nullable(),
+  offeringId: offeringIdSchema,
+  offering: z
+    .lazy(() => IOffering)
+    .optional()
+    .nullable(),
+  createdById: userIdSchema,
+  createdBy: UserZod.optional().nullable(),
+  reviewedById: z
+    .string()
+    .nullable()
+    .openapi({ example: 'user_00041061050r3gg28a1c60t3gf' }),
+});
+
+export type DisbursementZod = z.infer<typeof DisbursementZod>;
+
+export const PostDisbursementTrades = z.object({
+  accountId: accountIdSchema.openapi({
+    example: 'account_00041061050r3gg28a1c60t3gf',
+  }),
+  name: z.string().openapi({ example: 'Dalmore' }),
+  offeringId: z
+    .lazy(() => offeringIdSchema)
+    .openapi({
+      example: 'offering_00041061050r3gg28a1c60t3gf',
+    }),
+  trades: z
+    .array(tradeIdSchema)
+    .min(1, 'At least one trade is required')
+    .max(500, 'Maximum of 500 trades allowed')
+    .openapi({
+      example: [
+        'trade_00041061050r3gg28a1c60t3gf',
+        'trade_00041061050r3gg28a1c60t3g',
+      ],
+    }),
+});
+export type PostDisbursementTrades = z.infer<typeof PostDisbursementTrades>;
+
+export const PostDisbursementOfferings = z.object({
+  accountId: accountIdSchema.openapi({
+    example: 'account_00041061050r3gg28a1c60t3gf',
+  }),
+  name: z.string().openapi({ example: 'Dalmore' }),
+  offeringId: z
+    .lazy(() => offeringIdSchema)
+    .openapi({
+      example: 'offering_00041061050r3gg28a1c60t3gf',
+    }),
+});
+export type PostDisbursementOfferings = z.infer<
+  typeof PostDisbursementOfferings
+>;
+
+export const DisbursementFiltersZod = z.object({
+  name: z.string().optional(),
+  offeringId: z.lazy(() => offeringIdSchema).optional(),
+  issuerId: z.lazy(() => issuerIdSchema).optional(),
+  search: z.string().optional(),
+  status: z
+    .nativeEnum(DisbursementStatus)
+    .optional()
+    .openapi({ example: 'PENDING' }),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  accountId: accountIdSchema.optional(),
+});
+
+export const IPaginatedDisbursement = z.object({
+  items: z.array(DisbursementZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDisbursement = z.infer<typeof IPaginatedDisbursement>;
+
+export const disbursementsInclude = z.enum([
+  'createdBy',
+  'reviewedBy',
+  'offering',
+  'account',
+  'issuerBankAccount',
+  'escrowAccount',
+  'disbursementAdjustments',
+  'tradeDisbursements',
+  'disbursementReviews',
+  'disbursementTransactions',
+  'issuer',
+]);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(DisbursementsIncludeQuery),
+ */
+export const DisbursementsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          disbursementsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${disbursementsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${disbursementsInclude.options.join(',')}`,
+    }),
+});
+export interface DisbursementsIncludeQuery
+  extends z.infer<typeof DisbursementsIncludeQuery> {}
+
+export const PostDisbursementZod = z.object({
+  name: z.string().max(50).openapi({ example: 'Dalmore' }),
+  offeringId: z
+    .lazy(() => offeringIdSchema)
+    .openapi({
+      example: 'offering_00041061050r3gg28a1c60t3gf',
+    }),
+  issuerId: z
+    .lazy(() => issuerIdSchema)
+    .openapi({
+      example: 'issuer_00041061050r3gg28a1c60t3gf',
+    }),
+  issuerBankAccountId: z
+    .lazy(() => issuerBankAccountIdSchema)
+    .openapi({
+      example: 'issuer_bank_account_00041061050r3gg28a1c60t3gf',
+    }),
+  requestedAmount: z
+    .number()
+    .min(0.01)
+    .max(10000000000)
+    .openapi({ example: 2000 }),
+  netAmount: z.number().min(0.01).max(10000000000).openapi({ example: 5000 }),
+  disbursedAt: dateSchema.optional().nullable(),
+  tradeIds: z.array(tradeIdSchema).min(1).max(100),
+  disbursementAdjustments: z.array(PostDisbursementAdjustmentZod).refine(
+    (adjustments) => {
+      const adjustmentTypes = adjustments.map((adj) => adj.type);
+      const requiredTypes = Object.values(DisbursementAdjustmentType);
+      return requiredTypes.every((type) => adjustmentTypes.includes(type));
+    },
+    {
+      message: `All disbursement adjustments are required: ${Object.values(DisbursementAdjustmentType).join(', ')}`,
+    },
+  ),
+  escrowAccountId: z.lazy(() => escrowAccountIdSchema),
+});
+export type PostDisbursementZod = z.infer<typeof PostDisbursementZod>;
+
+export const CompliancePostDisbursementZod = PostDisbursementZod.extend({
+  accountId: accountIdSchema,
+});
+export type CompliancePostDisbursementZod = z.infer<
+  typeof CompliancePostDisbursementZod
+>;
+
+export const DisbursementsMissingConfigQuery = z.object({
+  accountId: accountIdSchema.optional(),
+});
+export interface DisbursementsMissingConfigQuery
+  extends z.infer<typeof DisbursementsMissingConfigQuery> {}
+
+export const DisbursementMissingConfigZod = z.object({
+  missingConfigurations: z.array(z.string()),
+});
+
+export type DisbursementMissingConfigZod = z.infer<
+  typeof DisbursementMissingConfigZod
+>;
+
+export const DisbursementSigningLinkZod = z.string().nullable();
+
+export type DisbursementSigningLinkZod = z.infer<
+  typeof DisbursementSigningLinkZod
+>;
+
+export const ComplianceReviewDisbursements = z.object({
+  complianceReview: z.enum([
+    ComplianceReview.APPROVED,
+    ComplianceReview.REJECTED,
+  ]),
+  disbursements: z
+    .array(disbursementIdSchema)
+    .min(1, 'At least one disbursement is required')
+    .max(50, 'Maximum of 50 disbursements allowed')
+    .openapi({
+      example: [
+        'disbursement_01jjsdrx1seqfse7z4z47sgdp5',
+        'disbursement_01jjsdrx27enkszq5cnc3hdhrf',
+      ],
+    }),
+});
+export type ComplianceReviewDisbursements = z.infer<
+  typeof ComplianceReviewDisbursements
+>;
+
+export const TradeDisbursementZod = z.object({
+  id: z
+    .lazy(() => disbursementIdSchema)
+    .openapi({
+      example: 'disbursement_00041061050r3gg28a1c60t3gf',
+    }),
+  name: z.string().openapi({ example: 'Disbursement Name' }),
+  status: z
+    .nativeEnum(DisbursementStatus)
+    .openapi({ example: DisbursementStatus.PENDING }),
+  date: z.date().nullable().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type TradeDisbursementZod = z.infer<typeof TradeDisbursementZod>;
+
+export const TradeDisbursementsZod = z.array(TradeDisbursementZod);
+export type TradeDisbursementsZod = z.infer<typeof TradeDisbursementsZod>;
+
+export const PostDisbursementBalanceZod = z.object({
+  offeringId: offeringIdSchema,
+});
+export type PostDisbursementBalanceZod = z.infer<
+  typeof PostDisbursementBalanceZod
+>;
+
+export const PostDisbursementSummaryZod = z.object({
+  offeringId: offeringIdSchema,
+  tradeIds: z.array(tradeIdSchema).min(1).max(1000),
+});
+export type PostDisbursementSummaryZod = z.infer<
+  typeof PostDisbursementSummaryZod
+>;
+
+export const DisbursementBalanceZod = z.object({
+  contingencyAmount: z.number(),
+  contingencyStatus: z.string(),
+  totalRaised: z.number(),
+  totalDisbursed: z.number(),
+  totalPending: z.number(),
+  totalFees: z.number(),
+  refundPool: z.number(),
+  availableForDisbursements: z.number(),
+});
+export type DisbursementBalanceZod = z.infer<typeof DisbursementBalanceZod>;
+
+export const DisbursementSummaryZod = z.object({
+  amountRequested: z.number(),
+  brokerageFee: z.number(),
+  disbursementFee: z.number(),
+  refundPool: z.number(),
+  amountToBeTransferred: z.number(),
+});
+export type DisbursementSummaryZod = z.infer<typeof DisbursementSummaryZod>;

package/src/common/types/domain-filter.types.ts

@@ -0,0 +1,55 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { DomainSchema, IPaginationMeta } from './common.types';
+extendZodWithOpenApi(z);
+export const domainFilterIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'domain_filter';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid domain filter ID format. Must be a valid TypeID with "domain_filter" prefix. Example: domain_filter_01j5y5ghx5fg68d663j1fvy2x7',
+  },
+);
+export const DomainFilterZod = IBaseEntity.extend({
+  id: domainFilterIdSchema,
+  domain: z.string(),
+});
+export type DomainFilterZod = z.infer<typeof DomainFilterZod>;
+
+export const IPaginatedDomainFilter = z.object({
+  items: z.array(DomainFilterZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDomainFilter = z.infer<typeof IPaginatedDomainFilter>;
+
+export const PostDomainFilterZod = z.object({
+  domain: DomainSchema.openapi({ example: 'dalmoregroup.com' }),
+});
+export type PostDomainFilterZod = z.infer<typeof PostDomainFilterZod>;
+
+export const PatchDomainFilterZod = PostDomainFilterZod.extend({});
+export type PatchDomainFilterZod = z.infer<typeof PatchDomainFilterZod>;
+
+export const DomainFilterFiltersZod = z.object({
+  domain: z
+    .string()
+    .max(30)
+    .optional()
+    .openapi({ example: 'dalmoregroup.com' }),
+});
+export type DomainFilterFiltersZod = z.infer<typeof DomainFilterFiltersZod>;
+
+export const DomainFilterDeleteResponseZod = z.object({
+  message: z.string(),
+});
+export type DomainFilterDeleteResponseZod = z.infer<
+  typeof DomainFilterDeleteResponseZod
+>;