@dalmore/api-contracts 0.0.0-dev.ab1033d → 0.0.0-dev.ade8992

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

@@ -1,100 +0,0 @@
-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/common/types/disbursement-review.types.ts

@@ -1,110 +0,0 @@
-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/common/types/disbursement-transaction.types.ts

@@ -1,72 +0,0 @@
-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/common/types/disbursements.types.ts

@@ -1,310 +0,0 @@
-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/common/types/domain-filter.types.ts

@@ -1,55 +0,0 @@
-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
->;