@dalmore/api-contracts 1.0.3 → 1.0.6

package/src/contracts/compliance/health/index.ts

@@ -1,26 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { InternalError } from '../../../common/types';
-import {
-  HealthCheckResponseSchema,
-  HealthErrorSchema,
-} from '../../../common/types/health.types';
-
-const c = initContract();
-
-export const healthContract = c.router(
-  {
-    getHealth: {
-      summary: 'Health Check',
-      method: 'GET',
-      path: '',
-      responses: {
-        200: HealthCheckResponseSchema,
-        500: InternalError,
-        503: HealthErrorSchema,
-      },
-    },
-  },
-  {
-    pathPrefix: 'health/',
-  },
-);

package/src/contracts/compliance/index.ts

@@ -1,147 +0,0 @@
-import { accountsContract } from './accounts';
-import { accountContactsContract } from './account-contacts';
-import { accountManagersContract } from './account-managers';
-import { activitiesContract } from './activities';
-import { apiKeysContract } from './api-keys';
-import { assetsContract } from './assets';
-import { authContract } from './auth';
-import { checkListContract } from './checklist';
-import { checkListItemsContract } from './checklist-items';
-import { coveredPersonsContract } from './covered-persons';
-import { dashboardContract } from './dashboard';
-import { dataRecordsContract } from './data-records';
-import { dataRoomsContract } from './data-rooms';
-import { disbursementApprovalUsersContract } from './disbursement-approval-users';
-import { disbursementContract } from './disbursement';
-import { disbursementTransactionsContract } from './disbursement-transactions';
-import { emailThemesContract } from './email-themes';
-import { escrowAccountsContract } from './escrow-accounts';
-import { filesContract } from './files';
-import { filesPublicContract } from './files-public';
-import { individualsContract } from './individuals';
-import { initContract } from '@ts-rest/core';
-import { investorAccountsContract } from './investor-accounts';
-import { invitesContract } from './invites';
-import { issuerBankAccountsContract } from './issuer-bank-accounts';
-import { issuerPaymentMethodsContract } from './issuer-payment-methods';
-import { issuersContract } from './issuers';
-import { jobsContract } from './jobs';
-import { kybsContract } from './kyb';
-import { kycsContract } from './kyc';
-import { legalEntitiesContract } from './legal-entities';
-import { loginHistoriesContract } from './login-histories';
-import { notesContract } from './notes';
-import { offeringsContract } from './offerings';
-import { pagesContract } from './pages';
-import { paymentMethodsContract } from './payment-methods';
-import { rejectionReasonsContract } from './rejection-reasons';
-import { reviewContract } from './review';
-import { rolesContract } from './roles';
-import { secureRequestContract } from './secure-requests';
-import { siteLinksContract } from './site-links';
-import { sitesContract } from './sites';
-import { siteSettingsContract } from './site-settings';
-import { tasksContract } from './tasks';
-import { thirdPartiesContract } from './third-parties';
-import { tradeLineItemsContract } from './trade-line-items';
-import { tradesContract } from './trades';
-import { transactionsContract } from './transactions';
-import { userManualsContract } from './user-manuals';
-import { usersContract } from './users';
-import { userSettingsContract } from './user-settings';
-import { webhooksContract } from './webhooks';
-import { domainFiltersContract } from './domain-filters';
-import { healthContract } from './health';
-import { signerContract } from './signer';
-import { secondaryCustomersContract } from './secondary-customers';
-import { secondaryOrdersContract } from './secondary-orders';
-import { batchJobsContract } from './batch-jobs';
-import { jobItemsContract } from './job-items';
-import { exchangeImportsContract } from './exchange-imports';
-import { secondaryTradesContract } from './secondary-trades';
-import { exchangeApiKeysContract } from './exchange-api-keys';
-import { notionDatabasesContract } from './notion-databases';
-import { notionPagesContract } from './notion-pages';
-import { defaultThemeConfigsContract } from './default-theme-configs';
-import { aicContract } from './aic';
-import { stateMachineContract } from './state-machine';
-import { offeringReportsContract } from './offering-reports';
-import { bonusTiersContract } from './bonus-tiers';
-
-const c = initContract();
-
-export const complianceContract = c.router(
-  {
-    accounts: accountsContract,
-    accountContacts: accountContactsContract,
-    accountManagers: accountManagersContract,
-    activities: activitiesContract,
-    apiKeys: apiKeysContract,
-    assets: assetsContract,
-    auth: authContract,
-    aic: aicContract,
-    batchJobs: batchJobsContract,
-    bonusTiers: bonusTiersContract,
-    checklist: checkListContract,
-    checklistItems: checkListItemsContract,
-    coveredPersons: coveredPersonsContract,
-    dashboard: dashboardContract,
-    dataRecords: dataRecordsContract,
-    dataRooms: dataRoomsContract,
-    defaultThemeConfigs: defaultThemeConfigsContract,
-    disbursementApprovalUsers: disbursementApprovalUsersContract,
-    disbursements: disbursementContract,
-    disbursementTransactions: disbursementTransactionsContract,
-    domainFilters: domainFiltersContract,
-    emailThemes: emailThemesContract,
-    escrowAccounts: escrowAccountsContract,
-    exchangeApiKeys: exchangeApiKeysContract,
-    exchangeImports: exchangeImportsContract,
-    files: filesContract,
-    filesPublic: filesPublicContract,
-    health: healthContract,
-    individuals: individualsContract,
-    investorAccounts: investorAccountsContract,
-    invites: invitesContract,
-    issuerBankAccounts: issuerBankAccountsContract,
-    issuerPaymentMethods: issuerPaymentMethodsContract,
-    issuers: issuersContract,
-    jobs: jobsContract,
-    kybs: kybsContract,
-    kycs: kycsContract,
-    legalEntities: legalEntitiesContract,
-    loginHistories: loginHistoriesContract,
-    notes: notesContract,
-    offerings: offeringsContract,
-    pages: pagesContract,
-    paymentMethods: paymentMethodsContract,
-    review: reviewContract,
-    roles: rolesContract,
-    rejectionReasons: rejectionReasonsContract,
-    secondaryCustomers: secondaryCustomersContract,
-    secondaryOrders: secondaryOrdersContract,
-    secondaryTrades: secondaryTradesContract,
-    secureRequests: secureRequestContract,
-    stateMachine: stateMachineContract,
-    signer: signerContract,
-    siteLinks: siteLinksContract,
-    sites: sitesContract,
-    siteSettings: siteSettingsContract,
-    tasks: tasksContract,
-    thirdParties: thirdPartiesContract,
-    trades: tradesContract,
-    transactions: transactionsContract,
-    tradeLineItems: tradeLineItemsContract,
-    userManuals: userManualsContract,
-    users: usersContract,
-    userSettings: userSettingsContract,
-    webhooks: webhooksContract,
-    jobItems: jobItemsContract,
-    notionDatabases: notionDatabasesContract,
-    notionPages: notionPagesContract,
-    offeringReports: offeringReportsContract,
-  },
-  {
-    pathPrefix: '/compliance/api/v1/',
-  },
-);

