@dalmore/api-contracts 1.0.0

package/contracts/compliance/index.ts

@@ -0,0 +1,145 @@
+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';
+
+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,
+    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/contracts/compliance/individuals/index.ts

@@ -0,0 +1,57 @@
+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/contracts/compliance/investor-accounts/index.ts

@@ -0,0 +1,137 @@
+import { initContract } from '@ts-rest/core';
+import {
+  accountIdSchema,
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  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,
+      }),
+      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/contracts/compliance/invites/index.ts

@@ -0,0 +1,137 @@
+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/contracts/compliance/issuer-bank-accounts/index.ts

@@ -0,0 +1,81 @@
+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/contracts/compliance/issuer-payment-methods/index.ts

@@ -0,0 +1,81 @@
+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',
+  },
+);