@dalmore/api-contracts 0.0.0-dev.2dc8e92 → 0.0.0-dev.4bb6b7a

package/common/types/webhook.types.ts

@@ -1,6 +1,148 @@
 import { z } from 'zod';
 import { PersonaStatus } from './common.types';
 
+/**
+ * Hook0 Webhook Provider Types
+ *
+ * Types for interacting with Hook0's webhooks-as-a-service API.
+ * @see https://documentation.hook0.com/api - API Reference
+ */
+
+/**
+ * Hook0 API error response format.
+ * @see https://documentation.hook0.com/api
+ */
+export const Hook0ApiErrorSchema = z.object({
+  type: z.string(),
+  status: z.number(),
+  title: z.string(),
+  detail: z.string(),
+  validation: z.unknown().nullable(),
+  id: z.string(),
+});
+export type Hook0ApiError = z.infer<typeof Hook0ApiErrorSchema>;
+
+/**
+ * Error returned from Hook0 provider operations.
+ * Wraps Hook0 API errors with additional context.
+ */
+export const Hook0ProviderErrorSchema = z.object({
+  message: z.string(),
+  statusCode: z.number().optional(),
+  code: z.string().optional(),
+  apiError: Hook0ApiErrorSchema.optional(),
+});
+export type Hook0ProviderError = z.infer<typeof Hook0ProviderErrorSchema>;
+
+/**
+ * Hook0 subscription target configuration.
+ * Defines where and how webhooks are delivered.
+ * @see https://documentation.hook0.com/reference/subscriptionscreate
+ */
+export const Hook0SubscriptionTargetSchema = z.object({
+  type: z.literal('http'),
+  method: z.string(),
+  url: z.string().url(),
+  headers: z.record(z.string()).optional(),
+});
+export type Hook0SubscriptionTarget = z.infer<
+  typeof Hook0SubscriptionTargetSchema
+>;
+
+/**
+ * Hook0 subscription response from create/get operations.
+ * @see https://documentation.hook0.com/reference/subscriptionscreate
+ * @see https://documentation.hook0.com/reference/subscriptionsget
+ */
+export const Hook0SubscriptionResponseSchema = z.object({
+  subscription_id: z.string().uuid(),
+  application_id: z.string().uuid(),
+  created_at: z.string().datetime().optional(),
+  dedicated_workers: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  event_types: z.array(z.string()).optional(),
+  is_enabled: z.boolean().optional(),
+  label_key: z.string().optional(),
+  label_value: z.string().optional(),
+  labels: z.record(z.string()).optional(),
+  metadata: z.record(z.string()).optional(),
+  secret: z.string(),
+  target: Hook0SubscriptionTargetSchema.optional(),
+});
+export type Hook0SubscriptionResponse = z.infer<
+  typeof Hook0SubscriptionResponseSchema
+>;
+
+/**
+ * Simplified subscription result returned to callers.
+ */
+export const WebhookSubscriptionSchema = z.object({
+  subscriptionId: z.string(),
+  secret: z.string(),
+});
+export type WebhookSubscription = z.infer<typeof WebhookSubscriptionSchema>;
+
+/**
+ * Hook0 event type response from create operation.
+ * @see https://documentation.hook0.com/reference/eventtypescreate
+ */
+export const Hook0EventTypeResponseSchema = z.object({
+  service_name: z.string(),
+  resource_type_name: z.string(),
+  verb_name: z.string(),
+  event_type_name: z.string(),
+});
+export type Hook0EventTypeResponse = z.infer<
+  typeof Hook0EventTypeResponseSchema
+>;
+
+/**
+ * Hook0 event type list item.
+ * @see https://documentation.hook0.com/reference/eventtypeslist
+ */
+export const Hook0EventTypeSchema = z.object({
+  name: z.string(),
+  service: z.string().optional(),
+  resource_type: z.string().optional(),
+  verb: z.string().optional(),
+});
+export type Hook0EventType = z.infer<typeof Hook0EventTypeSchema>;
+
+/**
+ * Hook0 event ingestion response.
+ * @see https://documentation.hook0.com/api/#tag/events-ingestion/POST/api/v1/event/
+ */
+export const Hook0EventResponseSchema = z.object({
+  event_id: z.string().uuid().optional(),
+  received_at: z.string().datetime().optional(),
+});
+export type Hook0EventResponse = z.infer<typeof Hook0EventResponseSchema>;
+
+/**
+ * Simplified event response returned to callers.
+ */
+export const WebhookEventResponseSchema = z.object({
+  eventId: z.string(),
+  receivedAt: z.string(),
+});
+export type WebhookEventResponse = z.infer<typeof WebhookEventResponseSchema>;
+
+/**
+ * Payload sent when ingesting events to Hook0.
+ * Contains activity data to be delivered to webhook subscribers.
+ */
+export const WebhookEventPayloadSchema = z.object({
+  activityId: z.string(),
+  activityType: z.string(),
+  accountId: z.string(),
+  targetId: z.string().nullable(),
+  targetTable: z.string().nullable(),
+  message: z.string(),
+  metadata: z.record(z.unknown()),
+  occurredAt: z.string(),
+});
+export type WebhookEventPayload = z.infer<typeof WebhookEventPayloadSchema>;
+
 export const WebhookReceived = z.object({
   received: z.boolean(),
 });

