@dalmore/api-contracts 0.0.0-dev.801385 → 0.0.0-dev.9d42e16

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',
-  },
-);

package/contracts/issuers/payment-methods/index.ts

@@ -1,61 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  userIdSchema,
-} from '../../../common/types';
-import {
-  paymentMethodIdSchema,
-  PaymentMethodResponse,
-  PaymentMethodResponseArray,
-} from '../../../common/types/payment-methods.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const paymentMethodsContract = c.router(
-  {
-    getPaymentMethods: {
-      summary: 'get payment methods',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({
-        userId: userIdSchema.optional(),
-      }),
-      responses: {
-        200: PaymentMethodResponseArray,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    getPaymentMethod: {
-      summary: 'GET payment method',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: paymentMethodIdSchema,
-      }),
-      responses: {
-        200: PaymentMethodResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'payment-methods',
-  },
-);

package/contracts/issuers/portfolios/index.ts

@@ -1,36 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import { investorAccountIdSchema } from '../../../common/types/investor-account.types';
-import { AccountPortfolioResponse } from '../../../common/types/portfolio.types';
-
-const c = initContract();
-
-export const portfoliosContract = c.router(
-  {
-    getAccountPortfolio: {
-      summary: 'GET Account portfolio',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: investorAccountIdSchema,
-      }),
-      responses: {
-        200: AccountPortfolioResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'portfolios',
-  },
-);

package/contracts/issuers/rejection-reasons/index.ts

@@ -1,32 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import { RejectionReasonZod } from '../../../common/types/rejection-reasons.types';
-
-const c = initContract();
-
-export const rejectionReasonsContract = c.router(
-  {
-    getRejectionReasons: {
-      summary: 'Get rejection reasons',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.array(RejectionReasonZod),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'rejection-reasons',
-  },
-);

package/contracts/issuers/review/index.ts

@@ -1,63 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-  PostReviewBody,
-  PostReviewResponse,
-} from '../../../common/types';
-
-const c = initContract();
-
-export const reviewContract = c.router(
-  {
-    postReviewKyc: {
-      summary: 'Post KYC review for individuals',
-      method: 'POST',
-      path: '/kyc',
-      metadata: {
-        auth: true,
-      },
-      body: PostReviewBody,
-      responses: {
-        201: PostReviewResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    postReviewAml: {
-      summary: 'Post AML review for individuals',
-      method: 'POST',
-      path: '/aml',
-      metadata: {
-        auth: true,
-      },
-      body: PostReviewBody,
-      responses: {
-        201: PostReviewResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    postReviewAic: {
-      summary: 'Post AIC review for individuals',
-      method: 'POST',
-      path: '/aic',
-      metadata: {
-        auth: true,
-      },
-      body: PostReviewBody,
-      responses: {
-        201: PostReviewResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'review',
-  },
-);

package/contracts/issuers/secondary-customers/index.ts

@@ -1,55 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  IPaginatedSecondaryCustomers,
-  SecondaryCustomerFiltersZod,
-  secondaryCustomerIdSchema,
-  SecondaryCustomer,
-} from '../../../common/types/secondary-customer.types';
-import {
-  ForbiddenError,
-  NotFoundError,
-  UnauthorizedError,
-  PaginationOptionsZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const secondaryCustomersContract = c.router(
-  {
-    getCustomers: {
-      summary: 'Get Customers',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(SecondaryCustomerFiltersZod),
-      responses: {
-        200: IPaginatedSecondaryCustomers,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getCustomer: {
-      summary: 'Get Customer',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: secondaryCustomerIdSchema,
-      }),
-      responses: {
-        200: SecondaryCustomer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'secondary-customers',
-  },
-);

package/contracts/issuers/secondary-orders/index.ts

@@ -1,57 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import { PaginationOptionsZod } from '../../../common/types/common.types';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types/error-responses.types';
-import {
-  IPaginatedSecondaryOrders,
-  SecondaryOrder,
-  secondaryOrderIdSchema,
-  SecondaryOrderFiltersZod,
-} from '../../../common/types/secondary-order.types';
-const c = initContract();
-
-export const secondaryOrdersContract = c.router(
-  {
-    getSecondaryOrders: {
-      method: 'GET',
-      path: '',
-      query: PaginationOptionsZod.merge(SecondaryOrderFiltersZod),
-      metadata: {
-        auth: true,
-      },
-      summary: 'Get all secondary orders',
-      responses: {
-        200: IPaginatedSecondaryOrders,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getSecondaryOrder: {
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: secondaryOrderIdSchema,
-      }),
-      summary: 'Get a secondary order by id',
-      responses: {
-        200: SecondaryOrder,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'secondary-orders',
-  },
-);

package/contracts/issuers/secondary-trades/index.ts

@@ -1,57 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import { PaginationOptionsZod } from '../../../common/types/common.types';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types/error-responses.types';
-import {
-  IPaginatedSecondaryTrades,
-  secondaryTradeIdSchema,
-  SecondaryTradeFiltersZod,
-  SecondaryTradeZod,
-} from '../../../common/types/secondary-trade.types';
-const c = initContract();
-
-export const secondaryTradesContract = c.router(
-  {
-    getSecondaryTrades: {
-      method: 'GET',
-      path: '',
-      query: PaginationOptionsZod.merge(SecondaryTradeFiltersZod),
-      metadata: {
-        auth: true,
-      },
-      summary: 'Get all secondary trades',
-      responses: {
-        200: IPaginatedSecondaryTrades,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getSecondaryTrade: {
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: secondaryTradeIdSchema,
-      }),
-      summary: 'Get a secondary trade by id',
-      responses: {
-        200: SecondaryTradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'secondary-trades',
-  },
-);