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

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

@@ -1,141 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  accountIdSchema,
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  tradeIdSchema,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  ExportInvestorAccountsResponse,
-  IInvestorAccount,
-  IInvestorAccountSummary,
-  investorAccountIdSchema,
-  InvestorAccountsFiltersZod,
-  InvestorAccountsIncludeQuery,
-  InvestorAccountsSortZod,
-  IPaginatedInvestorAccounts,
-  IPaginatedRegisteredInvestorUserZod,
-  RegisteredInvestorUserFiltersZod,
-  SeedInvestorAccountsForDemoUsersZod,
-} from '../../../common/types/investor-account.types';
-
-const c = initContract();
-
-export const investorAccountsContract = c.router(
-  {
-    getRegisteredInvestorUsers: {
-      summary: 'Get registered investor users',
-      method: 'GET',
-      path: '/registered-users/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      query: PaginationOptionsZod.merge(RegisteredInvestorUserFiltersZod),
-      responses: {
-        200: IPaginatedRegisteredInvestorUserZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    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: PaginationOptionsZod.merge(InvestorAccountsFiltersZod).merge(
-        InvestorAccountsSortZod,
-      ),
-      responses: {
-        200: IPaginatedInvestorAccounts,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getInvestorAccountSummary: {
-      summary: 'Get investor account summary',
-      method: 'GET',
-      path: '/:id/summary',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: investorAccountIdSchema,
-      }),
-      query: z.object({
-        tradeId: tradeIdSchema.optional(),
-      }),
-      responses: {
-        200: IInvestorAccountSummary,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    seedInvestorAccountsForDemoUsers: {
-      summary: '[Admin] Seed investor accounts for demo users',
-      method: 'POST',
-      path: '/seed',
-      metadata: {
-        auth: true,
-      },
-      body: SeedInvestorAccountsForDemoUsersZod,
-      responses: {
-        200: ExportInvestorAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    seedInvestorAccountsForAllDemoUsers: {
-      summary: '[Admin] Seed investor accounts for all demo users',
-      method: 'POST',
-      path: '/seed-all',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({}),
-      responses: {
-        200: ExportInvestorAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'investor-accounts',
-  },
-);

package/contracts/compliance/invites/index.ts

@@ -1,137 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  inviteIdSchema,
-  InviteWithoutSecretZod,
-  InviteWithUrl,
-  IPaginatedInvite,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchInviteForComplianceZod,
-  PortalType,
-  UnauthorizedError,
-  UserRole,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const invitesContract = c.router(
-  {
-    getInvites: {
-      summary: '[ADMIN] Get invites',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPaginatedInvite,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    postInvite: {
-      summary: '[ADMIN] Invite user',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        email: z.string().email(),
-        role: z.nativeEnum(UserRole),
-        accountId: z.string().optional(),
-        portalType: z.nativeEnum(PortalType).optional(),
-      }),
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    postInviteForCompliance: {
-      summary: '[ADMIN] Invite user for Compliance',
-      method: 'POST',
-      path: '/compliance',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        email: z.string().email(),
-        role: z.nativeEnum(UserRole),
-      }),
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    verifyInvite: {
-      summary: 'Verify invite',
-      method: 'GET',
-      path: '/verify/:code',
-      pathParams: z.object({
-        code: z.string(),
-      }),
-      responses: {
-        200: z.object({
-          valid: z.boolean(),
-          email: z.string().email().nullable(),
-        }),
-        400: BadRequestError,
-      },
-    },
-    patchInviteRole: {
-      summary: 'Patch invite role',
-      method: 'PATCH',
-      path: '/:id/role',
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: PatchInviteForComplianceZod,
-      responses: {
-        201: InviteWithoutSecretZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteInvite: {
-      summary: 'Delete invite by id',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      responses: {
-        200: z.object({
-          message: z.string(),
-        }),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'invites',
-  },
-);

package/contracts/compliance/issuer-bank-accounts/index.ts

@@ -1,81 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  PaginationOptionsZod,
-  BadRequestError,
-} from '../../../common/types';
-import {
-  IIssuerBankAccount,
-  IPaginatedIssuerBankAccount,
-  issuerBankAccountIdSchema,
-  IssuerBankAccountsFilter,
-  IssuerBankAccountsIncludeQuery,
-  PatchIssuerBankAccount,
-  PostIssuerBankAccount,
-} from '../../../common/types/issuer-bank-account.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerBankAccountsContract = c.router(
-  {
-    getIssuerBankAccounts: {
-      summary: 'Get issuer bank accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuerBankAccountsFilter).merge(
-        IssuerBankAccountsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedIssuerBankAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postIssuerBankAccount: {
-      summary: 'Create an issuer bank account',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostIssuerBankAccount,
-      responses: {
-        201: IIssuerBankAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchIssuerBankAccount: {
-      summary: 'Update issuer bank account',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: issuerBankAccountIdSchema }),
-      body: PatchIssuerBankAccount,
-      responses: {
-        201: IIssuerBankAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuer-bank-accounts',
-  },
-);

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

@@ -1,81 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  ComplianceGetIssuerPaymentMethodZod,
-  IIssuerPaymentMethod,
-  IPaginatedIssuerPaymentMethod,
-  issuerPaymentMethodIdSchema,
-  PaginationOptionsZod,
-  accountIdSchema,
-  CompliancePatchIssuerPaymentMethodZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerPaymentMethodsContract = c.router(
-  {
-    getIssuerPaymentMethods: {
-      summary: 'get payment methods',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ComplianceGetIssuerPaymentMethodZod),
-      responses: {
-        200: IPaginatedIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchIssuerPaymentMethod: {
-      summary: 'PATCH issuer payment method for compliance',
-      method: 'PATCH',
-      path: '/:id',
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchIssuerPaymentMethodZod,
-      responses: {
-        201: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    toggleIssuerPaymentMethod: {
-      summary: 'Toggle issuer payment method',
-      method: 'PATCH',
-      path: '/:id/toggle',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      body: z.object({
-        enabled: z.boolean(),
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuer-payment-methods',
-  },
-);

package/contracts/compliance/issuers/index.ts

@@ -1,97 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  CompliancePostIssuerZod,
-  IIssuer,
-  IPaginatedIssersSummary,
-  issuerIdSchema,
-  IssuersIncludeQuery,
-  IssuersSortZod,
-  IssuersSummaryFilterZod,
-  PutIssuerZod,
-} from '../../../common/types/issuer.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuersContract = c.router(
-  {
-    getIssuersSummary: {
-      summary: 'Get Issuers Summary',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuersSummaryFilterZod).merge(
-        IssuersSortZod,
-      ),
-      responses: {
-        200: IPaginatedIssersSummary,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getIssuer: {
-      summary: 'Get issuer by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(IssuersIncludeQuery),
-      pathParams: z.object({ id: issuerIdSchema }),
-      responses: {
-        200: IIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    postIssuer: {
-      summary: '[ADMIN] Create an issuer for a specific account',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostIssuerZod,
-      responses: {
-        201: IIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    updateIssuer: {
-      summary: 'Update issuer',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerIdSchema,
-      }),
-      body: PutIssuerZod,
-      responses: {
-        200: IIssuer,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuers',
-  },
-);

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

@@ -1,58 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  IPaginatedJobItem,
-  JobItemFiltersZod,
-  JobItemIdSchema,
-  JobItemZod,
-} from '../../../common/types/job-item.types';
-
-const c = initContract();
-
-export const jobItemsContract = c.router(
-  {
-    getJobItems: {
-      summary: 'Get job items',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(JobItemFiltersZod),
-      responses: {
-        200: IPaginatedJobItem,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getJobItem: {
-      summary: 'Get job item by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: JobItemIdSchema,
-      }),
-      responses: {
-        200: JobItemZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'job-items',
-  },
-);

package/contracts/compliance/jobs/index.ts

@@ -1,59 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  CheckInvestorParamsSchema,
-  ForbiddenError,
-  QueueTradeSaLogSchema,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const jobsContract = c.router(
-  {
-    postInvestorCheck: {
-      summary: 'Create a investor check',
-      method: 'POST',
-      path: '/investor-check',
-      metadata: {
-        auth: true,
-      },
-      body: CheckInvestorParamsSchema,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    queueInvestorCheck: {
-      summary: 'Manually trigger the queue check',
-      method: 'GET',
-      path: '/queue-investor-check',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    queueTradeSaLog: {
-      summary: 'Manually trigger the queue trade sa log',
-      method: 'POST',
-      path: '/queue-trade-salog',
-      metadata: {
-        auth: true,
-      },
-      body: QueueTradeSaLogSchema,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'jobs',
-  },
-);

package/contracts/compliance/kyb/index.ts

@@ -1,54 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedKyb,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  KybZod,
-  KybFiltersZod,
-  kybIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const kybsContract = c.router(
-  {
-    getKyb: {
-      summary: 'Get kyb by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(KybFiltersZod),
-      pathParams: z.object({
-        id: kybIdSchema,
-      }),
-      responses: {
-        200: KybZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getKybs: {
-      summary: 'Get kybs',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(KybFiltersZod),
-      responses: {
-        200: IPaginatedKyb,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'kybs',
-  },
-);