@dalmore/api-contracts 0.0.0-dev.2047f71 → 0.0.0-dev.3af7603

package/contracts/clients/cart/index.ts

@@ -0,0 +1,80 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  BadRequestError,
+  InternalError,
+  TradeZod,
+  userIdSchema,
+  tradeIdSchema,
+} from '../../../common/types';
+import {
+  PatchCartBody,
+  ClientPlacetradeBody,
+  PlaceTradeResponse,
+} from '../../../common/types/cart.types';
+
+const c = initContract();
+
+export const cartContract = c.router(
+  {
+    getTradeCart: {
+      summary: 'Get carts (Trade.status = CART)',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postCheckout: {
+      summary: 'Place a trade (checkout button)',
+      method: 'POST',
+      path: '/checkout',
+      metadata: {
+        auth: true,
+      },
+      body: ClientPlacetradeBody,
+      responses: {
+        200: PlaceTradeResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchCart: {
+      summary: 'Patch a cart',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: PatchCartBody,
+      responses: {
+        200: TradeZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'carts',
+  },
+);

package/contracts/clients/index.ts

@@ -3,6 +3,7 @@ import { accountsContract } from './accounts';
 import { apiKeysContract } from './api-keys';
 import { clientApiKeyLogsContract } from './api-key-logs';
 import { assetsContract } from './assets';
+import { cartContract } from './cart';
 import { filesContract } from './files';
 import { individualsContract } from './individuals';
 import { investorAccountsContract } from './investor-accounts';
@@ -15,6 +16,10 @@ import { secureRequestContract } from './secure-requests';
 import { aicContract } from './aic';
 import { authContract } from './auth';
 import { sitesContract } from './sites';
+import { paymentMethodsContract } from './payment-methods';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { tradeLineItemsContract } from './trade-line-items';
+import { clientsTransactionsContract } from './transactions';
 
 const c = initContract();
 
@@ -27,16 +32,21 @@ export const clientsContract = c.router(
     apiKeys: apiKeysContract,
     apiKeyLogs: clientApiKeyLogsContract,
     assets: assetsContract,
+    cart: cartContract,
     files: filesContract,
     filesPublic: filesPublicContract,
     individuals: individualsContract,
     investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
     issuers: issuersContract,
     legalEntities: legalEntityContract,
     offerings: offeringsContract,
+    paymentMethods: paymentMethodsContract,
     secureRequests: secureRequestContract,
     sites: sitesContract,
+    tradeLineItems: tradeLineItemsContract,
     trades: tradesContract,
+    transactions: clientsTransactionsContract,
   },
   {
     pathPrefix: '/clients/api/v1/',

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

@@ -0,0 +1,39 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IPaginatedIssuerPaymentMethod,
+  IssuerPaymentMethodsIncludeQuery,
+  PaginationOptionsZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerPaymentMethodsContract = c.router(
+  {
+    getIssuerPaymentMethods: {
+      summary: 'Get issuer payment methods',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(
+        IssuerPaymentMethodsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/clients/payment-methods/index.ts

@@ -0,0 +1,85 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  userIdSchema,
+  BadRequestError,
+  InternalError,
+} from '../../../common/types';
+import {
+  PaymentMethodResponseArray,
+  PaymentMethodResponse,
+  PostPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
+} from '../../../common/types/payment-methods.types';
+
+const c = initContract();
+
+export const paymentMethodsContract = c.router(
+  {
+    getPaymentMethods: {
+      summary: 'Get payment methods for a user',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: PaymentMethodResponseArray,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createPaymentMethod: {
+      summary: 'Create payment method for a user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSetupIntent: {
+      summary: 'Create payment method setup intent for a user',
+      method: 'POST',
+      path: '/intent',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostSetupIntentBody,
+      responses: {
+        201: SetupIntentResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'payment-methods',
+  },
+);

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

@@ -0,0 +1,66 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  userIdSchema,
+} from '../../../common/types';
+import {
+  PostTradeLineItem,
+  TradeLineItemParams,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+  TradeLineItemUpdate,
+} from '../../../common/types/trade-line-item.types';
+
+const c = initContract();
+
+export const tradeLineItemsContract = c.router(
+  {
+    postTradeLineItem: {
+      summary: 'Create Trade Line Item',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeLineItem,
+      query: TradeLineItemQuery.merge(
+        z.object({
+          userId: userIdSchema,
+        }),
+      ),
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateTradeLineItem: {
+      summary: 'Update Trade Line Item - Can delete if you pass quantity = 0',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: TradeLineItemParams,
+      body: TradeLineItemUpdate,
+      responses: {
+        200: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+        400: BadRequestError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trade-line-items',
+  },
+);

package/contracts/clients/trades/index.ts

@@ -16,13 +16,17 @@ import {
   tradeIdOrTidSchema,
   TradesIncludeQuery,
   TradeZod,
+  PostAttachSubdocBody,
+  PutAttachSubdocBody,
+  PatchSubdocSignatureBody,
+  AttachSubdocResponse,
 } from '../../../common/types/trade.types';
 import { z } from 'zod';
 import {
   PostTradeLineItem,
   TradeLineItemQuery,
   TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 
@@ -115,6 +119,66 @@ export const tradesContract = c.router(
         500: InternalError,
       },
     },
+    postAttachSubdoc: {
+      summary: 'Attach subdoc to trade',
+      method: 'POST',
+      path: '/:id/attach-subdoc',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PostAttachSubdocBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    putAttachSubdoc: {
+      summary: 'Update attached subdoc for trade',
+      method: 'PUT',
+      path: '/:id/attach-subdoc',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PutAttachSubdocBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchSubdocSign: {
+      summary: 'Update subdoc signature statuses for trade',
+      method: 'PATCH',
+      path: '/:id/sign',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PatchSubdocSignatureBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'trades',

package/contracts/clients/transactions/index.ts

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ClientPostTransactionZod,
+  TransactionZod,
+} from '../../../common/types/transaction.types';
+
+const c = initContract();
+
+export const clientsTransactionsContract = c.router(
+  {
+    postTransaction: {
+      summary: 'Create a transaction',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: ClientPostTransactionZod,
+      responses: {
+        201: TransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'transactions',
+  },
+);

package/contracts/compliance/bonus-tiers/index.ts

@@ -6,10 +6,12 @@ import {
   UnauthorizedError,
 } from '../../../common/types';
 import {
+  ComplianceEstimateBonusTierCalculationZod,
   CompliancePostBonusTierZod,
   EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
   IBonusTierList,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -23,7 +25,7 @@ export const bonusTiersContract = c.router(
       metadata: {
         auth: true,
       },
-      body: EstimateBonusTierCalculationZod,
+      body: ComplianceEstimateBonusTierCalculationZod,
       responses: {
         200: EstimateBonusTierCalculationResponseZod,
         400: BadRequestError,
@@ -32,6 +34,23 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary:
+        '[ADMIN] Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
     postBonusTier: {
       summary: 'Create a new bonus tier',
       method: 'POST',

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

@@ -13,7 +13,7 @@ import {
   ReviewTradeLineItemStatus,
   TradeLineItemFiltersQuery,
   TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 import { z } from 'zod';
 const c = initContract();

package/contracts/compliance/users/index.ts

@@ -21,6 +21,7 @@ import {
   IssuersActiveStatusUpdateZod,
   UpdateLockedStatus,
   UpdateUserRoleZod,
+  UserRestoreResponse,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -143,6 +144,26 @@ export const usersContract = c.router(
         500: InternalError,
       },
     },
+    restoreUser: {
+      summary: 'Restore user by id',
+      method: 'POST',
+      path: '/:id/restore',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: UserRestoreResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
     updateActiveStatus: {
       summary: '[Admin] Update user active status',
       method: 'PATCH',

package/contracts/investors/bonus-tiers/index.ts

@@ -8,6 +8,8 @@ import {
 import {
   EstimateBonusTierCalculationResponseZod,
   EstimateBonusTierCalculationZod,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -30,6 +32,22 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary: 'Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'bonus-tiers',

package/contracts/investors/individuals/index.ts

@@ -14,6 +14,8 @@ import {
   IIndividualZod,
   BadRequestError,
   InternalError,
+  IWillDoItLaterBodySchema,
+  IWillDoItLaterResponseSchema,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -92,6 +94,26 @@ export const individualsContract = c.router(
         403: ForbiddenError,
       },
     },
+    iWillDoItLater: {
+      summary: "I'll do it later - Create a task for later completion",
+      method: 'POST',
+      path: '/:id/defer',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      body: IWillDoItLaterBodySchema,
+      responses: {
+        201: IWillDoItLaterResponseSchema,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'individuals',

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

@@ -13,7 +13,7 @@ import {
   TradeLineItemResponse,
   TradeLineItemUpdate,
   TradeLineItemSignStatusUpdate,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/issuers/bonus-tiers/index.ts

@@ -10,6 +10,8 @@ import {
   EstimateBonusTierCalculationZod,
   IBonusTierList,
   PostBonusTierZod,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -32,6 +34,22 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary: 'Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
     postBonusTier: {
       summary: 'Create a new bonus tier',
       method: 'POST',

package/contracts/issuers/disbursements/index.ts

@@ -17,9 +17,13 @@ import {
   DisbursementMissingConfigZod,
   DisbursementsIncludeQuery,
   DisbursementsMissingConfigQuery,
+  DisbursementPreviewZod,
   DisbursementSummaryZod,
   DisbursementZod,
+  GetDisbursementPreviewQueryZod,
+  EligibleOfferingsFiltersZod,
   IPaginatedDisbursement,
+  IPaginatedEligibleOffering,
   PostDisbursementBalanceZod,
   PostDisbursementSummaryZod,
   PostDisbursementZod,
@@ -146,6 +150,38 @@ export const disbursementsContract = c.router(
         500: InternalError,
       },
     },
+    getDisbursementPreview: {
+      summary: 'Get disbursement preview data for Step 2',
+      method: 'GET',
+      path: '/preview',
+      metadata: {
+        auth: true,
+      },
+      query: GetDisbursementPreviewQueryZod,
+      responses: {
+        200: DisbursementPreviewZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getEligibleOfferings: {
+      summary: 'Get eligible offerings for disbursement',
+      method: 'GET',
+      path: '/eligible-offerings',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(EligibleOfferingsFiltersZod),
+      responses: {
+        200: IPaginatedEligibleOffering,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'disbursements',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmore/api-contracts",
-  "version": "0.0.0-dev.2047f71",
+  "version": "0.0.0-dev.3af7603",
   "description": "Type-safe API contracts for Dalmore Client Portal",
   "main": "./contracts/index.ts",
   "types": "./contracts/index.ts",