@dalmore/api-contracts 1.0.3 → 1.0.5

package/src/contracts/issuers/files-public/index.ts

@@ -1,166 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadGateWayError,
-  BadRequestError,
-  fileIdSchema,
-  FilesIncludeQuery,
-  FileZod,
-  InternalError,
-  IPaginatedFile,
-  PostFileQueryParams,
-  LinkFileZod,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchFile,
-  UnauthorizedError,
-  UnprocessableError,
-} from '../../../common/types';
-import { z } from 'zod';
-import { authHeader, generateApiDescription } from '../../../common/helpers';
-
-const c = initContract();
-
-export const filesPublicContract = c.router(
-  {
-    postFilePublic: {
-      summary: 'Upload an issuer file - Issuer files are public',
-      description: generateApiDescription(
-        'Upload a file to the system.',
-        'POST',
-        '/files-public',
-        {
-          query: {
-            name: 'test',
-            category: 'application',
-            targetId: 'covered_person_01j5tkg6k2fygr0x06fegt27aj',
-          },
-          headers: authHeader,
-          formData: { file: '@"/Users/local/Desktop/test.csv"' },
-        },
-      ),
-      method: 'POST',
-      path: '',
-      query: PostFileQueryParams,
-      contentType: 'multipart/form-data',
-      body: c.type<{ file: File }>(),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        201: FileZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        422: UnprocessableError,
-        500: InternalError,
-        502: BadGateWayError,
-      },
-    },
-    linkFilePublic: {
-      summary: 'Links a public file to a new resource',
-      method: 'POST',
-      path: '/:id/link',
-      pathParams: z.object({
-        id: fileIdSchema,
-      }),
-      body: LinkFileZod,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        201: FileZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        422: UnprocessableError,
-        500: InternalError,
-        502: BadGateWayError,
-      },
-    },
-    unlinkFilePublic: {
-      summary: 'Unlinks a public file to the parent resource',
-      method: 'POST',
-      path: '/:id/unlink',
-      pathParams: z.object({
-        id: fileIdSchema,
-      }),
-      body: z.object({}),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        202: FileZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        422: UnprocessableError,
-        500: InternalError,
-        502: BadGateWayError,
-      },
-    },
-    getFilesPublic: {
-      summary: 'Get public files',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(FilesIncludeQuery),
-      responses: {
-        200: IPaginatedFile,
-        401: UnauthorizedError,
-      },
-    },
-    getFilePublic: {
-      summary: 'Get public file by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: fileIdSchema,
-      }),
-      responses: {
-        200: FileZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    patchFilePublic: {
-      summary: 'Update public file by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: fileIdSchema,
-      }),
-      body: PatchFile,
-      responses: {
-        201: FileZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    previewFilePublic: {
-      summary: 'Preview (stream) a public file by id',
-      method: 'GET',
-      path: '/preview/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: fileIdSchema,
-      }),
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'files-public',
-  },
-);

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

