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

package/contracts/compliance/state-machine/index.ts

@@ -1,94 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  CreateStateMachineConfigurationZod,
-  DebugStateMachineZod,
-  StartStateMachineZod,
-  StateMachineConfigurationZod,
-  StateMachineResponseZod,
-  StateMachineType,
-} from '../../../common/types/state-machine.types';
-
-const c = initContract();
-
-export const stateMachineContract = c.router(
-  {
-    createStateMachineConfiguration: {
-      summary: 'Create a state machine configuration',
-      method: 'POST',
-      path: '/configuration',
-      body: CreateStateMachineConfigurationZod,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        201: StateMachineConfigurationZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-
-    getStateMachineConfigurations: {
-      summary: 'Get state machine configurations',
-      method: 'GET',
-      path: '/:type/configuration',
-      pathParams: z.object({
-        type: z.nativeEnum(StateMachineType),
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.array(StateMachineConfigurationZod),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    startStateMachine: {
-      summary: 'Start a state machine',
-      method: 'POST',
-      path: '/start',
-      body: StartStateMachineZod,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: StateMachineResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    debugStateMachine: {
-      summary: 'Step forward in debug mode',
-      method: 'POST',
-      path: '/debug',
-      body: DebugStateMachineZod,
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: StateMachineResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'state-machines',
-  },
-);

package/contracts/compliance/tasks/index.ts

@@ -1,91 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  IPaginatedTask,
-  TaskFiltersZod,
-  TaskZod,
-  NotFoundError,
-  PaginationOptionsZod,
-  PostTaskBody,
-  UnauthorizedError,
-  taskIdSchema,
-  MarkTaskAsDoneZod,
-  accountIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const tasksContract = c.router(
-  {
-    postTask: {
-      summary: 'Create a task',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostTaskBody,
-      responses: {
-        201: TaskZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getTasks: {
-      summary: 'Get tasks',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(TaskFiltersZod),
-      responses: {
-        200: IPaginatedTask,
-        401: UnauthorizedError,
-      },
-    },
-    getTask: {
-      summary: 'Get task by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: taskIdSchema,
-      }),
-      responses: {
-        200: TaskZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    markTaskAsDone: {
-      summary: 'Mark task as done',
-      method: 'PATCH',
-      path: '/:id/done',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: taskIdSchema,
-      }),
-      body: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: MarkTaskAsDoneZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'tasks',
-  },
-);

package/contracts/compliance/third-parties/index.ts

@@ -1,52 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import { TemplatesPaginatedZod } from '../../../common/types/signer.types';
-import { z } from 'zod';
-import { StripeConnectedAccountZod } from '../../../common/types/payment-methods.types';
-
-const c = initContract();
-
-export const thirdPartiesContract = c.router(
-  {
-    getPaginatedBoldSignTemplates: {
-      summary: 'Get paginated boldSign templates',
-      method: 'GET',
-      path: '/boldsign/templates',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: TemplatesPaginatedZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getStripeConnectedAccounts: {
-      summary: 'Get stripe connected accounts',
-      method: 'GET',
-      path: '/stripe/accounts',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.array(StripeConnectedAccountZod),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'third-parties',
-  },
-);

package/contracts/compliance/trade-line-items/index.ts

@@ -1,59 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  accountIdSchema,
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  IPaginatedTradeLineItem,
-  ReviewTradeLineItemStatus,
-  TradeLineItemFiltersQuery,
-  TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.types';
-
-import { z } from 'zod';
-const c = initContract();
-
-export const tradeLineItemsContract = c.router(
-  {
-    getPaginatedTradesLineItems: {
-      summary: 'Get trades lineItems with pagination',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: TradeLineItemFiltersQuery.merge(PaginationOptionsZod),
-      responses: {
-        200: IPaginatedTradeLineItem,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewLineItemSignatureStatus: {
-      summary: '[ADMIN] Review Trade Line Item Signature Status',
-      method: 'POST',
-      path: '/review',
-      metadata: { auth: true },
-      body: ReviewTradeLineItemStatus.merge(
-        z.object({ accountId: accountIdSchema }),
-      ),
-      responses: {
-        200: TradeLineItemResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        400: BadRequestError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'trade-line-items',
-  },
-);

package/contracts/compliance/trades/index.ts

@@ -1,249 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedTrade,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  TradeZod,
-  TradeFiltersZod,
-  reviewTrades,
-  reviewAllTrades,
-  TradesIncludeQuery,
-  tradeIdSchema,
-  IPaginatedReviewTrade,
-  ReviewTradeZod,
-  InternalError,
-  PatchSaLogSchema,
-  ProcessPaymentZod,
-  ProcessPaymentResponse,
-  TradeSortZod,
-  ComplianceTradesFiltersZod,
-  GetTemplateVariablesForTradeZod,
-  ExportTradesQuery,
-  CancelTradeResponse,
-  ComplianceCancelTradeZod,
-  GetTradeSnapshotEventsResponse,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const tradesContract = c.router(
-  {
-    getTemplateVariablesForTrade: {
-      summary: 'Get template variables for trade with Boldsign',
-      method: 'GET',
-      path: '/:id/boldsign',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      responses: {
-        200: GetTemplateVariablesForTradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getTradeSnapshotEvents: {
-      summary: 'Get trade snapshot events',
-      method: 'GET',
-      path: '/:id/snapshot-events',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      responses: {
-        200: GetTradeSnapshotEventsResponse,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getTrade: {
-      summary: 'Get trade by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(TradeFiltersZod).merge(TradesIncludeQuery),
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      responses: {
-        200: TradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getTrades: {
-      summary: 'Get trades',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(TradeFiltersZod)
-        .merge(ComplianceTradesFiltersZod)
-        .merge(TradesIncludeQuery)
-        .merge(TradeSortZod),
-      responses: {
-        200: IPaginatedTrade,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    exportTrades: {
-      summary: 'Export trades into a csv file',
-      method: 'GET',
-      path: '/export',
-      metadata: {
-        auth: true,
-      },
-      query: ExportTradesQuery,
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getPaginatedReviewTrades: {
-      summary: 'Get review trades with pagination',
-      method: 'GET',
-      path: '/review/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      responses: {
-        200: IPaginatedReviewTrade,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewTrades: {
-      summary: 'Review Trades',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: reviewTrades,
-      responses: {
-        201: ReviewTradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    reviewAllTrades: {
-      summary: 'Review All Trades',
-      method: 'POST',
-      path: '/review/all',
-      metadata: {
-        auth: true,
-      },
-      body: reviewAllTrades,
-      responses: {
-        201: ReviewTradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-
-    // Triggers the cron job for debug purposes
-    tradeReview: {
-      summary: '[SUPER ADMIN] Start Trade Review',
-      method: 'POST',
-      path: '/trade-review',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        start: z.boolean(),
-      }),
-      responses: {
-        200: z.object({ status: z.string() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    updateTradeSaLog: {
-      summary: 'Update Trade Sa Log',
-      method: 'PATCH',
-      path: '/:id/sa-log',
-      metadata: {
-        auth: true,
-      },
-      body: PatchSaLogSchema,
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      responses: {
-        201: TradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    processPayment: {
-      summary: 'Process Payment',
-      method: 'POST',
-      path: '/process-payment',
-      metadata: {
-        auth: true,
-      },
-      body: ProcessPaymentZod,
-      responses: {
-        201: ProcessPaymentResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    cancelTrade: {
-      summary: 'Cancel Trade',
-      method: 'PUT',
-      path: '/cancel/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      body: ComplianceCancelTradeZod,
-      responses: {
-        201: CancelTradeResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'trades',
-  },
-);

package/contracts/compliance/transactions/index.ts

@@ -1,161 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ComplianceTransactionQueryZod,
-  CreateRefundZod,
-  GetRefundResponseZod,
-  GetTransactionRefundsResponseZod,
-  PostTransactionZod,
-  refundTransactionIdSchema,
-  RefundTransactionZod,
-  transactionIdSchema,
-  TransactionZod,
-  UpdateRefundZod,
-} from '../../../common/types/transaction.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const transactionsContract = c.router(
-  {
-    markTransactionAsReceived: {
-      summary: 'Mark a transaction as received',
-      method: 'PATCH',
-      path: '/:id/received',
-      query: ComplianceTransactionQueryZod,
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: transactionIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        201: TransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postTransaction: {
-      summary: 'Create a transaction',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostTransactionZod,
-      responses: {
-        201: TransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    voidTransaction: {
-      summary: 'Void a transaction',
-      method: 'PATCH',
-      path: '/:id/void',
-      query: ComplianceTransactionQueryZod,
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: transactionIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        201: TransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getTransactionRefunds: {
-      summary: 'Get All Refunds for Transaction',
-      description:
-        'Retrieves all refunds for a transaction with balance summary',
-      method: 'GET',
-      path: '/:id/refunds',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: transactionIdSchema,
-      }),
-      responses: {
-        200: GetTransactionRefundsResponseZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createRefund: {
-      summary: 'Create Refund Transaction',
-      description: 'Creates a refund for a settled CHECK or WIRE transaction',
-      method: 'POST',
-      path: '/refund',
-      metadata: {
-        auth: true,
-      },
-      body: CreateRefundZod,
-      responses: {
-        201: RefundTransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getRefund: {
-      summary: 'Get Refund Transaction',
-      description:
-        'Retrieves refund details with calculated transaction balance',
-      method: 'GET',
-      path: '/refund/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: refundTransactionIdSchema,
-      }),
-      responses: {
-        200: GetRefundResponseZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateRefund: {
-      summary: 'Update Refund Transaction',
-      description: 'Updates refund status (PENDING→SETTLED/CANCELLED) or notes',
-      method: 'PATCH',
-      path: '/refund/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: refundTransactionIdSchema,
-      }),
-      body: UpdateRefundZod,
-      responses: {
-        200: RefundTransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'transactions',
-  },
-);