@dalmore/api-contracts 0.0.0-dev.eb820f7 → 0.0.0-dev.f0b9301

package/common/types/escrow-account.types.ts

@@ -1,104 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import { AccountZod, IPaginationMeta } from './common.types';
-import { IBaseEntity } from './entity.types';
-import { TypeID } from 'typeid-js';
-import { accountIdSchema } from './account.types';
-
-extendZodWithOpenApi(z);
-
-export const escrowAccountIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'escrow_account';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid escrow account ID format. Must be a valid TypeID with "escrow_account" prefix.',
-  },
-);
-
-export const IEscrowAccount = IBaseEntity.extend({
-  accountNumber: z.string().optional().nullable(),
-  routingNumber: z.string().optional().nullable(),
-  accountName: z.string(),
-  agentEmail: z.string(),
-  agentName: z.string(),
-  accountId: accountIdSchema,
-  account: AccountZod.optional().nullable(),
-});
-export type IEscrowAccount = z.infer<typeof IEscrowAccount>;
-
-export const IPaginatedEscrowAccount = z.object({
-  items: z.array(IEscrowAccount),
-  meta: IPaginationMeta,
-});
-export type IPaginatedEscrowAccount = z.infer<typeof IPaginatedEscrowAccount>;
-export const PostEscrowAccount = z.object({
-  accountName: z.string().min(2).max(50).openapi({ example: 'Bulk' }),
-  accountNumber: z.string().optional().nullable(),
-  routingNumber: z.string().min(9).max(9).optional().nullable(),
-  agentName: z.string().min(2).max(50),
-  agentEmail: z.string().email(),
-});
-
-export type PostEscrowAccount = z.infer<typeof PostEscrowAccount>;
-
-export const CompliancePostEscrowAccount = PostEscrowAccount.extend({
-  accountId: accountIdSchema,
-});
-export type CompliancePostEscrowAccount = z.infer<
-  typeof CompliancePostEscrowAccount
->;
-
-export const PatchEscrowAccount = z.object({
-  accountName: z
-    .string()
-    .min(2)
-    .max(50)
-    .openapi({ example: 'Bulk' })
-    .optional(),
-  accountNumber: z.string().min(10).max(18).optional().nullable().optional(),
-  routingNumber: z.string().min(9).max(9).optional().nullable().optional(),
-  agentName: z.string().min(2).max(50).optional(),
-  agentEmail: z.string().email().optional(),
-});
-
-export type PatchEscrowAccount = z.infer<typeof PatchEscrowAccount>;
-
-const escrowAccountsInclude = z.enum(['account']);
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(EscrowAccountsIncludeQuery),
- */
-export const EscrowAccountsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          escrowAccountsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${escrowAccountsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${escrowAccountsInclude.options.join(',')}`,
-    }),
-});
-export interface EscrowAccountsIncludeQuery
-  extends z.infer<typeof EscrowAccountsIncludeQuery> {}
-
-export const EscrowAccountsFilter = z.object({
-  accountId: accountIdSchema.optional(),
-  search: z.string().optional(),
-});
-export interface EscrowAccountsFilter
-  extends z.infer<typeof EscrowAccountsFilter> {}

package/common/types/exchange-api-key.types.ts

@@ -1,121 +0,0 @@
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import { accountIdSchema } from './account.types';
-import { ExchangeProvider, IPaginationMeta } from './common.types';
-import { IBaseEntity } from './entity.types';
-import { ApiMessageSchema } from './north-cap-integration.types';
-
-/**
- * Generic API Message schema that can be extended with more provider-specific message types
- */
-export const APIMessage = ApiMessageSchema;
-export type APIMessage = z.infer<typeof APIMessage>;
-
-export enum ExchangeApiKeyStatus {
-  PENDING = 'PENDING',
-  ACTIVE = 'ACTIVE',
-  VERIFIED = 'VERIFIED',
-}
-
-export const exchangeApiKeyIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'exchange_api_key';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid exchange api key ID format. Must be a valid TypeID with "exchange_api_key" prefix.',
-  },
-);
-
-export const ExchangeApiKey = IBaseEntity.extend({
-  id: exchangeApiKeyIdSchema,
-  accountId: z.string(),
-  apiKey: z.string(),
-  clientId: z.string(),
-  baseUrl: z.string(),
-  environment: z.string().nullable(),
-  provider: z.nativeEnum(ExchangeProvider),
-  isActive: z.boolean(),
-  status: z
-    .nativeEnum(ExchangeApiKeyStatus)
-    .default(ExchangeApiKeyStatus.PENDING),
-  apiMessage: APIMessage.nullable(),
-});
-export type ExchangeApiKey = z.infer<typeof ExchangeApiKey>;
-
-export const PostExchangeApiKey = z.object({
-  provider: z.nativeEnum(ExchangeProvider),
-  apiKey: z.string(),
-  clientId: z.string(),
-});
-export type PostExchangeApiKey = z.infer<typeof PostExchangeApiKey>;
-export const AdminPostExchangeApiKey = PostExchangeApiKey.extend({
-  accountId: accountIdSchema,
-  environment: z.string().optional(),
-});
-export type AdminPostExchangeApiKey = z.infer<typeof AdminPostExchangeApiKey>;
-
-export const PaginatedExchangeApiKeys = z.object({
-  items: z.array(ExchangeApiKey),
-  meta: IPaginationMeta,
-});
-export type PaginatedExchangeApiKeys = z.infer<typeof PaginatedExchangeApiKeys>;
-
-export const UpdateExchangeApiKey = z.object({
-  provider: z.nativeEnum(ExchangeProvider),
-  apiKey: z.string(),
-  clientId: z.string(),
-  status: z.nativeEnum(ExchangeApiKeyStatus).optional(),
-  apiMessage: APIMessage.nullable().optional(),
-});
-export type UpdateExchangeApiKey = z.infer<typeof UpdateExchangeApiKey>;
-
-const exchangeApiKeysInclude = z.enum(['account']);
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(ExchangeApiKeysIncludeQuery),
- */
-export const ExchangeApiKeysIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          exchangeApiKeysInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${exchangeApiKeysInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${exchangeApiKeysInclude.options.join(',')}`,
-    }),
-});
-export interface ExchangeApiKeysIncludeQuery
-  extends z.infer<typeof ExchangeApiKeysIncludeQuery> {}
-
-export const ExchangeApiKeysFilter = z.object({
-  accountId: accountIdSchema.optional(),
-  provider: z.nativeEnum(ExchangeProvider).optional(),
-});
-
-export interface ExchangeApiKeysFilter
-  extends z.infer<typeof ExchangeApiKeysFilter> {}
-
-/**
- * Status response for exchange API key
- * Returns only the status field
- */
-export const ExchangeApiKeyStatusResponse = z.object({
-  status: z.nativeEnum(ExchangeApiKeyStatus),
-});
-export type ExchangeApiKeyStatusResponse = z.infer<
-  typeof ExchangeApiKeyStatusResponse
->;

