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

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

package/contracts/issuers/notes/index.ts

@@ -1,69 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  IPaginatedNote,
-  noteIdSchema,
-  NotesFilters,
-  NoteZod,
-  NotFoundError,
-  PaginationOptionsZod,
-  PostNoteBody,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerNotesContract = c.router(
-  {
-    postNote: {
-      summary: 'Create a note',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostNoteBody,
-      responses: {
-        201: NoteZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getNotes: {
-      summary: 'Get notes',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(NotesFilters),
-      responses: {
-        200: IPaginatedNote,
-        401: UnauthorizedError,
-      },
-    },
-    getNote: {
-      summary: 'Get note by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: noteIdSchema,
-      }),
-      responses: {
-        200: NoteZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'notes',
-  },
-);

package/contracts/issuers/notification-channels/index.ts

@@ -1,251 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  IssuerCreateChannelInputSchema,
-  CreateTriggerInputSchema,
-  IAvailableTriggersResponse,
-  INotificationChannelTriggerZod,
-  INotificationChannelZod,
-  INotificationRecordZod,
-  IPaginatedNotificationChannel,
-  IPaginatedNotificationRecord,
-  NotificationChannelFilters,
-  NotificationChannelsIncludeQuery,
-  notificationChannelIdSchema,
-  notificationChannelTriggerIdSchema,
-  NotificationRecordFilters,
-  NotificationRecordsIncludeQuery,
-  notificationRecordIdSchema,
-  UpdateChannelInputSchema,
-} from '../../../common/types/notification.types';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-
-const c = initContract();
-
-export const issuerNotificationChannelsContract = c.router(
-  {
-    getChannels: {
-      summary: 'Get notification channels for current account',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(
-        NotificationChannelFilters.omit({ accountSettingsId: true }),
-      ).merge(NotificationChannelsIncludeQuery),
-      responses: {
-        200: IPaginatedNotificationChannel,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    getChannel: {
-      summary: 'Get notification channel by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      query: z.object({}).merge(NotificationChannelsIncludeQuery),
-      responses: {
-        200: INotificationChannelZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createChannel: {
-      summary: 'Create notification channel for current account',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: IssuerCreateChannelInputSchema,
-      responses: {
-        201: INotificationChannelZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    updateChannel: {
-      summary: 'Update notification channel',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      body: UpdateChannelInputSchema,
-      responses: {
-        200: INotificationChannelZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteChannel: {
-      summary: 'Delete notification channel',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createTrigger: {
-      summary: 'Create notification channel trigger',
-      method: 'POST',
-      path: '/:id/triggers',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      body: CreateTriggerInputSchema.omit({ notificationChannelId: true }),
-      responses: {
-        201: INotificationChannelTriggerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getAvailableTriggers: {
-      summary: 'Get all available triggers for a channel',
-      method: 'GET',
-      path: '/:id/triggers/available',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      responses: {
-        200: IAvailableTriggersResponse,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateTrigger: {
-      summary: 'Update notification channel trigger',
-      method: 'PATCH',
-      path: '/:id/triggers/:triggerId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-        triggerId: notificationChannelTriggerIdSchema,
-      }),
-      body: z.object({ enabled: z.boolean() }),
-      responses: {
-        200: INotificationChannelTriggerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteTrigger: {
-      summary: 'Delete notification channel trigger',
-      method: 'DELETE',
-      path: '/:id/triggers/:triggerId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-        triggerId: notificationChannelTriggerIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getRecords: {
-      summary: 'Get notification records for current account',
-      method: 'GET',
-      path: '/records',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(NotificationRecordFilters).merge(
-        NotificationRecordsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedNotificationRecord,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    getRecord: {
-      summary: 'Get notification record by id',
-      method: 'GET',
-      path: '/records/:recordId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        recordId: notificationRecordIdSchema,
-      }),
-      query: z.object({}).merge(NotificationRecordsIncludeQuery),
-      responses: {
-        200: INotificationRecordZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    retryRecord: {
-      summary: 'Retry failed notification record',
-      method: 'POST',
-      path: '/records/:recordId/retry',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        recordId: notificationRecordIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: INotificationRecordZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'notification-channels',
-  },
-);