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

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

package/contracts/compliance/email-themes/index.ts

@@ -1,284 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  InternalError,
-  UnauthorizedError,
-  accountIdSchema,
-  EmailThemesList,
-  EmailThemeFiltersZod,
-  IEmailTheme,
-  emailThemeIdSchema,
-  IEmailThemeSettings,
-  emailThemeSettingIdSchema,
-  IEmailThemeSetting,
-  ExportEmailThemeSettingsZod,
-  CompliancePostEmailThemeZod,
-  CompliancePatchEmailThemeSettings,
-  CompliancePatchEmailThemeSetting,
-  ComplianceImportEmailThemeSettingsZod,
-  CompliancePatchEmailThemeNameZod,
-  ComplianceSendPreviewEmailZod,
-  SendPreviewEmailResponse,
-  PreviewEmailThemeResponse,
-  PaginationOptionsZod,
-  GetEmailThemesAdminQuery,
-  CompliancePreviewEmailThemeZod,
-  ComplianceGenerateTemplatePreviewHtmlZod,
-  GetDefaultEmailThemesZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const emailThemesContract = c.router(
-  {
-    previewEmailTheme: {
-      summary: '[ADMIN] Preview an email theme',
-      method: 'GET',
-      path: '/preview',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: PreviewEmailThemeResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getEmailThemesAdmin: {
-      summary: '[ADMIN] Get the email themes for the admin users',
-      method: 'GET',
-      path: '/admin',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(GetEmailThemesAdminQuery),
-      responses: {
-        200: EmailThemesList,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getDefaultEmailThemes: {
-      summary: '[ADMIN] Get the default email themes',
-      method: 'GET',
-      path: '/default-email-themes',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetDefaultEmailThemesZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getEmailThemes: {
-      summary: '[ADMIN] Get the themes for the specified account',
-      method: 'GET',
-      path: '/account/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: EmailThemesList,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getEmailTheme: {
-      summary: '[ADMIN] Get the theme by id for the specified account',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      query: z.object({}).merge(EmailThemeFiltersZod),
-      responses: {
-        200: IEmailTheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    sendPreviewEmail: {
-      summary: '[ADMIN] Send a preview email',
-      method: 'POST',
-      path: '/send-preview-email',
-      metadata: {
-        auth: true,
-      },
-      body: ComplianceSendPreviewEmailZod,
-      responses: {
-        201: SendPreviewEmailResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    sendTemplateEmail: {
-      summary: '[ADMIN] Send a template email',
-      method: 'POST',
-      path: '/send-template-email',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePreviewEmailThemeZod,
-      responses: {
-        201: SendPreviewEmailResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    generateTemplatePreviewHtml: {
-      summary: '[ADMIN] Generate HTML for a template email',
-      method: 'POST',
-      path: '/generate-template-preview-html',
-      metadata: {
-        auth: true,
-      },
-      body: ComplianceGenerateTemplatePreviewHtmlZod,
-      responses: {
-        200: PreviewEmailThemeResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postEmailTheme: {
-      summary: '[ADMIN] Post a email theme',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostEmailThemeZod,
-      responses: {
-        201: IEmailTheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    patchEmailThemeSettings: {
-      summary: '[ADMIN] Patch email theme settings',
-      method: 'PATCH',
-      path: '/:id/email-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      body: CompliancePatchEmailThemeSettings,
-      responses: {
-        201: IEmailThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchEmailThemeSetting: {
-      summary: '[ADMIN] Patch a email theme setting',
-      method: 'PATCH',
-      path: '/:id/email-theme/:emailThemeId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeSettingIdSchema,
-        emailThemeId: emailThemeIdSchema,
-      }),
-      body: CompliancePatchEmailThemeSetting,
-      responses: {
-        201: IEmailThemeSetting,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    importEmailThemeSettings: {
-      summary: '[ADMIN] Import email theme settings',
-      method: 'POST',
-      path: '/:id/import-email-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      body: ComplianceImportEmailThemeSettingsZod,
-      responses: {
-        201: IEmailThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    exportEmailThemeSettings: {
-      summary: '[ADMIN] Export email theme settings',
-      method: 'GET',
-      path: '/:id/export-email-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      responses: {
-        200: ExportEmailThemeSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchEmailThemeName: {
-      summary: '[ADMIN] Patch the name of a email theme',
-      method: 'PATCH',
-      path: '/:id/name',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      body: CompliancePatchEmailThemeNameZod,
-      responses: {
-        201: IEmailTheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'email-themes',
-  },
-);

package/contracts/compliance/escrow-accounts/index.ts

@@ -1,85 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  PaginationOptionsZod,
-  BadRequestError,
-} from '../../../common/types';
-import {
-  CompliancePostEscrowAccount,
-  escrowAccountIdSchema,
-  EscrowAccountsFilter,
-  EscrowAccountsIncludeQuery,
-  IEscrowAccount,
-  IPaginatedEscrowAccount,
-  PatchEscrowAccount,
-} from '../../../common/types/escrow-account.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const escrowAccountsContract = c.router(
-  {
-    getEscrowAccounts: {
-      summary: 'Get escrow accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(EscrowAccountsFilter).merge(
-        EscrowAccountsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedEscrowAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postEscrowAccount: {
-      summary: 'Create an escrow account',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostEscrowAccount,
-      /* 
-        for compliance portal we'll be taking accountId from body as `ESCROW ACCOUNT` will 
-        be of some issuer.
-      */
-      responses: {
-        201: IEscrowAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchEscrowAccount: {
-      summary: 'Update escrow account',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: escrowAccountIdSchema }),
-      body: PatchEscrowAccount,
-      responses: {
-        201: IEscrowAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'escrow-accounts',
-  },
-);