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

package/common/types/investors-offering.types.ts

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-import { AccountZod, IPaginationMeta, OfferingType } from './common.types';
-import { IBaseEntity } from './entity.types';
-import { accountIdSchema } from './account.types';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-extendZodWithOpenApi(z);
-
-export const InvestorsOffering = IBaseEntity.extend({
-  name: z.string(),
-  tid: z.string().nullable(),
-  type: z.nativeEnum(OfferingType).nullable(),
-  raiseAmount: z.coerce.number().nullable(),
-  minInvestment: z.coerce.number().nullable(),
-  maxInvestment: z.coerce.number().nullable(),
-  contingencyAmount: z.coerce.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(),
-});
-export type InvestorsOffering = z.infer<typeof InvestorsOffering>;
-
-export const InvestorsPaginatedOffering = z.object({
-  items: z.array(InvestorsOffering),
-  meta: IPaginationMeta,
-});
-export type InvestorsPaginatedOffering = z.infer<
-  typeof InvestorsPaginatedOffering
->;
-
-const investorsOfferingsInclude = z.enum(['account', 'assets', 'issuer']);
-
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
- */
-export const InvestorsOfferingsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          investorsOfferingsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${investorsOfferingsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${investorsOfferingsInclude.options.join(',')}`,
-    }),
-});
-export interface InvestorsOfferingsIncludeQuery
-  extends z.infer<typeof InvestorsOfferingsIncludeQuery> {}
-
-export const InvestorsOfferingFiltersZod = z.object({
-  name: z.string().optional(),
-  accountId: accountIdSchema.optional(),
-  issuerId: z.string().optional(),
-});

package/common/types/invite.types.ts

@@ -1,133 +0,0 @@
-import { z } from 'zod';
-import {
-  AccountZod,
-  IPaginationMeta,
-  IssuerRole,
-  UserRole,
-} from './common.types';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-import { roleIdSchema, RoleZod } from './role.types';
-import { accountIdSchema } from './account.types';
-extendZodWithOpenApi(z);
-export const inviteIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'invite';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: `Invalid invite ID format. Must be a valid TypeID with "invite" prefix. Example: invite_01j5y5ghx5fg68d663j1fvy2x7`,
-  },
-);
-export const InviteWithoutSecretZod = z.object({
-  id: z.string(),
-  email: z.string().email(),
-  code: z.string(),
-  roleId: roleIdSchema.nullable(),
-  role: RoleZod.nullable().optional(),
-  used: z.boolean(),
-  createdAt: z.date(),
-  updatedAt: z.date(),
-  deletedAt: z.date().nullable(),
-  account: AccountZod.nullable().optional(),
-});
-export type InviteWithoutSecretZod = z.infer<typeof InviteWithoutSecretZod>;
-export const IPaginatedInvite = z.object({
-  items: z.array(InviteWithoutSecretZod),
-  meta: IPaginationMeta,
-});
-export type InviteWithSecretZod = z.infer<typeof InviteWithoutSecretZod>;
-
-export const InviteWithUrl = InviteWithoutSecretZod.extend({
-  url: z.string(),
-});
-export type InviteWithUrl = z.infer<typeof InviteWithUrl>;
-
-export const PostIssuerInviteZod = z.object({
-  email: z.string().email(),
-  role: z.nativeEnum(IssuerRole),
-});
-
-export type PostIssuerInviteZod = z.infer<typeof PostIssuerInviteZod>;
-
-export const IssuerInvitesFiltersZod = z.object({
-  role: z
-    .nativeEnum(UserRole)
-    .optional()
-    .refine((role) => !role || Object.values(UserRole).includes(role), {
-      message: 'Role must be a valid issuer role, such as OWNER or MARKETER',
-    }),
-  used: z
-    .string()
-    .optional()
-    .transform((val) => {
-      if (val === 'true') return true;
-      if (val === 'false') return false;
-      if (val === '') return undefined;
-      return;
-    }),
-  email: z.string().optional(),
-});
-
-export type IssuerInvitesFiltersZod = z.infer<typeof IssuerInvitesFiltersZod>;
-
-export const IssuerVerifyInviteResponse = z.object({
-  valid: z.boolean(),
-  email: z.string().email().nullable(),
-  existingLogin: z.boolean().nullable().optional(),
-  accountName: z.string().nullable().optional(),
-});
-
-export type IssuerVerifyInviteResponse = z.infer<
-  typeof IssuerVerifyInviteResponse
->;
-
-export const IssuerInvitesDecisionResponse = z.object({
-  message: z.string(),
-});
-export type IssuerInvitesDecisionResponse = z.infer<
-  typeof IssuerInvitesDecisionResponse
->;
-
-const invitesInclude = z.enum(['user', 'role']);
-
-export const InvitesIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          invitesInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${invitesInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${invitesInclude.options.join(',')}`,
-    }),
-});
-
-export const PatchInviteRoleZod = z.object({
-  role: z.nativeEnum(UserRole).openapi({
-    example: UserRole.OWNER,
-  }),
-});
-
-export type PatchInviteRoleZod = z.infer<typeof PatchInviteRoleZod>;
-
-export const PatchInviteForComplianceZod = PatchInviteRoleZod.extend({
-  accountId: accountIdSchema.optional().openapi({
-    example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
-  }),
-});
-
-export type PatchInviteForComplianceZod = z.infer<
-  typeof PatchInviteForComplianceZod
->;

