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

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

package/contracts/compliance/default-theme-configs/index.ts

@@ -1,95 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  defaultThemeConfigIdSchema,
-  ForbiddenError,
-  GetDefaultThemeConfig,
-  IDefaultThemeConfig,
-  InternalError,
-  IPaginatedDefaultThemeConfigsZod,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchDefaultThemeConfigZod,
-  PostDefaultThemeConfigZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const defaultThemeConfigsContract = c.router(
-  {
-    getDefaultThemeConfigs: {
-      summary: '[ADMIN] Get Default Theme Configs',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPaginatedDefaultThemeConfigsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDefaultThemeConfig: {
-      summary: '[ADMIN] Get default theme config by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: defaultThemeConfigIdSchema,
-      }),
-      responses: {
-        200: GetDefaultThemeConfig,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postDefaultThemeConfig: {
-      summary: '[ADMIN] Create default theme config',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostDefaultThemeConfigZod,
-      responses: {
-        201: IDefaultThemeConfig,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    patchDefaultThemeConfig: {
-      summary: '[ADMIN] Update default theme config',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: defaultThemeConfigIdSchema,
-      }),
-      body: PatchDefaultThemeConfigZod,
-      responses: {
-        200: IDefaultThemeConfig,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'default-theme-configs',
-  },
-);

package/contracts/compliance/disbursement/index.ts

@@ -1,165 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  CompliancePostDisbursementZod,
-  DisbursementBalanceZod,
-  DisbursementFiltersZod,
-  disbursementIdSchema,
-  DisbursementMissingConfigZod,
-  DisbursementSigningLinkZod,
-  DisbursementsIncludeQuery,
-  DisbursementsMissingConfigQuery,
-  DisbursementSummaryZod,
-  DisbursementZod,
-  IPaginatedDisbursement,
-  PostDisbursementBalanceZod,
-  PostDisbursementSummaryZod,
-} from '../../../common/types/disbursements.types';
-import { PostComplianceReviewDisbursementZod } from '../../../common/types/disbursement-review.types';
-
-const c = initContract();
-
-export const disbursementContract = c.router(
-  {
-    postDisbursement: {
-      summary: 'Create a disbursement',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostDisbursementZod,
-      responses: {
-        201: DisbursementZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postDisbursementBalance: {
-      summary: 'Get a disbursement balance',
-      method: 'POST',
-      path: '/balance',
-      metadata: {
-        auth: true,
-      },
-      body: PostDisbursementBalanceZod,
-      responses: {
-        201: DisbursementBalanceZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postDisbursementSummary: {
-      summary: 'Get a disbursement summary',
-      method: 'POST',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      body: PostDisbursementSummaryZod,
-      responses: {
-        201: DisbursementSummaryZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDisbursements: {
-      summary: 'Get disbursements',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DisbursementFiltersZod).merge(
-        DisbursementsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedDisbursement,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDisbursementsMissingConfig: {
-      summary: 'Get missing configuration for disbursements',
-      method: 'GET',
-      path: '/config',
-      metadata: {
-        auth: true,
-      },
-      query: DisbursementsMissingConfigQuery,
-      responses: {
-        200: DisbursementMissingConfigZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getDisbursement: {
-      summary: 'Get disbursement by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(DisbursementsIncludeQuery),
-      pathParams: z.object({ id: disbursementIdSchema }),
-      responses: {
-        200: DisbursementZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    reviewDisbursements: {
-      summary: 'Review Disbursements',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: PostComplianceReviewDisbursementZod,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDisbursementEmbeddedSigningLink: {
-      summary: 'Review Disbursements',
-      method: 'GET',
-      path: '/:id/signing-link',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: disbursementIdSchema }),
-      responses: {
-        200: DisbursementSigningLinkZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'disbursements',
-  },
-);

package/contracts/compliance/disbursement-approval-users/index.ts

@@ -1,84 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  PaginationOptionsZod,
-  BadRequestError,
-  accountIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  DisbursementApprovalUserFiltersZod,
-  disbursementApprovalUserIdSchema,
-  DisbursementApprovalUsersIncludeQuery,
-  DisbursementApprovalUserZod,
-  IPaginatedDisbursementApprovalUser,
-  PostComplianceDisbursementApprovalUser,
-} from '../../../common/types/disbursement-approval-user.types';
-
-const c = initContract();
-
-export const disbursementApprovalUsersContract = c.router(
-  {
-    getDisbursementApprovalUsers: {
-      summary: '[ADMIN] Get disbursement approval users',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(
-        DisbursementApprovalUserFiltersZod,
-      ).merge(DisbursementApprovalUsersIncludeQuery),
-      responses: {
-        200: IPaginatedDisbursementApprovalUser,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postDisbursementApprovalUser: {
-      summary: '[ADMIN] Create disbursement approval user',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostComplianceDisbursementApprovalUser,
-      responses: {
-        201: DisbursementApprovalUserZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    deleteDisbursementApprovalUser: {
-      summary: '[ADMIN] Delete disbursement approval user',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: disbursementApprovalUserIdSchema,
-      }),
-      query: z.object({ accountId: accountIdSchema.optional() }),
-      responses: {
-        200: z.object({ success: z.boolean() }),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'disbursement-approval-users',
-  },
-);

package/contracts/compliance/disbursement-transactions/index.ts

@@ -1,37 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  CompliancePostDisbursementTransactionZod,
-  DisbursementTransactionZod,
-} from '../../../common/types/disbursement-transaction.types';
-
-const c = initContract();
-
-export const disbursementTransactionsContract = c.router(
-  {
-    postDisbursementTransaction: {
-      summary: 'Create a disbursement transaction',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostDisbursementTransactionZod,
-      responses: {
-        201: DisbursementTransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'disbursement-transactions',
-  },
-);

package/contracts/compliance/domain-filters/index.ts

@@ -1,117 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  PaginationOptionsZod,
-  DomainFilterFiltersZod,
-  IPaginatedDomainFilter,
-  ForbiddenError,
-  UnauthorizedError,
-  NotFoundError,
-  domainFilterIdSchema,
-  DomainFilterZod,
-  PostDomainFilterZod,
-  ConflictError,
-  InternalError,
-  PatchDomainFilterZod,
-  DomainFilterDeleteResponseZod,
-} from '../../../common/types';
-
-const c = initContract();
-
-export const domainFiltersContract = c.router(
-  {
-    getDomainFilters: {
-      summary: 'Get domain filters',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DomainFilterFiltersZod),
-      responses: {
-        200: IPaginatedDomainFilter,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getDomainFilter: {
-      summary: 'Get domain filter by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: domainFilterIdSchema,
-      }),
-      responses: {
-        200: DomainFilterZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    createDomainFilter: {
-      summary: 'Create domain filter',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostDomainFilterZod,
-      responses: {
-        200: DomainFilterZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        500: InternalError,
-      },
-    },
-    updateDomainFilter: {
-      summary: 'Update domain filter',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: domainFilterIdSchema,
-      }),
-      body: PatchDomainFilterZod,
-      responses: {
-        200: DomainFilterZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        500: InternalError,
-      },
-    },
-    deleteDomainFilter: {
-      summary: 'Delete domain filter',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: domainFilterIdSchema,
-      }),
-      responses: {
-        200: DomainFilterDeleteResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'domain-filters',
-  },
-);