package/src/contracts/compliance/individuals/index.ts

@@ -1,57 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedIndividual,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  ComplianceIndividualFiltersZod,
-  IndividualsIncludeQuery,
-  IIndividualZod,
-  individualIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const individualsContract = c.router(
-  {
-    getIndividual: {
-      summary: 'Get individual by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(IndividualsIncludeQuery),
-      pathParams: z.object({
-        id: individualIdSchema,
-      }),
-      responses: {
-        200: IIndividualZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getIndividuals: {
-      summary: 'Get individuals',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ComplianceIndividualFiltersZod).merge(
-        IndividualsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedIndividual,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'individuals',
-  },
-);

package/src/contracts/compliance/investor-accounts/index.ts

@@ -1,141 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  accountIdSchema,
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  tradeIdSchema,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  ExportInvestorAccountsResponse,
-  IInvestorAccount,
-  IInvestorAccountSummary,
-  investorAccountIdSchema,
-  InvestorAccountsFiltersZod,
-  InvestorAccountsIncludeQuery,
-  InvestorAccountsSortZod,
-  IPaginatedInvestorAccounts,
-  IPaginatedRegisteredInvestorUserZod,
-  RegisteredInvestorUserFiltersZod,
-  SeedInvestorAccountsForDemoUsersZod,
-} from '../../../common/types/investor-account.types';
-
-const c = initContract();
-
-export const investorAccountsContract = c.router(
-  {
-    getRegisteredInvestorUsers: {
-      summary: 'Get registered investor users',
-      method: 'GET',
-      path: '/registered-users/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      query: PaginationOptionsZod.merge(RegisteredInvestorUserFiltersZod),
-      responses: {
-        200: IPaginatedRegisteredInvestorUserZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getInvestorAccount: {
-      summary: 'Get investor account by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(InvestorAccountsIncludeQuery),
-      pathParams: z.object({
-        id: investorAccountIdSchema,
-      }),
-      responses: {
-        200: IInvestorAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getInvestorAccounts: {
-      summary: 'Get investor accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(InvestorAccountsFiltersZod).merge(
-        InvestorAccountsSortZod,
-      ),
-      responses: {
-        200: IPaginatedInvestorAccounts,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getInvestorAccountSummary: {
-      summary: 'Get investor account summary',
-      method: 'GET',
-      path: '/:id/summary',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: investorAccountIdSchema,
-      }),
-      query: z.object({
-        tradeId: tradeIdSchema.optional(),
-      }),
-      responses: {
-        200: IInvestorAccountSummary,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    seedInvestorAccountsForDemoUsers: {
-      summary: '[Admin] Seed investor accounts for demo users',
-      method: 'POST',
-      path: '/seed',
-      metadata: {
-        auth: true,
-      },
-      body: SeedInvestorAccountsForDemoUsersZod,
-      responses: {
-        200: ExportInvestorAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    seedInvestorAccountsForAllDemoUsers: {
-      summary: '[Admin] Seed investor accounts for all demo users',
-      method: 'POST',
-      path: '/seed-all',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({}),
-      responses: {
-        200: ExportInvestorAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'investor-accounts',
-  },
-);

package/src/contracts/compliance/invites/index.ts

@@ -1,137 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  inviteIdSchema,
-  InviteWithoutSecretZod,
-  InviteWithUrl,
-  IPaginatedInvite,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchInviteForComplianceZod,
-  PortalType,
-  UnauthorizedError,
-  UserRole,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const invitesContract = c.router(
-  {
-    getInvites: {
-      summary: '[ADMIN] Get invites',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPaginatedInvite,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    postInvite: {
-      summary: '[ADMIN] Invite user',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        email: z.string().email(),
-        role: z.nativeEnum(UserRole),
-        accountId: z.string().optional(),
-        portalType: z.nativeEnum(PortalType).optional(),
-      }),
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    postInviteForCompliance: {
-      summary: '[ADMIN] Invite user for Compliance',
-      method: 'POST',
-      path: '/compliance',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        email: z.string().email(),
-        role: z.nativeEnum(UserRole),
-      }),
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    verifyInvite: {
-      summary: 'Verify invite',
-      method: 'GET',
-      path: '/verify/:code',
-      pathParams: z.object({
-        code: z.string(),
-      }),
-      responses: {
-        200: z.object({
-          valid: z.boolean(),
-          email: z.string().email().nullable(),
-        }),
-        400: BadRequestError,
-      },
-    },
-    patchInviteRole: {
-      summary: 'Patch invite role',
-      method: 'PATCH',
-      path: '/:id/role',
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: PatchInviteForComplianceZod,
-      responses: {
-        201: InviteWithoutSecretZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteInvite: {
-      summary: 'Delete invite by id',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      responses: {
-        200: z.object({
-          message: z.string(),
-        }),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'invites',
-  },
-);

package/src/contracts/compliance/issuer-bank-accounts/index.ts

@@ -1,81 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  PaginationOptionsZod,
-  BadRequestError,
-} from '../../../common/types';
-import {
-  IIssuerBankAccount,
-  IPaginatedIssuerBankAccount,
-  issuerBankAccountIdSchema,
-  IssuerBankAccountsFilter,
-  IssuerBankAccountsIncludeQuery,
-  PatchIssuerBankAccount,
-  PostIssuerBankAccount,
-} from '../../../common/types/issuer-bank-account.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerBankAccountsContract = c.router(
-  {
-    getIssuerBankAccounts: {
-      summary: 'Get issuer bank accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuerBankAccountsFilter).merge(
-        IssuerBankAccountsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedIssuerBankAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postIssuerBankAccount: {
-      summary: 'Create an issuer bank account',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostIssuerBankAccount,
-      responses: {
-        201: IIssuerBankAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchIssuerBankAccount: {
-      summary: 'Update issuer bank account',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: issuerBankAccountIdSchema }),
-      body: PatchIssuerBankAccount,
-      responses: {
-        201: IIssuerBankAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuer-bank-accounts',
-  },
-);

package/src/contracts/compliance/issuer-payment-methods/index.ts

@@ -1,81 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  ComplianceGetIssuerPaymentMethodZod,
-  IIssuerPaymentMethod,
-  IPaginatedIssuerPaymentMethod,
-  issuerPaymentMethodIdSchema,
-  PaginationOptionsZod,
-  accountIdSchema,
-  CompliancePatchIssuerPaymentMethodZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerPaymentMethodsContract = c.router(
-  {
-    getIssuerPaymentMethods: {
-      summary: 'get payment methods',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ComplianceGetIssuerPaymentMethodZod),
-      responses: {
-        200: IPaginatedIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchIssuerPaymentMethod: {
-      summary: 'PATCH issuer payment method for compliance',
-      method: 'PATCH',
-      path: '/:id',
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchIssuerPaymentMethodZod,
-      responses: {
-        201: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    toggleIssuerPaymentMethod: {
-      summary: 'Toggle issuer payment method',
-      method: 'PATCH',
-      path: '/:id/toggle',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      body: z.object({
-        enabled: z.boolean(),
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuer-payment-methods',
-  },
-);