package/common/types/issuer-bank-account.types.ts

@@ -1,107 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import { AccountZod, IPaginationMeta } from './common.types';
-import { IBaseEntity } from './entity.types';
-import { IIssuer, issuerIdSchema } from './issuer.types';
-import { TypeID } from 'typeid-js';
-import { accountIdSchema } from './account.types';
-
-extendZodWithOpenApi(z);
-
-export const issuerBankAccountIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'issuer_bank_account';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid issuer ID format. Must be a valid TypeID with "issuer_bank_account" prefix.',
-  },
-);
-
-export const IIssuerBankAccount = IBaseEntity.extend({
-  accountNumber: z.string(),
-  accountHolder: z.string(),
-  routingNumber: z.string(),
-  nickName: z.string(),
-  accountId: z.string(),
-  account: AccountZod.optional().nullable(),
-  issuerId: issuerIdSchema,
-  issuer: z
-    .lazy(() => IIssuer)
-    .optional()
-    .nullable(),
-});
-export type IIssuerBankAccount = z.infer<typeof IIssuerBankAccount>;
-
-export const IPaginatedIssuerBankAccount = z.object({
-  items: z.array(IIssuerBankAccount),
-  meta: IPaginationMeta,
-});
-export type IPaginatedIssuerBankAccount = z.infer<
-  typeof IPaginatedIssuerBankAccount
->;
-export const PostIssuerBankAccount = z.object({
-  accountId: accountIdSchema.optional(),
-  issuerId: z.lazy(() => issuerIdSchema),
-  nickName: z.string().min(2).max(50).openapi({ example: 'Bulk' }),
-  accountNumber: z
-    .string()
-    .min(10, 'Account number must be at least 10 digits')
-    .max(18, 'Account number must not exceed 18 digits'),
-  routingNumber: z.string().min(9).max(9),
-  accountHolder: z.string().min(2).max(50),
-});
-
-export type PostIssuerBankAccount = z.infer<typeof PostIssuerBankAccount>;
-
-const issuerBankAccountsInclude = z.enum([
-  'account',
-  'issuer',
-  'transactions',
-  'disbursements',
-]);
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(IssuerBankAccountsIncludeQuery),
- */
-export const IssuerBankAccountsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          issuerBankAccountsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${issuerBankAccountsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${issuerBankAccountsInclude.options.join(',')}`,
-    }),
-});
-export interface IssuerBankAccountsIncludeQuery
-  extends z.infer<typeof IssuerBankAccountsIncludeQuery> {}
-
-export const IssuerBankAccountsFilter = z.object({
-  issuerId: z.lazy(() => issuerIdSchema).optional(),
-  accountId: accountIdSchema.optional(),
-  search: z.string().optional(),
-});
-export interface IssuerBankAccountsFilter
-  extends z.infer<typeof IssuerBankAccountsFilter> {}
-
-export const PatchIssuerBankAccount = z.object({
-  nickName: z.string().min(2).max(50).optional(),
-  accountNumber: z.string().min(10).max(18).optional(),
-  routingNumber: z.string().min(9).max(9).optional(),
-  accountHolder: z.string().min(2).max(50).optional(),
-});
-export type PatchIssuerBankAccount = z.infer<typeof PatchIssuerBankAccount>;

package/common/types/issuer-offering.types.ts

@@ -1,399 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import {
-  AccountZod,
-  dateSchema,
-  IPaginationMeta,
-  OfferingType,
-  ManagedByType,
-  OfferingVersioningType,
-  ComplianceReview,
-  DurationType,
-  AssetType,
-} from './common.types';
-import { IBaseEntity } from './entity.types';
-import { IIssuer, issuerIdSchema } from './issuer.types';
-import {
-  IAsset,
-  postAssetRefinement,
-  AssetTemplateType,
-  assetIdSchema,
-} from './asset.types';
-import { fileIdSchema, FileZod } from './file.types';
-import { accountIdSchema } from './account.types';
-
-extendZodWithOpenApi(z);
-
-export enum OfferingStatus {
-  ONBOARDING = 'ONBOARDING',
-  IN_COMPLIANCE_REVIEW = 'IN_COMPLIANCE_REVIEW',
-  ACTIVE = 'ACTIVE',
-  PAUSED = 'PAUSED',
-}
-
-export const IIssuerOffering = IBaseEntity.extend({
-  name: z.string(),
-  tid: z.string().nullable(),
-  description: z.string().nullable(),
-  type: z.nativeEnum(OfferingType).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(),
-  assets: z
-    .lazy(() => z.array(IAsset))
-    .nullable()
-    .optional(), // Use z.lazy here
-  cancellationPeriod: z.number().nullable(),
-  coverArtId: z
-    .lazy(() => fileIdSchema)
-    .nullable()
-    .optional(),
-  coverArt: z.lazy(() => FileZod).nullable(),
-  memorandumId: z
-    .lazy(() => fileIdSchema)
-    .optional()
-    .nullable(),
-  subscriptionAgreementId: z
-    .lazy(() => fileIdSchema)
-    .optional()
-    .nullable(),
-  managedBy: z.nativeEnum(ManagedByType).nullable(),
-  valuationCap: z.number().nullable(),
-  showTotalRaised: z.boolean().optional(),
-  status: z.nativeEnum(OfferingStatus).optional().nullable(),
-});
-export type IIssuerOffering = z.infer<typeof IIssuerOffering>;
-
-export const IPaginatedIssuerOffering = z.object({
-  items: z.array(IIssuerOffering),
-  meta: IPaginationMeta,
-});
-export type IPaginatedIssuerOffering = z.infer<typeof IPaginatedIssuerOffering>;
-export const PostIssuerOffering = z
-  .object({
-    issuerId: issuerIdSchema,
-    name: z.string().min(2).max(100).openapi({ example: 'Airbnb IPO' }),
-    type: z.nativeEnum(OfferingType).openapi({ example: OfferingType.REG_D }),
-    targetAmount: z
-      .number()
-      .min(0.01)
-      .max(10000000000)
-      .openapi({ example: 120000 }),
-    raiseAmount: z
-      .number()
-      .min(0)
-      .max(10000000000)
-      .optional()
-      .openapi({ example: 200000 }),
-    minInvestment: z
-      .number()
-      .min(0)
-      .max(10000000000)
-      .optional()
-      .openapi({ example: 1000 }),
-    maxInvestment: z
-      .number()
-      .min(0)
-      .max(10000000000)
-      .optional()
-      .openapi({ example: 20000 }),
-    contingencyAmount: z
-      .number()
-      .min(0)
-      .max(10000000000)
-      .optional()
-      .openapi({ example: 5000 }),
-    startAt: dateSchema.optional().openapi({ example: '10/20/2024' }),
-    endAt: dateSchema.optional().openapi({ example: '10/27/2024' }),
-    active: z.boolean().optional().openapi({ example: true }),
-    cancellationPeriod: z
-      .number()
-      .min(1)
-      .max(30)
-      .openapi({ example: 4 })
-      .optional()
-      .nullable(),
-    description: z
-      .string()
-      .min(1)
-      .max(1000)
-      .optional()
-      .nullable()
-      .openapi({ example: 'This is a description of the offering.' }),
-    managedBy: z.nativeEnum(ManagedByType).optional(),
-    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(),
-  })
-  .superRefine((data, ctx) => {
-    // Check if both values are present, and if so, ensure minInvestment is less than maxInvestment
-    if (data.minInvestment && data.maxInvestment) {
-      if (data.minInvestment >= data.maxInvestment) {
-        ctx.addIssue({
-          path: ['minInvestment'],
-          message: 'Minimum investment must be less than maximum investment.',
-          code: z.ZodIssueCode.custom,
-        });
-      }
-    }
-    // Apply asset-specific refinements
-    postAssetRefinement(data, ctx);
-  });
-
-export type PostIssuerOffering = z.infer<typeof PostIssuerOffering>;
-export const PatchIssuerOffering = z.object({
-  name: z
-    .string()
-    .min(2)
-    .max(100)
-    .optional()
-    .openapi({ example: 'Airbnb IPO' }),
-  targetAmount: z
-    .number()
-    .min(0)
-    .max(10000000000)
-    .optional()
-    .openapi({ example: 120000 }),
-  raiseAmount: z
-    .number()
-    .min(0)
-    .max(10000000000)
-    .optional()
-    .openapi({ example: 200000 }),
-  minInvestment: z
-    .number()
-    .min(0)
-    .max(10000000000)
-    .optional()
-    .openapi({ example: 1000 }),
-  maxInvestment: z
-    .number()
-    .min(0)
-    .max(10000000000)
-    .optional()
-    .openapi({ example: 20000 }),
-  contingencyAmount: z
-    .number()
-    .min(0)
-    .max(10000000000)
-    .optional()
-    .openapi({ example: 5000 }),
-  startAt: dateSchema.optional().openapi({ example: '10/20/2024' }),
-  endAt: dateSchema.optional().openapi({ example: '10/27/2024' }),
-  cancellationPeriod: z
-    .number()
-    .min(1)
-    .max(30)
-    .optional()
-    .openapi({ example: 4 })
-    .nullable(),
-  description: z
-    .string()
-    .min(1)
-    .max(1000)
-    .optional()
-    .nullable()
-    .openapi({ example: 'This is a description of the offering.' }),
-  memorandumId: z
-    .lazy(() => fileIdSchema)
-    .optional()
-    .nullable(),
-  subscriptionAgreementId: z
-    .lazy(() => fileIdSchema)
-    .optional()
-    .nullable(),
-  coverArtId: z
-    .lazy(() => fileIdSchema)
-    .nullable()
-    .optional(),
-  managedBy: z.nativeEnum(ManagedByType).optional(),
-  showTotalRaised: z.boolean().optional(),
-  issuerId: issuerIdSchema.optional(),
-  assetId: assetIdSchema,
-  assetName: z.string().min(2).max(50).optional().openapi({ example: 'Z' }),
-  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(),
-  enabled: z.boolean().optional(),
-});
-export type PatchIssuerOffering = z.infer<typeof PatchIssuerOffering>;
-
-const issuerOfferingsInclude = z.enum([
-  'account',
-  'trades',
-  'issuer',
-  'assets',
-  'draftVersion',
-  'publishedVersion',
-  'revisions',
-  'onboardingReviewedBy',
-]);
-
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(UsersIncludeQuery),
- */
-export const IssuerOfferingsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          issuerOfferingsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${issuerOfferingsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${issuerOfferingsInclude.options.join(',')}`,
-    }),
-});
-export interface IssuerOfferingsIncludeQuery
-  extends z.infer<typeof IssuerOfferingsIncludeQuery> {}
-
-export const IssuerOfferingsDeleteResponse = z.object({
-  message: z.string(),
-});
-export type IssuerOfferingsDeleteResponse = z.infer<
-  typeof IssuerOfferingsDeleteResponse
->;
-export const OfferingCapTableFiltersZod = z.object({
-  startDate: dateSchema.optional(),
-  endDate: dateSchema.optional(),
-});
-export type OfferingCapTableFiltersZod = z.infer<
-  typeof OfferingCapTableFiltersZod
->;
-
-export const OfferingCapTableResponse = z.array(
-  z.object({
-    name: z.string(),
-    sharesOwned: z.coerce.number().default(0),
-    percentageOfOwnership: z.coerce.number().default(0),
-  }),
-);
-export type OfferingCapTableResponse = z.infer<typeof OfferingCapTableResponse>;
-
-export const IssuerOfferingsFilterZod = 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: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
-  managedBy: z.nativeEnum(ManagedByType).optional(),
-  versioningType: z.nativeEnum(OfferingVersioningType).optional(),
-  combinedStatus: z.nativeEnum(OfferingStatus).optional(),
-  sortByNameASC: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional().default(false),
-  ),
-});
-export type IssuerOfferingsFilterZod = z.infer<typeof IssuerOfferingsFilterZod>;