package/contracts/{investors → clients}/cart/index.ts

@@ -1,36 +1,41 @@
 import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
 import {
   UnauthorizedError,
   ForbiddenError,
   NotFoundError,
-  InternalError,
   BadRequestError,
+  InternalError,
   TradeZod,
+  userIdSchema,
   tradeIdSchema,
 } from '../../../common/types';
 import {
-  PlaceTradeResponse,
-  PlaceTradeBody,
   PatchCartBody,
+  ClientPlacetradeBody,
+  PlaceTradeResponse,
 } from '../../../common/types/cart.types';
-import { z } from 'zod';
 
 const c = initContract();
 
 export const cartContract = c.router(
   {
     getTradeCart: {
-      summary: 'GET Cart (Trade.status = CART)',
+      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: {
@@ -40,7 +45,7 @@ export const cartContract = c.router(
       metadata: {
         auth: true,
       },
-      body: PlaceTradeBody,
+      body: ClientPlacetradeBody,
       responses: {
         200: PlaceTradeResponse,
         400: BadRequestError,

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/{investors → clients}/issuer-payment-methods/index.ts

@@ -6,6 +6,7 @@ import {
   UnauthorizedError,
   GetIssuerPaymentMethodZod,
   IPaginatedIssuerPaymentMethod,
+  IssuerPaymentMethodsIncludeQuery,
   PaginationOptionsZod,
 } from '../../../common/types';
 
@@ -14,13 +15,15 @@ const c = initContract();
 export const issuerPaymentMethodsContract = c.router(
   {
     getIssuerPaymentMethods: {
-      summary: 'get payment methods',
+      summary: 'Get issuer payment methods',
       method: 'GET',
       path: '',
       metadata: {
         auth: true,
       },
-      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod),
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(
+        IssuerPaymentMethodsIncludeQuery,
+      ),
       responses: {
         200: IPaginatedIssuerPaymentMethod,
         401: UnauthorizedError,

package/contracts/{compliance → clients}/payment-methods/index.ts

@@ -1,16 +1,19 @@
 import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
 import {
-  BadRequestError,
+  UnauthorizedError,
   ForbiddenError,
-  InternalError,
   NotFoundError,
-  UnauthorizedError,
+  userIdSchema,
+  BadRequestError,
+  InternalError,
 } from '../../../common/types';
 import {
-  CompliancePostPaymentMethod,
-  PaymentMethodFilterQuery,
-  PaymentMethodResponse,
   PaymentMethodResponseArray,
+  PaymentMethodResponse,
+  PostPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
 } from '../../../common/types/payment-methods.types';
 
 const c = initContract();
@@ -18,13 +21,15 @@ const c = initContract();
 export const paymentMethodsContract = c.router(
   {
     getPaymentMethods: {
-      summary: 'get payment methods',
+      summary: 'Get payment methods for a user',
       method: 'GET',
-      path: '/',
+      path: '',
       metadata: {
         auth: true,
       },
-      query: PaymentMethodFilterQuery,
+      query: z.object({
+        userId: userIdSchema,
+      }),
       responses: {
         200: PaymentMethodResponseArray,
         401: UnauthorizedError,
@@ -34,13 +39,16 @@ export const paymentMethodsContract = c.router(
       },
     },
     createPaymentMethod: {
-      summary: 'POST payment methods',
+      summary: 'Create payment method for a user',
       method: 'POST',
-      path: '/',
+      path: '',
       metadata: {
         auth: true,
       },
-      body: CompliancePostPaymentMethod,
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostPaymentMethod,
       responses: {
         201: PaymentMethodResponse,
         400: BadRequestError,
@@ -50,6 +58,26 @@ export const paymentMethodsContract = c.router(
         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/{investors → clients}/trade-line-items/index.ts

@@ -1,42 +1,25 @@
 import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
 import {
   BadRequestError,
   ForbiddenError,
   InternalError,
   NotFoundError,
   UnauthorizedError,
+  userIdSchema,
 } from '../../../common/types';
 import {
-  TradeLineItemParams,
   PostTradeLineItem,
+  TradeLineItemParams,
   TradeLineItemQuery,
   TradeLineItemResponse,
   TradeLineItemUpdate,
-  TradeLineItemSignStatusUpdate,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 
 export const tradeLineItemsContract = c.router(
   {
-    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,
-      },
-    },
     postTradeLineItem: {
       summary: 'Create Trade Line Item',
       method: 'POST',
@@ -45,7 +28,11 @@ export const tradeLineItemsContract = c.router(
         auth: true,
       },
       body: PostTradeLineItem,
-      query: TradeLineItemQuery,
+      query: TradeLineItemQuery.merge(
+        z.object({
+          userId: userIdSchema,
+        }),
+      ),
       responses: {
         201: TradeLineItemResponse,
         401: UnauthorizedError,
@@ -54,18 +41,22 @@ export const tradeLineItemsContract = c.router(
         500: InternalError,
       },
     },
-    updateLineItemSignatureStatus: {
-      summary: 'Update Trade Signature Status',
+    updateTradeLineItem: {
+      summary: 'Update Trade Line Item - Can delete if you pass quantity = 0',
       method: 'PATCH',
-      path: '/:id/sign',
-      metadata: { auth: true },
-      body: TradeLineItemSignStatusUpdate,
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: TradeLineItemParams,
+      body: TradeLineItemUpdate,
       responses: {
         200: TradeLineItemResponse,
         401: UnauthorizedError,
         403: ForbiddenError,
-        400: BadRequestError,
+        404: NotFoundError,
         500: InternalError,
+        400: BadRequestError,
       },
     },
   },

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/{investors → clients}/transactions/index.ts

@@ -6,13 +6,13 @@ import {
   UnauthorizedError,
 } from '../../../common/types';
 import {
-  InvestorPostTransactionZod,
+  ClientPostTransactionZod,
   TransactionZod,
 } from '../../../common/types/transaction.types';
 
 const c = initContract();
 
-export const investorsTransactionsContract = c.router(
+export const clientsTransactionsContract = c.router(
   {
     postTransaction: {
       summary: 'Create a transaction',
@@ -21,7 +21,7 @@ export const investorsTransactionsContract = c.router(
       metadata: {
         auth: true,
       },
-      body: InvestorPostTransactionZod,
+      body: ClientPostTransactionZod,
       responses: {
         201: TransactionZod,
         400: BadRequestError,

package/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @dalmore/api-contracts
+ * Main entry point - re-exports clients contract and types
+ */
+
+// Re-export clients contract
+export * from './contracts/clients/index.js';
+
+// Re-export all common types
+export * from './common/types/index.js';

package/package.json

@@ -1,48 +1,42 @@
 {
   "name": "@dalmore/api-contracts",
-  "version": "0.0.0-dev.2dc8e92",
+  "version": "0.0.0-dev.4bb6b7a",
   "description": "Type-safe API contracts for Dalmore Client Portal",
-  "main": "./contracts/index.ts",
-  "types": "./contracts/index.ts",
+  "type": "module",
+  "main": "./index.ts",
+  "types": "./index.ts",
   "exports": {
     ".": {
-      "types": "./contracts/index.ts",
-      "default": "./contracts/index.ts"
-    },
-    "./compliance": {
-      "types": "./contracts/compliance/index.ts",
-      "default": "./contracts/compliance/index.ts"
-    },
-    "./investors": {
-      "types": "./contracts/investors/index.ts",
-      "default": "./contracts/investors/index.ts"
-    },
-    "./issuers": {
-      "types": "./contracts/issuers/index.ts",
-      "default": "./contracts/issuers/index.ts"
+      "types": "./index.ts",
+      "import": "./index.ts",
+      "default": "./index.ts"
     },
     "./clients": {
       "types": "./contracts/clients/index.ts",
+      "import": "./contracts/clients/index.ts",
       "default": "./contracts/clients/index.ts"
     },
-    "./secondaries": {
-      "types": "./contracts/secondaries/index.ts",
-      "default": "./contracts/secondaries/index.ts"
-    },
-    "./compliance-apikey": {
-      "types": "./contracts/compliance-apikey/index.ts",
-      "default": "./contracts/compliance-apikey/index.ts"
-    },
     "./types": {
       "types": "./common/types/index.ts",
+      "import": "./common/types/index.ts",
       "default": "./common/types/index.ts"
-    },
-    "./types/*": {
-      "types": "./common/types/*.ts",
-      "default": "./common/types/*.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./index.ts"
+      ],
+      "clients": [
+        "./contracts/clients/index.ts"
+      ],
+      "types": [
+        "./common/types/index.ts"
+      ]
     }
   },
   "files": [
+    "index.ts",
     "contracts",
     "common"
   ],
@@ -68,9 +62,6 @@
     "typeid-js": "^1.2.0",
     "zod": "^3.24.4"
   },
-  "devDependencies": {
-    "typescript": "^5.8.3"
-  },
   "engines": {
     "node": ">=24.0.0 <25.0.0"
   }