@dalmore/api-contracts 0.0.0-dev.58a860b → 0.0.0-dev.64aba85

package/contracts/issuers/trades/index.ts

@@ -1,132 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedTrade,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  TradeZod,
-  TradesIncludeQuery,
-  tradeIdSchema,
-  IssuersTradeFiltersZod,
-  reviewTrades,
-  CancelTradeResponse,
-  InternalError,
-  CancelTradeZod,
-  TradeDisbursementsZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerTradesContract = c.router(
-  {
-    exportTrades: {
-      summary: 'Export trades into a csv file',
-      method: 'GET',
-      path: '/export',
-      metadata: {
-        auth: true,
-      },
-      query: IssuersTradeFiltersZod,
-      responses: {
-        200: z.unknown(),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    getTrade: {
-      summary: 'Get trade by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z
-        .object({})
-        .merge(IssuersTradeFiltersZod)
-        .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(IssuersTradeFiltersZod).merge(
-        TradesIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedTrade,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getTradeDisbursements: {
-      summary: 'Get trade disbursements',
-      method: 'GET',
-      path: '/:id/disbursements',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      responses: {
-        200: TradeDisbursementsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    reviewTrade: {
-      summary: 'Review Trades',
-      method: 'PATCH',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: reviewTrades,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    cancelTrade: {
-      summary: 'Cancel Trade',
-      method: 'PUT',
-      path: '/cancel/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      body: CancelTradeZod,
-      responses: {
-        201: CancelTradeResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'trades',
-  },
-);

package/contracts/issuers/transactions/index.ts

@@ -1,158 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  PostTransactionZod,
-  transactionIdSchema,
-  TransactionZod,
-  CreateRefundZod,
-  UpdateRefundZod,
-  RefundTransactionZod,
-  GetRefundResponseZod,
-  GetTransactionRefundsResponseZod,
-  refundTransactionIdSchema,
-} from '../../../common/types/transaction.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerTransactionsContract = c.router(
-  {
-    markTransactionAsReceived: {
-      summary: 'Mark a transaction as received',
-      method: 'PATCH',
-      path: '/:id/received',
-      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',
-      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',
-  },
-);

package/contracts/issuers/user-manuals/index.ts

@@ -1,62 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  IPaginatedUserManualCategory,
-  IUserManualCategory,
-  userManualCategoriesIncludeQuery,
-  userManualCategorySchema,
-  GetLimitedUserManualCategoryZod,
-  UserManualsPaginationOptionsZod,
-} from '../../../common/types/user-manual.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const userManualsContract = c.router(
-  {
-    getUserManualCategories: {
-      summary: 'Get user manual Categories',
-      method: 'GET',
-      path: '/categories',
-      metadata: {
-        auth: true,
-      },
-      query: UserManualsPaginationOptionsZod.merge(
-        userManualCategoriesIncludeQuery,
-      ).merge(GetLimitedUserManualCategoryZod),
-      responses: {
-        200: IPaginatedUserManualCategory,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getUserManualCategory: {
-      summary: 'Get user manual category',
-      method: 'GET',
-      path: '/categories/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: userManualCategorySchema,
-      }),
-      query: z.object({}).merge(userManualCategoriesIncludeQuery),
-      responses: {
-        200: IUserManualCategory,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'user-manuals',
-  },
-);

package/contracts/issuers/user-settings/index.ts

@@ -1,170 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  sendEmailVerificationBody,
-  sendEmailVerificationResponse,
-  sendVerificationCodeBody,
-  sendVerificationCodeResponse,
-  setupPhoneNumberBody,
-  setupPhoneNumberResponse,
-  setupTwoFactorResponse,
-  userSettingsZod,
-  validPhoneNumberBody,
-  validPhoneNumberResponse,
-  verifyEmailBody,
-  verifyEmailResponse,
-  verifyPhoneNumberBody,
-  verifyPhoneNumberResponse,
-  verifyTwoFactorBody,
-  verifyTwoFactorResponse,
-} from '../../../common/types/user-setting.types';
-
-const c = initContract();
-
-export const userSettingsContract = c.router(
-  {
-    getUserSettings: {
-      summary: 'Get current user settings',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: userSettingsZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    validPhoneNumber: {
-      summary: 'Validate phone number',
-      method: 'POST',
-      path: '/valid-phone-number',
-      metadata: {
-        auth: true,
-      },
-      body: validPhoneNumberBody,
-      responses: {
-        200: validPhoneNumberResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    setupPhoneNumber: {
-      summary: 'Setup phone number',
-      method: 'POST',
-      path: '/setup-phone-number',
-      metadata: {
-        auth: true,
-      },
-      body: setupPhoneNumberBody,
-      responses: {
-        200: setupPhoneNumberResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    verifyPhoneNumber: {
-      summary: 'Verify phone number',
-      method: 'POST',
-      path: '/verify-phone-number',
-      metadata: {
-        auth: true,
-      },
-      body: verifyPhoneNumberBody,
-      responses: {
-        200: verifyPhoneNumberResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    sendVerificationCode: {
-      summary: 'Send verification code',
-      method: 'POST',
-      path: '/send-verification-code',
-      metadata: {
-        auth: true,
-      },
-      body: sendVerificationCodeBody,
-      responses: {
-        200: sendVerificationCodeResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    setupTwoFactorAuthenticator: {
-      summary: 'Setup 2FA',
-      method: 'GET',
-      path: '/setup-authenticator',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        201: setupTwoFactorResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    verifyTwoFactorAuthenticator: {
-      summary: 'Verify 2FA',
-      method: 'POST',
-      path: '/verify-authenticator',
-      body: verifyTwoFactorBody,
-      responses: {
-        201: verifyTwoFactorResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    sendEmailVerification: {
-      summary: 'Send email verification code',
-      method: 'POST',
-      path: '/send-email-verification',
-      metadata: {
-        auth: true,
-      },
-      body: sendEmailVerificationBody,
-      responses: {
-        200: sendEmailVerificationResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        429: BadRequestError,
-        500: InternalError,
-      },
-    },
-    verifyEmail: {
-      summary: 'Verify email with code',
-      method: 'POST',
-      path: '/verify-email',
-      metadata: {
-        auth: true,
-      },
-      body: verifyEmailBody,
-      responses: {
-        200: verifyEmailResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'user-settings',
-  },
-);

package/contracts/issuers/users/index.ts

@@ -1,126 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  GetMeResponse,
-  InternalError,
-  IPaginatedUser,
-  IssuersActiveStatusUpdateZod,
-  IssuersUsersFiltersZod,
-  IssuerUsersStatusUpdateResponse,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  UpdateUserRoleZod,
-  userIdSchema,
-  UserMeUpdateZod,
-  UsersIncludeQuery,
-  UserWithoutPasswordZod,
-  UserZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerUsersContract = c.router(
-  {
-    getUsers: {
-      summary: 'Get users',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuersUsersFiltersZod).merge(
-        UsersIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedUser,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    me: {
-      summary: 'Get current user',
-      method: 'GET',
-      path: '/me',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetMeResponse,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getUser: {
-      summary: 'Get user by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(UsersIncludeQuery),
-      pathParams: z.object({
-        id: z.string(),
-      }),
-      responses: {
-        200: UserZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    updateMe: {
-      summary: 'Update current user',
-      method: 'PATCH',
-      path: '/me',
-      metadata: {
-        auth: true,
-      },
-      body: UserMeUpdateZod,
-      responses: {
-        201: UserWithoutPasswordZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateActiveStatus: {
-      summary: 'Update current user',
-      method: 'PATCH',
-      path: '/active/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: userIdSchema }),
-      body: IssuersActiveStatusUpdateZod,
-      responses: {
-        201: IssuerUsersStatusUpdateResponse,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateRole: {
-      summary: 'Update user role',
-      method: 'PATCH',
-      path: '/role',
-      metadata: {
-        auth: true,
-      },
-      body: UpdateUserRoleZod,
-      responses: {
-        201: UserWithoutPasswordZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'users',
-  },
-);

package/contracts/secondaries/accounts/index.ts

@@ -1,58 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedAccount,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  AccountFiltersZod,
-  AccountsIncludeQuery,
-  AccountZod,
-  accountIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const accountsContract = c.router(
-  {
-    getAccount: {
-      summary: 'Get account by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(AccountsIncludeQuery),
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      responses: {
-        200: AccountZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getAccounts: {
-      summary: 'Get accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(AccountFiltersZod).merge(
-          AccountsIncludeQuery,
-        ),
-      responses: {
-        200: IPaginatedAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'accounts',
-  },
-);