@dalmore/api-contracts 0.0.0-dev.d07da18 → 0.0.0-dev.d29fb02

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

@@ -1,148 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  IIndividualZod,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  tradeIdSchema,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  InvestorAccountsIncludeQuery,
-  investorAccountIdSchema,
-  IInvestorAccount,
-  IssuerInvestorAccountsFiltersZod,
-  IPaginatedInvestorAccounts,
-  InvestorAccountExportFilters,
-  GetInvestorAccountDetailsQuery,
-  RegisteredInvestorUserFiltersZod,
-  IPaginatedRegisteredInvestorUserZod,
-  IInvestorAccountSummary,
-} from '../../../common/types/investor-account.types';
-
-const c = initContract();
-
-export const investorAccountsContract = c.router(
-  {
-    exportInvestorAccounts: {
-      summary: 'Export investor accounts to CSV',
-      method: 'GET',
-      path: '/export',
-      query: InvestorAccountExportFilters,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    exportRegisteredInvestorUsers: {
-      summary: 'Export registered investor users to CSV',
-      method: 'GET',
-      path: '/registered-users/export',
-      query: RegisteredInvestorUserFiltersZod,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    getInvestorAccounts: {
-      summary: 'Get investor accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuerInvestorAccountsFiltersZod),
-      responses: {
-        200: IPaginatedInvestorAccounts,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getRegisteredInvestorUsers: {
-      summary: 'Get registered investor users',
-      method: 'GET',
-      path: '/registered-users',
-      query: PaginationOptionsZod.merge(RegisteredInvestorUserFiltersZod),
-      metadata: {
-        auth: true,
-      },
-      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,
-      },
-    },
-    getInvestorAccountDetails: {
-      summary: 'Get investor account details',
-      method: 'GET',
-      path: '/:id/details',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: investorAccountIdSchema,
-      }),
-      query: GetInvestorAccountDetailsQuery,
-      responses: {
-        200: IIndividualZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    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,
-      },
-    },
-  },
-  {
-    pathPrefix: 'investor-accounts',
-  },
-);

package/contracts/issuers/invites/index.ts

@@ -1,129 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  NotFoundError,
-  InternalError,
-  InviteWithUrl,
-  IPaginatedInvite,
-  PaginationOptionsZod,
-  PostIssuerInviteZod,
-  IssuerInvitesFiltersZod,
-  UnauthorizedError,
-  IssuerVerifyInviteResponse,
-  IssuerInvitesDecisionResponse,
-  inviteIdSchema,
-  InvitesIncludeQuery,
-  PatchInviteRoleZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerInvitesContract = c.router(
-  {
-    getInvites: {
-      summary: '[OWNER] Get invites',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuerInvitesFiltersZod).merge(
-        InvitesIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedInvite,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    verifyInvite: {
-      summary: 'Verify invite',
-      method: 'GET',
-      path: '/verify/:code',
-      pathParams: z.object({
-        code: z.string(),
-      }),
-      responses: {
-        200: IssuerVerifyInviteResponse,
-        400: BadRequestError,
-        404: NotFoundError,
-      },
-    },
-    postInvite: {
-      summary: '[OWNER] Invite user',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostIssuerInviteZod,
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    acceptInvite: {
-      summary: 'Accept invite',
-      method: 'PATCH',
-      path: '/accept/:id',
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        201: IssuerInvitesDecisionResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    rejectInvite: {
-      summary: 'Verify invite',
-      method: 'PATCH',
-      path: '/reject/:id',
-      body: z.object({}),
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      responses: {
-        201: IssuerInvitesDecisionResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchInviteRole: {
-      summary: 'Patch invite role',
-      method: 'PATCH',
-      path: '/role/:id',
-      pathParams: z.object({
-        id: inviteIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: PatchInviteRoleZod,
-      responses: {
-        201: InviteWithUrl,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'invites',
-  },
-);

package/contracts/issuers/issuer/index.ts

@@ -1,94 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  GetIssuersZod,
-  IIssuer,
-  IPaginatedIssuer,
-  IssuersIncludeQuery,
-  issuerIdSchema,
-  PostIssuerZod,
-  PutIssuerZod,
-} from '../../../common/types/issuer.types';
-const c = initContract();
-
-export const issuerContract = c.router(
-  {
-    getIssuers: {
-      summary: 'Get Issuers',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(IssuersIncludeQuery).merge(GetIssuersZod),
-      responses: {
-        200: IPaginatedIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    postIssuer: {
-      summary: 'Create an issuer',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostIssuerZod,
-      responses: {
-        201: IIssuer,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    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,
-      },
-    },
-    updateIssuer: {
-      summary: 'Update issuer',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerIdSchema,
-      }),
-      body: PutIssuerZod,
-      responses: {
-        201: IIssuer,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuers',
-  },
-);

package/contracts/issuers/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/issuers/issuer-payment-methods/index.ts

@@ -1,136 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  GetIssuerPaymentMethodZod,
-  IIssuerPaymentMethod,
-  IPaginatedIssuerPaymentMethod,
-  issuerPaymentMethodIdSchema,
-  PatchIssuerPaymentMethodZod,
-  PaginationOptionsZod,
-  ConnectIssuerPaymentMethodZod,
-  BadRequestError,
-} 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(GetIssuerPaymentMethodZod),
-      responses: {
-        200: IPaginatedIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchIssuerPaymentMethod: {
-      summary: 'PATCH issuer payment method',
-      method: 'PATCH',
-      path: '/:id',
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      body: PatchIssuerPaymentMethodZod,
-      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(),
-      }),
-      responses: {
-        200: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    connectIssuerPaymentMethod: {
-      summary: 'Connect issuer payment method',
-      method: 'POST',
-      path: '/integrations/connect',
-      metadata: {
-        auth: true,
-      },
-      body: ConnectIssuerPaymentMethodZod,
-      responses: {
-        200: z.array(IIssuerPaymentMethod),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    disconnectIssuerPaymentMethod: {
-      summary: 'Disconnect issuer payment method',
-      method: 'PATCH',
-      path: '/:id/integrations/disconnect',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createIssuerPaymentMethodAccountLink: {
-      summary: 'Create issuer payment method account link',
-      method: 'POST',
-      path: '/:id/integrations/account-link',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: issuerPaymentMethodIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: IIssuerPaymentMethod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'issuer-payment-methods',
-  },
-);

package/contracts/issuers/kyc/index.ts

@@ -1,38 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-  inquiryIdSchema,
-  InquiryResponse,
-  ServiceUnavailableError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const kycsContract = c.router(
-  {
-    getInquiry: {
-      summary: 'KYC inquiry by ID',
-      method: 'GET',
-      path: '/inquiries/:inquiryId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        inquiryId: inquiryIdSchema,
-      }),
-      responses: {
-        200: InquiryResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-        503: ServiceUnavailableError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'kycs',
-  },
-);

package/contracts/issuers/login-histories/index.ts

@@ -1,51 +0,0 @@
-import { initContract } from '@ts-rest/core';
-
-import {
-  BadRequestError,
-  ForbiddenError,
-  UnauthorizedError,
-  IListLoginHistories,
-  userIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const loginHistoriesContract = c.router(
-  {
-    getLoginHistories: {
-      summary: 'Get Login Histories',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: IListLoginHistories,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getLoginHistoriesByUserId: {
-      summary: 'Get Login Histories by User id',
-      method: 'GET',
-      path: '/:userId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        userId: userIdSchema,
-      }),
-      responses: {
-        200: IListLoginHistories,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'login-histories',
-  },
-);