@dalmore/api-contracts 1.0.2 → 1.0.5

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

@@ -1,136 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

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