@dalmore/api-contracts 1.0.0

package/contracts/issuers/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/issuers/issuer-payment-methods/index.ts

@@ -0,0 +1,136 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IIssuerPaymentMethod,
+  IPaginatedIssuerPaymentMethod,
+  issuerPaymentMethodIdSchema,
+  PatchIssuerPaymentMethodZod,
+  PaginationOptionsZod,
+  ConnectIssuerPaymentMethodZod,
+  BadRequestError,
+} 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(GetIssuerPaymentMethodZod),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchIssuerPaymentMethod: {
+      summary: 'PATCH issuer payment method',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: issuerPaymentMethodIdSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PatchIssuerPaymentMethodZod,
+      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(),
+      }),
+      responses: {
+        200: IIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    connectIssuerPaymentMethod: {
+      summary: 'Connect issuer payment method',
+      method: 'POST',
+      path: '/integrations/connect',
+      metadata: {
+        auth: true,
+      },
+      body: ConnectIssuerPaymentMethodZod,
+      responses: {
+        200: z.array(IIssuerPaymentMethod),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    disconnectIssuerPaymentMethod: {
+      summary: 'Disconnect issuer payment method',
+      method: 'PATCH',
+      path: '/:id/integrations/disconnect',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: issuerPaymentMethodIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: IIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createIssuerPaymentMethodAccountLink: {
+      summary: 'Create issuer payment method account link',
+      method: 'POST',
+      path: '/:id/integrations/account-link',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: issuerPaymentMethodIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: IIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/issuers/kyc/index.ts

@@ -0,0 +1,38 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  UnauthorizedError,
+  inquiryIdSchema,
+  InquiryResponse,
+  ServiceUnavailableError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const kycsContract = c.router(
+  {
+    getInquiry: {
+      summary: 'KYC inquiry by ID',
+      method: 'GET',
+      path: '/inquiries/:inquiryId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        inquiryId: inquiryIdSchema,
+      }),
+      responses: {
+        200: InquiryResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+        503: ServiceUnavailableError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'kycs',
+  },
+);

package/contracts/issuers/login-histories/index.ts

@@ -0,0 +1,51 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  BadRequestError,
+  ForbiddenError,
+  UnauthorizedError,
+  IListLoginHistories,
+  userIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const loginHistoriesContract = c.router(
+  {
+    getLoginHistories: {
+      summary: 'Get Login Histories',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: IListLoginHistories,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getLoginHistoriesByUserId: {
+      summary: 'Get Login Histories by User id',
+      method: 'GET',
+      path: '/:userId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: IListLoginHistories,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'login-histories',
+  },
+);

package/contracts/issuers/notes/index.ts

@@ -0,0 +1,69 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  IPaginatedNote,
+  noteIdSchema,
+  NotesFilters,
+  NoteZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PostNoteBody,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const issuerNotesContract = c.router(
+  {
+    postNote: {
+      summary: 'Create a note',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostNoteBody,
+      responses: {
+        201: NoteZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getNotes: {
+      summary: 'Get notes',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotesFilters),
+      responses: {
+        200: IPaginatedNote,
+        401: UnauthorizedError,
+      },
+    },
+    getNote: {
+      summary: 'Get note by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: noteIdSchema,
+      }),
+      responses: {
+        200: NoteZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'notes',
+  },
+);

package/contracts/issuers/offerings/index.ts

@@ -0,0 +1,206 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  IIssuerOffering,
+  InternalError,
+  IOffering,
+  IPaginatedIssuerOffering,
+  IssuerOfferingsDeleteResponse,
+  IssuerOfferingsFilterZod,
+  IssuerOfferingsIncludeQuery,
+  NotFoundError,
+  OfferingCapTableFiltersZod,
+  OfferingCapTableResponse,
+  offeringIdSchema,
+  OfferingsIncludeQuery,
+  OfferingSummaryFiltersZod,
+  PaginatedOfferingSummaryResponseZod,
+  PaginationOptionsZod,
+  PatchIssuerOffering,
+  PostIssuerOffering,
+  SubmitIssuerOfferingResponse,
+  UnauthorizedError,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuersOfferingsContract = c.router(
+  {
+    getOfferings: {
+      summary: 'Get offerings',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuerOfferingsIncludeQuery).merge(
+        IssuerOfferingsFilterZod,
+      ),
+      responses: {
+        200: IPaginatedIssuerOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getOfferingsSummary: {
+      summary: 'Get offerings summary',
+      method: 'GET',
+      path: '/summary',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(OfferingSummaryFiltersZod),
+      responses: {
+        200: PaginatedOfferingSummaryResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getOfferingCapTable: {
+      summary: 'Get offering cap table',
+      method: 'GET',
+      path: '/:id/cap-table',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      query: OfferingCapTableFiltersZod,
+      responses: {
+        200: OfferingCapTableResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getOffering: {
+      summary: 'Get offering by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(OfferingsIncludeQuery),
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      responses: {
+        200: IIssuerOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    submitOffering: {
+      summary: 'Submit offering for review',
+      method: 'PATCH',
+      path: '/:id/submit',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        201: SubmitIssuerOfferingResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchOffering: {
+      summary: 'Update offering by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      body: PatchIssuerOffering,
+      responses: {
+        201: IIssuerOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postOffering: {
+      summary: '[ADMIN] Create offering',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostIssuerOffering,
+      responses: {
+        201: IIssuerOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    toggleOffering: {
+      summary: 'Toggle offering by id',
+      method: 'PATCH',
+      path: '/:id/toggle',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      body: z.object({
+        enabled: z.boolean(),
+      }),
+      responses: {
+        200: IOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteOffering: {
+      summary: 'Delete offering by id',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      responses: {
+        200: IssuerOfferingsDeleteResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'offerings',
+  },
+);

package/contracts/issuers/pages/index.ts

@@ -0,0 +1,138 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  pageRevisionIdSchema,
+  PagesIncludeQuery,
+  GetPagesZod,
+  IPaginatedPages,
+  pageIdSchema,
+  IPage,
+  PostPageZod,
+  PatchPageZod,
+  ConflictError,
+  IPageRevision,
+  GetLandingPageCandidatesResponse,
+} from '../../../common/types';
+
+import { z } from 'zod';
+const c = initContract();
+
+export const pagesContract = c.router(
+  {
+    getPages: {
+      summary: 'Get Pages',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(PagesIncludeQuery).merge(GetPagesZod),
+      responses: {
+        200: IPaginatedPages,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getLandingPageCandidates: {
+      summary: 'Get pages that are qualified to be presented as landing page',
+      method: 'GET',
+      path: '/landing-page-candidates',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: GetLandingPageCandidatesResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getPage: {
+      summary: 'Get Page',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(PagesIncludeQuery),
+      pathParams: z.object({
+        id: pageIdSchema,
+      }),
+      responses: {
+        200: IPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postPage: {
+      summary: 'Post Pages',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostPageZod,
+      responses: {
+        201: IPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        500: InternalError,
+      },
+    },
+    updatePublishedVersion: {
+      summary: 'Update the current published version',
+      method: 'PATCH',
+      path: '/published-version',
+      metadata: {
+        auth: true,
+      },
+      body: z.object({
+        id: pageRevisionIdSchema,
+      }),
+      responses: {
+        201: IPageRevision,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchPage: {
+      summary: 'Patch Pages',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: pageIdSchema,
+      }),
+      body: PatchPageZod,
+      responses: {
+        201: IPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'pages',
+  },
+);