@@ -1,24 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { InternalError } from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const healthContract = c.router(
-  {
-    getHealth: {
-      summary: 'Health Check',
-      method: 'GET',
-      path: '',
-      responses: {
-        201: z.object({
-          status: z.literal('ok'),
-        }),
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'health/',
-  },
-);

package/src/contracts/issuers/index.ts

@@ -1,112 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { accountsContract } from './accounts';
-import { accountContactsContract } from './account-contacts';
-import { accountIntegrationsContract } from './account-integrations';
-import { assetsContract } from './assets';
-import { healthContract } from './health';
-import { issuerContract } from './issuer';
-import { authContract } from './auth';
-import { issuersOfferingsContract } from './offerings';
-import { issuerInvitesContract } from './invites';
-import { issuerNotesContract } from './notes';
-import { issuerTradesContract } from './trades';
-import { investorAccountsContract } from './investor-accounts';
-import { issuerUsersContract } from './users';
-import { coveredPersonsContract } from './covered-persons';
-import { activitiesContract } from './activities';
-import { filesPublicContract } from './files-public';
-import { pagesContract } from './pages';
-import { loginHistoriesContract } from './login-histories';
-import { dataRoomsContract } from './data-rooms';
-import { dataRecordsContract } from './data-records';
-import { filesContract } from './files';
-import { issuerPaymentMethodsContract } from './issuer-payment-methods';
-import { issuerTasksContract } from './tasks';
-import { issuerTransactionsContract } from './transactions';
-import { dashboardContract } from './dashboard';
-import { siteSettingsContract } from './site-settings';
-import { sitesContract } from './sites';
-import { contactUsContract } from './contact-us';
-import { paymentMethodsContract } from './payment-methods';
-import { userManualsContract } from './user-manuals';
-import { issuerBankAccountsContract } from './issuer-bank-accounts';
-import { disbursementsContract } from './disbursements';
-import { escrowAccountsContract } from './escrow-accounts';
-import { disbursementApprovalUsersContract } from './disbursement-approval-users';
-import { disbursementTransactionsContract } from './disbursement-transactions';
-import { userSettingsContract } from './user-settings';
-import { siteLinksContract } from './site-links';
-import { emailThemesContract } from './email-themes';
-import { kycsContract } from './kyc';
-import { reviewContract } from './review';
-import { secondaryCustomersContract } from './secondary-customers';
-import { secondaryOrdersContract } from './secondary-orders';
-import { secondaryTradesContract } from './secondary-trades';
-import { portfoliosContract } from './portfolios';
-import { exchangeApiKeysContract } from './exchange-api-keys';
-import { issuerApiKeysContract } from './api-keys';
-import { issuerApiKeyLogsContract } from './api-key-logs';
-import { aicContract } from './aic';
-import { rejectionReasonsContract } from './rejection-reasons';
-import { secureRequestContract } from './secure-requests';
-import { bonusTiersContract } from './bonus-tiers';
-const c = initContract();
-
-export const issuersContract = c.router(
-  {
-    accounts: accountsContract,
-    accountContacts: accountContactsContract,
-    accountIntegrations: accountIntegrationsContract,
-    activities: activitiesContract,
-    aic: aicContract,
-    assets: assetsContract,
-    auth: authContract,
-    bonusTiers: bonusTiersContract,
-    contactUs: contactUsContract,
-    coveredPersons: coveredPersonsContract,
-    dashboard: dashboardContract,
-    dataRecords: dataRecordsContract,
-    dataRooms: dataRoomsContract,
-    disbursementApprovalUsers: disbursementApprovalUsersContract,
-    disbursements: disbursementsContract,
-    disbursementTransactions: disbursementTransactionsContract,
-    emailThemes: emailThemesContract,
-    escrowAccounts: escrowAccountsContract,
-    exchangeApiKeys: exchangeApiKeysContract,
-    apiKeys: issuerApiKeysContract,
-    apiKeyLogs: issuerApiKeyLogsContract,
-    files: filesContract,
-    filesPublic: filesPublicContract,
-    health: healthContract,
-    investorAccounts: investorAccountsContract,
-    invites: issuerInvitesContract,
-    issuerBankAccounts: issuerBankAccountsContract,
-    issuerPaymentMethods: issuerPaymentMethodsContract,
-    issuers: issuerContract,
-    kycs: kycsContract,
-    loginHistories: loginHistoriesContract,
-    notes: issuerNotesContract,
-    offerings: issuersOfferingsContract,
-    pages: pagesContract,
-    paymentMethods: paymentMethodsContract,
-    portfolios: portfoliosContract,
-    rejectionReasons: rejectionReasonsContract,
-    review: reviewContract,
-    secondaryCustomers: secondaryCustomersContract,
-    secondaryOrders: secondaryOrdersContract,
-    secondaryTrades: secondaryTradesContract,
-    secureRequests: secureRequestContract,
-    siteLinks: siteLinksContract,
-    sites: sitesContract,
-    siteSettings: siteSettingsContract,
-    tasks: issuerTasksContract,
-    trades: issuerTradesContract,
-    transactions: issuerTransactionsContract,
-    userManuals: userManualsContract,
-    users: issuerUsersContract,
-    userSettings: userSettingsContract,
-  },
-  {
-    pathPrefix: '/issuers/api/v1/',
-  },
-);

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

@@ -1,148 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  IIndividualZod,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  tradeIdSchema,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  InvestorAccountsIncludeQuery,
-  investorAccountIdSchema,
-  IInvestorAccount,
-  IssuerInvestorAccountsFiltersZod,
-  IPaginatedInvestorAccounts,
-  InvestorAccountExportFilters,
-  GetInvestorAccountDetailsQuery,
-  RegisteredInvestorUserFiltersZod,
-  IPaginatedRegisteredInvestorUserZod,
-  IInvestorAccountSummary,
-} from '../../../common/types/investor-account.types';
-
-const c = initContract();
-
-export const investorAccountsContract = c.router(
-  {
-    exportInvestorAccounts: {
-      summary: 'Export investor accounts to CSV',
-      method: 'GET',
-      path: '/export',
-      query: InvestorAccountExportFilters,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    exportRegisteredInvestorUsers: {
-      summary: 'Export registered investor users to CSV',
-      method: 'GET',
-      path: '/registered-users/export',
-      query: RegisteredInvestorUserFiltersZod,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    getInvestorAccounts: {
-      summary: 'Get investor accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuerInvestorAccountsFiltersZod),
-      responses: {
-        200: IPaginatedInvestorAccounts,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getRegisteredInvestorUsers: {
-      summary: 'Get registered investor users',
-      method: 'GET',
-      path: '/registered-users',
-      query: PaginationOptionsZod.merge(RegisteredInvestorUserFiltersZod),
-      metadata: {
-        auth: true,
-      },
-      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,
-      },
-    },
-    getInvestorAccountDetails: {
-      summary: 'Get investor account details',
-      method: 'GET',
-      path: '/:id/details',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: investorAccountIdSchema,
-      }),
-      query: GetInvestorAccountDetailsQuery,
-      responses: {
-        200: IIndividualZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    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,
-      },
-    },
-  },
-  {
-    pathPrefix: 'investor-accounts',
-  },
-);

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

@@ -1,129 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  NotFoundError,
-  InternalError,
-  InviteWithUrl,
-  IPaginatedInvite,
-  PaginationOptionsZod,
-  PostIssuerInviteZod,
-  IssuerInvitesFiltersZod,
-  UnauthorizedError,
-  IssuerVerifyInviteResponse,
-  IssuerInvitesDecisionResponse,
-  inviteIdSchema,
-  InvitesIncludeQuery,
-  PatchInviteRoleZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerInvitesContract = c.router(
-  {
-    getInvites: {
-      summary: '[OWNER] Get invites',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuerInvitesFiltersZod).merge(
-        InvitesIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedInvite,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    verifyInvite: {
-      summary: 'Verify invite',
-      method: 'GET',
-      path: '/verify/:code',
-      pathParams: z.object({
-        code: z.string(),
-      }),
-      responses: {
-        200: IssuerVerifyInviteResponse,
-        400: BadRequestError,
-        404: NotFoundError,
-      },
-    },
-    postInvite: {
-      summary: '[OWNER] Invite user',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostIssuerInviteZod,
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    acceptInvite: {
-      summary: 'Accept invite',
-      method: 'PATCH',
-      path: '/accept/:id',
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        201: IssuerInvitesDecisionResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    rejectInvite: {
-      summary: 'Verify invite',
-      method: 'PATCH',
-      path: '/reject/:id',
-      body: z.object({}),
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      responses: {
-        201: IssuerInvitesDecisionResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchInviteRole: {
-      summary: 'Patch invite role',
-      method: 'PATCH',
-      path: '/role/:id',
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: PatchInviteRoleZod,
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'invites',
-  },
-);

package/src/contracts/issuers/issuer/index.ts

@@ -1,94 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  GetIssuersZod,
-  IIssuer,
-  IPaginatedIssuer,
-  IssuersIncludeQuery,
-  issuerIdSchema,
-  PostIssuerZod,
-  PutIssuerZod,
-} from '../../../common/types/issuer.types';
-const c = initContract();
-
-export const issuerContract = c.router(
-  {
-    getIssuers: {
-      summary: 'Get Issuers',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(IssuersIncludeQuery).merge(GetIssuersZod),
-      responses: {
-        200: IPaginatedIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    postIssuer: {
-      summary: 'Create an issuer',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostIssuerZod,
-      responses: {
-        201: IIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getIssuer: {
-      summary: 'Get issuer by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(IssuersIncludeQuery),
-      pathParams: z.object({ id: issuerIdSchema }),
-      responses: {
-        200: IIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateIssuer: {
-      summary: 'Update issuer',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerIdSchema,
-      }),
-      body: PutIssuerZod,
-      responses: {
-        201: IIssuer,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuers',
-  },
-);