@dalmore/api-contracts 0.0.0-dev.15e31bc → 0.0.0-dev.1945443

package/contracts/compliance/offerings/index.ts

@@ -1,233 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  IOffering,
-  NotFoundError,
-  OfferingFiltersZod,
-  offeringIdSchema,
-  OfferingsIncludeQuery,
-  OfferingSummaryFiltersZod,
-  PaginatedOfferingSummaryResponseZod,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  IComplianceOffering,
-  IPaginatedComplianceOffering,
-  PatchComplianceOffering,
-  ReviewOfferings,
-  PostComplianceOffering,
-  OfferingSortZod,
-  PaginatedPendingOfferingSummaryResponseZod,
-  ReviewOfferingOnboarding,
-} from '../../../common/types';
-import {
-  CreateSubDocPreview,
-  CreateSubDocPreviewResponse,
-  ISubDocPreview,
-  SubDocPreviewFormFields,
-} from '../../../common/types/subdoc-preview.types';
-
-const c = initContract();
-
-export const offeringsContract = c.router(
-  {
-    getOfferings: {
-      summary: 'Get offerings',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(OfferingsIncludeQuery)
-        .merge(OfferingFiltersZod)
-        .merge(OfferingSortZod),
-      responses: {
-        200: IPaginatedComplianceOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    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,
-      },
-    },
-    getPendingOfferingsSummary: {
-      summary: 'Get pending offerings summary',
-      method: 'GET',
-      path: '/summary/pending',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: PaginatedPendingOfferingSummaryResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        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: IComplianceOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchOffering: {
-      summary: 'Update offering by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      body: PatchComplianceOffering,
-      responses: {
-        201: IOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postOffering: {
-      summary: '[ADMIN] Create offering',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostComplianceOffering,
-      responses: {
-        201: IOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    reviewOfferings: {
-      summary: 'Review Offerings',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewOfferings,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewOfferingOnboarding: {
-      summary: 'Review Offering Onboarding',
-      method: 'PATCH',
-      path: '/onboarding/review/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      body: ReviewOfferingOnboarding,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    offeringSubDocTemplateFields: {
-      summary: 'Get Sub Doc Template Form Fields',
-      method: 'GET',
-      path: '/templates/:templateId/form-fields',
-      pathParams: z.object({
-        templateId: z.string().min(1).max(36),
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: SubDocPreviewFormFields,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createOfferingSubDocPreview: {
-      summary: 'Create Offering Sub Doc Preview',
-      method: 'POST',
-      path: '/sub-doc/preview',
-      metadata: {
-        auth: true,
-      },
-      body: CreateSubDocPreview,
-      responses: {
-        201: CreateSubDocPreviewResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    offeringSubDocPreview: {
-      summary: 'Get Offering Sub Doc Preview',
-      method: 'GET',
-      path: '/sub-doc/:documentId/preview',
-      pathParams: z.object({
-        documentId: z.string().min(1).max(36),
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: ISubDocPreview,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'offerings',
-  },
-);

package/contracts/compliance/pages/index.ts

@@ -1,178 +0,0 @@
-import { initContract } from '@ts-rest/core';
-
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  IPaginatedPages,
-  NotFoundError,
-  pageIdSchema,
-  PagesIncludeQuery,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  ReviewPagesZod,
-  IPage,
-  ComplianceGetPagesZod,
-  PatchPageZod,
-  ConflictError,
-  IPendingPagesSummary,
-  GetLandingPageCandidatesResponse,
-  accountIdSchema,
-  pageRevisionIdSchema,
-  IPageRevision,
-  CompliancePostPageZod,
-  PagesSortZod,
-} 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(ComplianceGetPagesZod)
-        .merge(PagesSortZod),
-      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,
-      },
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      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,
-      },
-    },
-    reviewPages: {
-      summary: 'Review Pages',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewPagesZod,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postPage: {
-      summary: '[ADMIN] Post Pages',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostPageZod,
-      responses: {
-        201: IPage,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        500: InternalError,
-      },
-    },
-    updatePublishedVersion: {
-      summary: '[ADMIN] 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: '[ADMIN] 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,
-      },
-    },
-    getPendingPagesSummary: {
-      summary: 'Get Pending Pages Summary',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPendingPagesSummary,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'pages',
-  },
-);

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

@@ -1,57 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  CompliancePostPaymentMethod,
-  PaymentMethodFilterQuery,
-  PaymentMethodResponse,
-  PaymentMethodResponseArray,
-} from '../../../common/types/payment-methods.types';
-
-const c = initContract();
-
-export const paymentMethodsContract = c.router(
-  {
-    getPaymentMethods: {
-      summary: 'get payment methods',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaymentMethodFilterQuery,
-      responses: {
-        200: PaymentMethodResponseArray,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createPaymentMethod: {
-      summary: 'POST payment methods',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostPaymentMethod,
-      responses: {
-        201: PaymentMethodResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'payment-methods',
-  },
-);

package/contracts/compliance/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/compliance/review/index.ts

@@ -1,169 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  GetReviewKycResponse,
-  ReviewKycFilters,
-  UnauthorizedError,
-  ReviewAmlFilters,
-  GetReviewAmlResponse,
-  ReviewAicFilters,
-  GetReviewAicResponse,
-  PostReviewBody,
-  PostReviewResponse,
-  GetPendingReviewResponse,
-  IIndividualZod,
-  individualIdSchema,
-  PendingReviewFilters,
-  PaginationOptionsZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const reviewContract = c.router(
-  {
-    getReviewKyc: {
-      summary: 'Get KYC review for individuals',
-      method: 'GET',
-      path: '/kyc',
-      metadata: {
-        auth: true,
-      },
-      query: ReviewKycFilters,
-      responses: {
-        200: GetReviewKycResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getReviewAml: {
-      summary: 'Get AML review for individuals',
-      method: 'GET',
-      path: '/aml',
-      metadata: {
-        auth: true,
-      },
-      query: ReviewAmlFilters,
-      responses: {
-        200: GetReviewAmlResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getReviewAic: {
-      summary: 'Get AIC review for individuals',
-      method: 'GET',
-      path: '/aic',
-      metadata: {
-        auth: true,
-      },
-      query: ReviewAicFilters,
-      responses: {
-        200: GetReviewAicResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getPendingReviews: {
-      summary: 'Get all pending reviews',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(PendingReviewFilters),
-      responses: {
-        200: GetPendingReviewResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    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,
-      },
-    },
-    reProcessKyc: {
-      summary: 'Reprocess KYC for individuals',
-      method: 'POST',
-      path: '/kyc/re-process',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        individualId: individualIdSchema,
-      }),
-      responses: {
-        200: IIndividualZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    reProcessAml: {
-      summary: 'Reprocess AML for individuals',
-      method: 'POST',
-      path: '/aml/re-process',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        individualId: individualIdSchema,
-      }),
-      responses: {
-        200: IIndividualZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'review',
-  },
-);

package/contracts/compliance/roles/index.ts

@@ -1,34 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-  PortalType,
-  RoleZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const rolesContract = c.router(
-  {
-    getRoles: {
-      summary: 'Get roles',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({ portalType: z.nativeEnum(PortalType) }),
-      responses: {
-        200: z.array(RoleZod),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'roles',
-  },
-);