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

package/contracts/investors/investor-accounts/index.ts

@@ -1,110 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  GetInvestorAccountsFilters,
-  IInvestorAccount,
-  IInvestorAccountSummary,
-  investorAccountIdSchema,
-  InvestorAccountsIncludeQuery,
-  InvestorUpdatePathParamsSchema,
-  IPaginatedInvestorAccounts,
-  PostInvestorAccountBodySchema,
-  UpdateInvestorAccountBodySchema,
-} from '../../../common/types/investor-account.types';
-
-const c = initContract();
-
-export const investorAccountsContract = c.router(
-  {
-    createInvestorAccount: {
-      summary: 'Create investor account ',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostInvestorAccountBodySchema,
-      responses: {
-        201: IInvestorAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateInvestorAccount: {
-      summary: 'Update investor account ',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: InvestorUpdatePathParamsSchema,
-      body: UpdateInvestorAccountBodySchema,
-      responses: {
-        201: IInvestorAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    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: GetInvestorAccountsFilters,
-      responses: {
-        200: IPaginatedInvestorAccounts,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    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,
-      },
-    },
-  },
-  {
-    pathPrefix: 'investor-accounts',
-  },
-);

package/contracts/investors/issuer-payment-methods/index.ts

@@ -1,36 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  GetIssuerPaymentMethodZod,
-  IPaginatedIssuerPaymentMethod,
-  PaginationOptionsZod,
-} from '../../../common/types';
-
-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,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuer-payment-methods',
-  },
-);

package/contracts/investors/issuers/index.ts

@@ -1,30 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import { IPaginatedCatalog } from '../../../common/types/issuer.types';
-const c = initContract();
-
-export const issuersContract = c.router(
-  {
-    getIssuers: {
-      summary: 'Get Issuers with mode property',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPaginatedCatalog,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuers',
-  },
-);

package/contracts/investors/legal-entities/index.ts

@@ -1,93 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  PostLegalEntitySchema,
-  ResponseLegalEntitySchema,
-  UnauthorizedError,
-  ForbiddenError,
-  legalEntityIdSchema,
-  UpdateLegalEntitySchema,
-  LegalEntitiesIncludeQuery,
-  LegalEntityZod,
-  PaginationOptionsZod,
-  LegalEntityFiltersZod,
-  IPaginatedLegalEntity,
-  NotFoundError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const legalEntityContract = c.router(
-  {
-    createLegalEntity: {
-      summary: 'Create Legal Entity',
-      method: 'POST',
-      path: '/',
-      body: PostLegalEntitySchema,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        201: ResponseLegalEntitySchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateLegalEntity: {
-      summary: 'Update Legal Entity',
-      method: 'PATCH',
-      path: '/:id',
-      pathParams: z.object({
-        id: legalEntityIdSchema,
-      }),
-      body: UpdateLegalEntitySchema,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: ResponseLegalEntitySchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getLegalEntity: {
-      summary: 'Get legalEntity by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(LegalEntitiesIncludeQuery),
-      pathParams: z.object({
-        id: legalEntityIdSchema,
-      }),
-      responses: {
-        200: LegalEntityZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getLegalEntities: {
-      summary: 'Get legalEntities',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(LegalEntityFiltersZod).merge(
-        LegalEntitiesIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedLegalEntity,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'legal-entities',
-  },
-);

package/contracts/investors/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 investorNotesContract = 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/investors/offerings/index.ts

@@ -1,93 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  NotFoundError,
-  offeringIdSchema,
-  OfferingDetailsResponseZod,
-  PublicOfferingFiltersZod,
-  InternalError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  InvestorsOffering,
-  InvestorsOfferingFiltersZod,
-  InvestorsOfferingsIncludeQuery,
-  InvestorsPaginatedOffering,
-} from '../../../common/types/investors-offering.types';
-
-const c = initContract();
-
-export const offeringsContract = c.router(
-  {
-    getOfferings: {
-      summary: 'Get offerings',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(InvestorsOfferingsIncludeQuery).merge(
-        InvestorsOfferingFiltersZod,
-      ),
-      responses: {
-        200: InvestorsPaginatedOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getPublicOfferings: {
-      summary: 'Get public offerings. This is used for public sites.',
-      method: 'GET',
-      path: '/public',
-      query: PublicOfferingFiltersZod,
-      responses: {
-        200: InvestorsPaginatedOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getOfferingDetails: {
-      summary: 'Get offering details',
-      method: 'GET',
-      path: '/:id/details',
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      responses: {
-        200: OfferingDetailsResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getOffering: {
-      summary: 'Get offering by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(InvestorsOfferingsIncludeQuery),
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      responses: {
-        200: InvestorsOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'offerings',
-  },
-);

package/contracts/investors/pages/index.ts

@@ -1,88 +0,0 @@
-import { initContract } from '@ts-rest/core';
-
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  pageIdSchema,
-  GetInvestorPageByUrlZod,
-  IPaginatedInvestorPages,
-  IInvestorPage,
-  GetInvestorPageZod,
-  PublicPagesFiltersZod,
-} 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(GetInvestorPageZod),
-      responses: {
-        200: IPaginatedInvestorPages,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getPublicPages: {
-      summary: 'Get public pages. This is used for public sites.',
-      method: 'GET',
-      path: '/public',
-      query: PublicPagesFiltersZod,
-      responses: {
-        200: IPaginatedInvestorPages,
-        400: BadRequestError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPageByUrl: {
-      summary: 'Get Page by URL',
-      method: 'GET',
-      path: '/url/:url',
-      pathParams: GetInvestorPageByUrlZod,
-      responses: {
-        200: IInvestorPage,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPage: {
-      summary: 'Get Page',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: pageIdSchema,
-      }),
-      responses: {
-        200: IInvestorPage,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'pages',
-  },
-);

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

@@ -1,149 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  paymentMethodIdSchema,
-  PaymentMethodResponse,
-  PaymentMethodResponseArray,
-  PostPaymentMethod,
-  PostProviderPaymentMethod,
-  PostSetupIntentBody,
-  SetupIntentResponse,
-  UpdatePaymentMethod,
-} 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,
-      },
-      responses: {
-        200: PaymentMethodResponseArray,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createPaymentMethod: {
-      summary: 'POST payment methods',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: PostPaymentMethod,
-      responses: {
-        201: PaymentMethodResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createProviderBankAccountPaymentMethod: {
-      summary: 'POST provider bank account payment method',
-      method: 'POST',
-      path: '/provider/bank-account',
-      metadata: {
-        auth: true,
-      },
-      body: PostProviderPaymentMethod,
-      responses: {
-        201: PaymentMethodResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createSetupIntent: {
-      summary: 'POST payment method setup intent',
-      method: 'POST',
-      path: '/intent',
-      metadata: {
-        auth: true,
-      },
-      body: PostSetupIntentBody,
-      responses: {
-        201: SetupIntentResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updatePaymentMethod: {
-      summary: 'PATCH payment methods',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: paymentMethodIdSchema,
-      }),
-      body: UpdatePaymentMethod,
-      responses: {
-        200: PaymentMethodResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPaymentMethod: {
-      summary: 'GET payment methods',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: paymentMethodIdSchema,
-      }),
-      responses: {
-        200: PaymentMethodResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deletePaymentMethod: {
-      summary: 'DELETE payment methods',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: paymentMethodIdSchema,
-      }),
-      responses: {
-        200: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'payment-methods',
-  },
-);