package/common/types/exchange-import.types.ts

@@ -1,36 +0,0 @@
-import { z } from 'zod';
-import { accountIdSchema } from './account.types';
-
-const exchangeImportsInclude = z.enum(['account']);
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(ExchangeImportsIncludeQuery),
- */
-export const ExchangeImportsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          exchangeImportsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${exchangeImportsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${exchangeImportsInclude.options.join(',')}`,
-    }),
-});
-
-export interface ExchangeImportsIncludeQuery
-  extends z.infer<typeof ExchangeImportsIncludeQuery> {}
-
-export const ExchangeImportsFilter = z.object({
-  accountId: accountIdSchema.optional(),
-});
-
-export interface ExchangeImportsFilter
-  extends z.infer<typeof ExchangeImportsFilter> {}

package/common/types/exchange-provider.types.ts

@@ -1,329 +0,0 @@
-import { z } from 'zod';
-import { TypeID } from 'typeid-js';
-import { IBaseEntity } from './entity.types';
-import { accountIdSchema } from './account.types';
-import {
-  ComplianceReview,
-  ExchangeProvider,
-  IPaginationMeta,
-  RunnerType,
-} from './common.types';
-import { secureRequestIdSchema } from './secure-request.types';
-
-export const exchangeImportIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'exchange_import';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid exchange import ID format. Must be a valid TypeID with "exchange_import" prefix.',
-  },
-);
-
-export enum ExchangeImportFrequency {
-  DAILY = 'DAILY',
-  WEEKLY = 'WEEKLY',
-  MONTHLY = 'MONTHLY',
-  EXTERNAL = 'EXTERNAL',
-}
-
-export const ExchangeImport = IBaseEntity.extend({
-  id: exchangeImportIdSchema,
-  accountId: accountIdSchema,
-  frequency: z.enum([
-    ExchangeImportFrequency.DAILY,
-    ExchangeImportFrequency.WEEKLY,
-    ExchangeImportFrequency.MONTHLY,
-    ExchangeImportFrequency.EXTERNAL,
-  ]),
-  provider: z.nativeEnum(ExchangeProvider),
-  isActive: z.boolean(),
-  runner: z.nativeEnum(RunnerType).default(RunnerType.WORKER),
-  secureRequestId: secureRequestIdSchema.nullable(),
-  primaries: z.boolean().default(false),
-  secondaries: z.boolean().default(false),
-});
-export type ExchangeImport = z.infer<typeof ExchangeImport>;
-
-export const PaginatedExchangeImports = z.object({
-  items: z.array(ExchangeImport),
-  meta: IPaginationMeta,
-});
-export type PaginatedExchangeImports = z.infer<typeof PaginatedExchangeImports>;
-
-export const PostAdminExchangeImport = z.object({
-  frequency: z.enum([
-    ExchangeImportFrequency.DAILY,
-    ExchangeImportFrequency.WEEKLY,
-    ExchangeImportFrequency.MONTHLY,
-    ExchangeImportFrequency.EXTERNAL,
-  ]),
-  provider: z.nativeEnum(ExchangeProvider),
-  accountId: accountIdSchema,
-  runner: z.nativeEnum(RunnerType).default(RunnerType.WORKER).optional(),
-  secureRequestId: secureRequestIdSchema.nullable().optional(),
-  primaries: z.boolean().default(false).optional(),
-  secondaries: z.boolean().default(false).optional(),
-});
-export type PostAdminExchangeImport = z.infer<typeof PostAdminExchangeImport>;
-
-export const UpdateExchangeImport = z.object({
-  isActive: z.boolean(),
-});
-export type UpdateExchangeImport = z.infer<typeof UpdateExchangeImport>;
-
-export const TriggerExchangeImport = z.object({});
-export type TriggerExchangeImport = z.infer<typeof TriggerExchangeImport>;
-
-// https://transactapi.readme.io/reference/createorder
-export const CreateOrderRequest = z.object({
-  memberid: z.string(),
-  issuerid: z.string(),
-  accountid: z.string().optional(),
-  securityid: z.string(),
-  type: z.enum(['Limit', 'RFQ']),
-  action: z.enum(['Buy', 'Sell']),
-  quantity: z.number().int().positive(),
-  price: z.number().positive(),
-  expiration: z.enum(['GTC', 'Day', 'Other']),
-  expirationDate: z.date().optional(),
-  disclosePrice: z.enum(['Yes', 'No']),
-  contingencies: z.enum(['All or None', 'Minimum Quantity', '']).optional(),
-  minimumThreshold: z.number().int().optional(),
-  solicited: z.enum(['Solicited', 'Unsolicited']),
-  token: z.string().optional(),
-});
-export type CreateOrderRequest = z.infer<typeof CreateOrderRequest>;
-
-export const CreateOrderResponse = z.object({
-  statusCode: z.string(),
-  statusDesc: z.string(),
-  orderid: z.string(),
-  orderStatus: z.enum([
-    'Pending',
-    'Live',
-    'Rejected',
-    'Cancelled',
-    'Partially Executed',
-    'Executed',
-  ]),
-  token: z.string().optional(),
-});
-export type CreateOrderResponse = z.infer<typeof CreateOrderResponse>;
-
-// PPEX Order types
-// https://transactapi.readme.io/reference/ppexorders
-export const PpexOrderZod = z.object({
-  securityId: z.string(),
-  securityName: z.string(),
-  expirationType: z.string(),
-  expirationDate: z.string(),
-  memberId: z.string(),
-  orderId: z.string(),
-  accountId: z.string(),
-  accountName: z.string(),
-  securityType: z.string(),
-  shares: z.string(),
-  remainingShares: z.string(),
-  sharePrice: z.string(),
-  amount: z.string(),
-  priceNotDisplayed: z.string(),
-  allOrNone: z.string(),
-  status: z.string(),
-  type: z.string(),
-  tradeStatus: z.string(),
-  orderStatus: z.string(),
-  tradeOrderStatus: z.string(),
-  negotiationStatus: z.string(),
-  deleted: z.string(),
-  createdDate: z.string(),
-  updatedBy: z.string(),
-  updatedDate: z.string(),
-  executionTime: z.string(),
-  contingencies: z.string(),
-  solicited: z.string(),
-  minimumQuantity: z.string(),
-  operationHrStatus: z.string(),
-  origination: z.string(),
-  cancelDate: z.string().optional(),
-  cancelExecutionTime: z.string(),
-  token: z.string(),
-});
-
-// PPEX Trade types
-// https://transactapi.readme.io/reference/ppextrades
-export const PpexTradeZod = z.object({
-  memberId: z.string(),
-  bidId: z.string(),
-  askId: z.string(),
-  offeringId: z.string(),
-  accountId: z.string(),
-  partyType: z.string(),
-  tradeId: z.string(),
-  transactionType: z.string(),
-  amount: z.string(),
-  sharePrice: z.string(),
-  shares: z.string(),
-  status: z.string(),
-  reportingStatus: z.string(),
-  createdDate: z.string(),
-  deleted: z.string(),
-  executionTime: z.string(),
-  updatedDate: z.string().nullable(),
-});
-
-export const GetOrdersResponseZod = z.object({
-  statusCode: z.string(),
-  statusDesc: z.string(),
-  ppex_orders: z.array(PpexOrderZod),
-  pagination: z.object({
-    totalRecords: z.number(),
-    startIndex: z.number(),
-    endIndex: z.number(),
-  }),
-});
-
-export const GetTradesResponseZod = z.object({
-  statusCode: z.string(),
-  statusDesc: z.string(),
-  ppex_trades: z.array(PpexTradeZod),
-  pagination: z.object({
-    totalRecords: z.number(),
-    startIndex: z.number(),
-    endIndex: z.number(),
-  }),
-});
-
-export const GetOrdersRequestZod = z.object({
-  limit: z.number().optional(),
-  offset: z.number().optional(),
-  filter: z.record(z.any()).optional(),
-  sort: z.string().optional(),
-  clientId: z.string(),
-  apiKey: z.string(),
-  baseUrl: z.string(),
-});
-
-export const GetTradesRequestZod = z.object({
-  limit: z.number().optional(),
-  offset: z.number().optional(),
-  filter: z.record(z.any()).optional(),
-  sort: z.string().optional(),
-  deleted: z.boolean().optional(),
-  clientId: z.string(),
-  apiKey: z.string(),
-  baseUrl: z.string(),
-});
-
-export type PpexOrder = z.infer<typeof PpexOrderZod>;
-export type PpexTrade = z.infer<typeof PpexTradeZod>;
-export type GetOrdersResponse = z.infer<typeof GetOrdersResponseZod>;
-export type GetTradesResponse = z.infer<typeof GetTradesResponseZod>;
-export type GetOrdersRequest = z.infer<typeof GetOrdersRequestZod>;
-export type GetTradesRequest = z.infer<typeof GetTradesRequestZod>;
-
-// Will extend for other exchanges if needed
-export type RawOrderData = PpexOrder;
-export type RawTradeData = PpexTrade;
-
-// PPEX Account types
-// https://transactapi.readme.io/reference/accounts
-export const PpexAccountZod = z.object({
-  accountId: z.string(),
-  accountName: z.string().nullable(),
-  type: z.string().nullable(),
-  entityType: z.string().nullable(),
-  residentType: z.string().nullable(),
-  socialSecurityNumber: z.string().nullable(),
-  address1: z.string().nullable(),
-  address2: z.string().nullable(),
-  city: z.string().nullable(),
-  state: z.string().nullable(),
-  zip: z.string().nullable(),
-  country: z.string().nullable(),
-  phone: z.string().nullable(),
-  taxID: z.string().nullable(),
-  kycStatus: z.string().nullable(),
-  kycDate: z.string().nullable(),
-  amlStatus: z.string().nullable(),
-  amlDate: z.string().nullable(),
-  suitabilityScore: z.string().nullable(),
-  suitabilityDate: z.string().nullable(),
-  suitabilityApprover: z.string().nullable(),
-  accreditedStatus: z.string().nullable(),
-  accreditedInvestor: z.string().nullable(),
-  accreditedInvestorDate: z.string().nullable(),
-  '506cLimit': z.string().nullable(),
-  accountTotalLimit: z.string().nullable(),
-  singleInvestmentLimit: z.string().nullable(),
-  associatedAC: z.string().nullable(),
-  syndicate: z.string().nullable(),
-  tags: z.string().nullable(),
-  notes: z.string().nullable(),
-  approvalStatus: z.string().nullable(),
-  approvalPrincipal: z.string().nullable(),
-  approvalLastReview: z.string().nullable(),
-  accountstatus: z.string().nullable(),
-  field1: z.string().nullable(),
-  field2: z.string().nullable(),
-  field3: z.string().nullable(),
-  createdDate: z.string().nullable(),
-  updatedDate: z.string().nullable(),
-});
-
-export const GetAccountsResponseZod = z.object({
-  statusCode: z.string(),
-  statusDesc: z.string(),
-  accounts: z.array(PpexAccountZod),
-  pagination: z.object({
-    totalRecords: z.number(),
-    startIndex: z.number(),
-    endIndex: z.number(),
-  }),
-});
-
-export const GetAccountsRequestZod = z.object({
-  limit: z.number().optional(),
-  offset: z.number().optional(),
-  deleted: z.boolean().optional(),
-  clientId: z.string(),
-  apiKey: z.string(),
-  baseUrl: z.string(),
-});
-
-export type PpexAccount = z.infer<typeof PpexAccountZod>;
-export type GetAccountsResponse = z.infer<typeof GetAccountsResponseZod>;
-export type GetAccountsRequest = z.infer<typeof GetAccountsRequestZod>;
-
-// Will extend for other exchanges if needed
-export type RawAccountData = PpexAccount;
-
-export const SecondaryTradesSummaryFiltersZod = z.object({
-  accountId: accountIdSchema.optional(),
-  complianceReview: z.nativeEnum(ComplianceReview).optional(),
-});
-export type SecondaryTradesSummaryFilters = z.infer<
-  typeof SecondaryTradesSummaryFiltersZod
->;
-
-export const SecondaryTradeSummaryResponseZod = z.object({
-  accountId: accountIdSchema,
-  accountName: z.string(),
-  tradesCount: z.number(),
-});
-export type SecondaryTradeSummaryResponse = z.infer<
-  typeof SecondaryTradeSummaryResponseZod
->;
-
-export const PaginatedSecondaryTradeSummaryResponseZod = z.object({
-  items: z.array(SecondaryTradeSummaryResponseZod),
-  meta: IPaginationMeta,
-});
-export type PaginatedSecondaryTradeSummaryResponse = z.infer<
-  typeof PaginatedSecondaryTradeSummaryResponseZod
->;