@dalmore/api-contracts 0.0.0-dev.10793c4 → 0.0.0-dev.15e31bc

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

@@ -0,0 +1,251 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  CreateChannelInputSchema,
+  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 notificationChannelsContract = c.router(
+  {
+    getChannels: {
+      summary: 'Get notification channels',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotificationChannelFilters).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',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CreateChannelInputSchema,
+      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',
+      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',
+  },
+);

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/trades/index.ts

@@ -23,6 +23,7 @@ import {
   ExportTradesQuery,
   CancelTradeResponse,
   ComplianceCancelTradeZod,
+  GetTradeSnapshotEventsResponse,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -48,6 +49,24 @@ export const tradesContract = c.router(
         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',

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/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/account-settings/index.ts

@@ -0,0 +1,36 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  AccountSettingsIncludeQuery,
+  IAccountSettingZod,
+} from '../../../common/types/account-setting.types';
+import {
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerAccountSettingsContract = c.router(
+  {
+    getAccountSettings: {
+      summary: 'Get account settings for current account',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AccountSettingsIncludeQuery),
+      responses: {
+        200: IAccountSettingZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-settings',
+  },
+);

package/contracts/issuers/auth/index.ts

@@ -13,6 +13,7 @@ import {
   SelectAccountIssuersResponse,
   SwitchAccountIssuersBody,
   UnauthorizedError,
+  EmailSchema,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -78,7 +79,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'forgot-password',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
       }),
       responses: {
         200: z.string(),
@@ -92,7 +93,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'reset-password/verify',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
         code: z.string(),
       }),
       responses: {
@@ -108,7 +109,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'reset-password',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
         code: z.string(),
         password: z.string().min(6),
       }),

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

@@ -117,23 +117,6 @@ export const disbursementsContract = c.router(
       },
     },
 
-    getDisbursement: {
-      summary: 'Get disbursement by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(DisbursementsIncludeQuery),
-      pathParams: z.object({ id: disbursementIdSchema }),
-      responses: {
-        200: DisbursementZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
     reviewDisbursements: {
       summary: 'Review Disbursements',
       method: 'POST',
@@ -182,6 +165,23 @@ export const disbursementsContract = c.router(
         500: InternalError,
       },
     },
+    getDisbursement: {
+      summary: 'Get disbursement by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(DisbursementsIncludeQuery),
+      pathParams: z.object({ id: disbursementIdSchema }),
+      responses: {
+        200: DisbursementZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
   },
   {
     pathPrefix: 'disbursements',

package/contracts/issuers/index.ts

@@ -2,7 +2,9 @@ import { initContract } from '@ts-rest/core';
 import { accountsContract } from './accounts';
 import { accountContactsContract } from './account-contacts';
 import { accountIntegrationsContract } from './account-integrations';
+import { issuerAccountSettingsContract } from './account-settings';
 import { assetsContract } from './assets';
+import { issuerNotificationChannelsContract } from './notification-channels';
 import { healthContract } from './health';
 import { issuerContract } from './issuer';
 import { authContract } from './auth';
@@ -57,6 +59,7 @@ export const issuersContract = c.router(
     accounts: accountsContract,
     accountContacts: accountContactsContract,
     accountIntegrations: accountIntegrationsContract,
+    accountSettings: issuerAccountSettingsContract,
     activities: activitiesContract,
     aic: aicContract,
     assets: assetsContract,
@@ -86,6 +89,7 @@ export const issuersContract = c.router(
     kycs: kycsContract,
     loginHistories: loginHistoriesContract,
     notes: issuerNotesContract,
+    notificationChannels: issuerNotificationChannelsContract,
     offerings: issuersOfferingsContract,
     pages: pagesContract,
     paymentMethods: paymentMethodsContract,