@dalmore/api-contracts 0.0.0-dev.d8ef117 → 0.0.0-dev.e325dbb

package/contracts/compliance/bonus-tiers/index.ts

@@ -1,74 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  CompliancePostBonusTierZod,
-  EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
-  IBonusTierList,
-  PurchaseCalculationResponseZod,
-  PurchaseCalculationZod,
-} from '../../../common/types/bonus-tier.types';
-
-const c = initContract();
-
-export const bonusTiersContract = c.router(
-  {
-    estimateCalculation: {
-      summary: 'Estimate bonus tier calculation',
-      method: 'POST',
-      path: '/estimate-calculation',
-      metadata: {
-        auth: true,
-      },
-      body: EstimateBonusTierCalculationZod,
-      responses: {
-        200: EstimateBonusTierCalculationResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    purchaseCalculation: {
-      summary:
-        '[ADMIN] Calculate the bonus shares that would be awarded for a trade',
-      method: 'POST',
-      path: '/purchase-calculation',
-      metadata: {
-        auth: true,
-      },
-      body: PurchaseCalculationZod,
-      responses: {
-        200: PurchaseCalculationResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    postBonusTier: {
-      summary: 'Create a new bonus tier',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostBonusTierZod,
-      responses: {
-        201: IBonusTierList,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'bonus-tiers',
-  },
-);

package/contracts/compliance/checklist/index.ts

@@ -1,87 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ChecklistFiltersZodSchema,
-  ChecklistIncludeQuerySchema,
-  ChecklistParamsZodSchema,
-  IPaginatedChecklistSchema,
-  PatchChecklistSchema,
-  PostChecklistSchema,
-  ResponseChecklistZodSchema,
-} from '../../../common/types/checklist.types';
-
-const c = initContract();
-
-export const checkListContract = c.router(
-  {
-    getChecklist: {
-      summary: 'Get checklist by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: ChecklistParamsZodSchema,
-      query: ChecklistIncludeQuerySchema,
-      responses: {
-        200: ResponseChecklistZodSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getChecklists: {
-      summary: 'Query checklist by name or type',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ChecklistFiltersZodSchema).merge(
-        ChecklistIncludeQuerySchema,
-      ),
-      responses: {
-        200: IPaginatedChecklistSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    createChecklist: {
-      summary: 'Create checklist ',
-      method: 'POST',
-      path: '',
-      body: PostChecklistSchema,
-      responses: {
-        201: ResponseChecklistZodSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateChecklist: {
-      summary: 'Update checklist ',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      body: PatchChecklistSchema,
-      pathParams: ChecklistParamsZodSchema,
-      responses: {
-        201: ResponseChecklistZodSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'checklists',
-  },
-);

package/contracts/compliance/checklist-items/index.ts

@@ -1,86 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ChecklistItemsFiltersZodSchema,
-  IPaginatedChecklistItemSchema,
-  ParamsChecklistItemSchema,
-  PatchChecklistItemSchema,
-  PostChecklistItemSchema,
-  ResponseChecklistItemSchema,
-} from '../../../common/types/checklist-items.types';
-
-const c = initContract();
-
-export const checkListItemsContract = c.router(
-  {
-    createChecklistItem: {
-      summary: 'Create checklist Item ',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: PostChecklistItemSchema,
-      responses: {
-        201: ResponseChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateChecklistItem: {
-      summary: 'Update checklist item',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      body: PatchChecklistItemSchema,
-      pathParams: ParamsChecklistItemSchema,
-      responses: {
-        201: ResponseChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    queryChecklistItem: {
-      summary: 'GET checklist items by Checklist id',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ChecklistItemsFiltersZodSchema),
-      responses: {
-        200: IPaginatedChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getChecklistItem: {
-      summary: 'GET checklist items by Checklist id',
-      method: 'GET',
-      pathParams: ParamsChecklistItemSchema,
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: ResponseChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'checklist-items',
-  },
-);

package/contracts/compliance/covered-persons/index.ts

@@ -1,97 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchCoveredPersonsZod,
-  ReviewCoveredPersons,
-  UnauthorizedError,
-} from '../../../common/types';
-
-import {
-  coveredPersonIdSchema,
-  CoveredPersonsIncludeQuery,
-  GetCoveredPersonsZod,
-  ICoveredPerson,
-  IPaginatedCoveredPerson,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const coveredPersonsContract = c.router(
-  {
-    getCoveredPersons: {
-      summary: 'Get Covered Persons',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(CoveredPersonsIncludeQuery).merge(
-        GetCoveredPersonsZod,
-      ),
-      responses: {
-        200: IPaginatedCoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getCoveredPerson: {
-      summary: 'Get covered person by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(CoveredPersonsIncludeQuery),
-      pathParams: z.object({ id: coveredPersonIdSchema }),
-      responses: {
-        200: ICoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchCoveredPerson: {
-      summary: 'Update covered person',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: coveredPersonIdSchema }),
-      body: PatchCoveredPersonsZod,
-      responses: {
-        201: ICoveredPerson,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewCoveredPersons: {
-      summary: 'Review CoveredPersons',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewCoveredPersons,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'covered-persons',
-  },
-);

package/contracts/compliance/dashboard/index.ts

@@ -1,111 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  IPaginatedTradeSummaryResponse,
-  InternalError,
-  BadRequestError,
-  TradeSummaryFilterZod,
-  IPaginatedOnboardingOfferingSummaryResponse,
-  OnboardingOfferingSummaryFilterZod,
-} from '../../../common/types';
-import { IPaginatedSecondaryTradeSummaryResponse } from '../../../common/types/secondary-trade.types';
-import {
-  DocumentSummaryFilterZod,
-  IPaginatedDocumentSummaryResponse,
-} from '../../../common/types/dashboard.types';
-import {
-  IPaginatedOnboardingAccountSummaryResponse,
-  OnboardingAccountSummaryFilterZod,
-} from '../../../common/types/account.types';
-
-const c = initContract();
-
-export const dashboardContract = c.router(
-  {
-    getPaginatedTradesSummary: {
-      summary: 'Get trades summary with pagination',
-      method: 'GET',
-      path: '/trades',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(TradeSummaryFilterZod),
-      responses: {
-        200: IPaginatedTradeSummaryResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getPaginatedSecondaryTradesSummary: {
-      summary: 'Get secondary trades summary with pagination',
-      method: 'GET',
-      path: '/secondary-trades',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPaginatedSecondaryTradeSummaryResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDocumentsSummary: {
-      summary: 'Get documents summary with pagination',
-      method: 'GET',
-      path: '/documents',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DocumentSummaryFilterZod),
-      responses: {
-        200: IPaginatedDocumentSummaryResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getPaginatedOnBoardingAccountSummary: {
-      summary: 'Get onboarding account summary with pagination',
-      method: 'GET',
-      path: '/onboarding-accounts',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(OnboardingAccountSummaryFilterZod),
-      responses: {
-        200: IPaginatedOnboardingAccountSummaryResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getPaginatedOnBoardingOfferingSummary: {
-      summary: 'Get onboarding offering summary with pagination',
-      method: 'GET',
-      path: '/onboarding-offerings',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(OnboardingOfferingSummaryFilterZod),
-      responses: {
-        200: IPaginatedOnboardingOfferingSummaryResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'dashboard',
-  },
-);

package/contracts/compliance/data-records/index.ts

@@ -1,116 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ComplianceReview,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  dataRecordIdSchema,
-  DataRecordsFilters,
-  DataRecordsIncludeQuery,
-  DataRecordStructureZod,
-  DataRecordZod,
-  IPaginatedDataRecords,
-  NavigationSummaryZod,
-  RecordPathResponse,
-} from '../../../common/types/data-record.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const dataRecordsContract = c.router(
-  {
-    getDataRecords: {
-      summary: 'Get Data Records',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DataRecordsFilters).merge(
-        DataRecordsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedDataRecords,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDataRecord: {
-      summary: 'Get data record by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      query: z
-        .object({ status: z.nativeEnum(ComplianceReview) })
-        .merge(DataRecordsIncludeQuery),
-      responses: {
-        200: DataRecordZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDataRecordStructure: {
-      summary:
-        'Get data record structure by id - shows the proper tree structure of the data record',
-      method: 'GET',
-      path: '/:id/structure',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      responses: {
-        200: DataRecordStructureZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDataRecordPath: {
-      summary:
-        'Get data record path by id - useful for navigation and showing the user where they are in the folder structure. Returns the path to the record',
-      method: 'GET',
-      path: '/:id/path',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      responses: {
-        200: RecordPathResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getNavigationSummary: {
-      summary:
-        'Get navigation summary for a data record - useful for breadcrumbs',
-      method: 'GET',
-      path: '/:id/navigation',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      responses: {
-        200: NavigationSummaryZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'data-records',
-  },
-);

package/contracts/compliance/data-rooms/index.ts

@@ -1,113 +0,0 @@
-import { z } from 'zod';
-import { initContract } from '@ts-rest/core';
-import {
-  ComplianceReview,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  dataRoomIdSchema,
-  DataRoomApprovalsZod,
-  DataRoomsFilters,
-  DataRoomsIncludeQuery,
-  IPaginatedDataRooms,
-  DataRoomZod,
-  DataRoomStructureZod,
-  DataRoomFilesSummaryFilterZod,
-  IPaginatedDataRoomFilesSummaryZod,
-  DataRoomPasswordQueryZod,
-} from '../../../common/types/data-room.types';
-
-const c = initContract();
-
-export const dataRoomsContract = c.router(
-  {
-    getDataRooms: {
-      summary: 'Get paginated data-rooms',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DataRoomsFilters).merge(
-        DataRoomsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedDataRooms,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDataRoom: {
-      summary: 'Get data-room by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: DataRoomsIncludeQuery.merge(DataRoomPasswordQueryZod),
-      pathParams: z.object({ id: dataRoomIdSchema }),
-      responses: {
-        200: DataRoomZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getDataRoomApprovals: {
-      summary: 'Get data-room approvals',
-      method: 'GET',
-      path: '/approvals',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({ status: z.nativeEnum(ComplianceReview) }),
-      responses: {
-        200: z.array(DataRoomApprovalsZod),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDataRoomStructure: {
-      summary:
-        'Get data room structure by id - shows the proper tree structure of the data room',
-      method: 'GET',
-      path: '/:id/structure',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRoomIdSchema }),
-      query: DataRoomPasswordQueryZod,
-      responses: {
-        200: DataRoomStructureZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDataRoomFilesSummary: {
-      summary: 'Get dataroom files based on compliancereview and structure',
-      method: 'GET',
-      path: '/files/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DataRoomFilesSummaryFilterZod),
-      responses: {
-        200: IPaginatedDataRoomFilesSummaryZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'data-rooms',
-  },
-);