@dalmore/api-contracts 0.0.0-dev.d8ef117 → 0.0.0-dev.dc7fdf8

package/contracts/compliance/account-managers/index.ts

@@ -1,142 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  PreconditionFailedError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  AccountManagerDeleteQuery,
-  AccountManagerDeleteResponse,
-  accountManagerIdSchema,
-  AccountManagersIncludeQuery,
-  IAccountManagerZod,
-  IPaginatedAccountManager,
-  PatchAccountManagerZod,
-  PostAccountManagerZod,
-  SetDefaultAccountManagerForAllAccountsResponse,
-} from '../../../common/types/account-manager.types';
-
-const c = initContract();
-
-export const accountManagersContract = c.router(
-  {
-    getAccountManagers: {
-      summary: 'Get account managers',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AccountManagersIncludeQuery),
-      responses: {
-        200: IPaginatedAccountManager,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAccountManager: {
-      summary: 'Get account manager by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(AccountManagersIncludeQuery),
-      pathParams: z.object({
-        id: accountManagerIdSchema,
-      }),
-      responses: {
-        200: IAccountManagerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    setDefaultAccountManagerForAllAccounts: {
-      summary: '[ADMIN] Set default account manager for all accounts',
-      method: 'PATCH',
-      path: '/set-default-for-all-accounts',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({}),
-      responses: {
-        200: SetDefaultAccountManagerForAllAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    patchAccountManager: {
-      summary: 'Update account manager by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountManagerIdSchema,
-      }),
-      body: PatchAccountManagerZod,
-      responses: {
-        201: IAccountManagerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postAccountManager: {
-      summary: 'Create account manager',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostAccountManagerZod,
-      responses: {
-        201: IAccountManagerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    deleteAccountManager: {
-      summary: 'Delete account manager by id',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountManagerIdSchema,
-      }),
-      query: AccountManagerDeleteQuery,
-      responses: {
-        201: AccountManagerDeleteResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        412: PreconditionFailedError,
-        500: InternalError,
-      },
-    },
-  },
-
-  {
-    pathPrefix: 'account-managers',
-  },
-);

package/contracts/compliance/accounts/index.ts

@@ -1,187 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedAccount,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  AccountFiltersZod,
-  AccountsIncludeQuery,
-  AccountZod,
-  InternalError,
-  accountIdSchema,
-  CreateAccountZod,
-  AccountsSummaryFilterZod,
-  IPaginatedAccountsSummaryResponse,
-  UpdateAccountIssuersStatusZod,
-  UpdateAccountStatusReponse,
-  CompliancePatchAccountZod,
-  AccountSortZod,
-  BadRequestError,
-} from '../../../common/types';
-import { z } from 'zod';
-import { AccountDetailSummaryZod } from '../../../common/types/account-detail.types';
-import {
-  accountManagerIdSchema,
-  SetDefaultAccountManagerForAllAccountsResponse,
-} from '../../../common/types/account-manager.types';
-
-const c = initContract();
-
-export const accountsContract = c.router(
-  {
-    getPaginatedAccountsSummary: {
-      summary: 'Get accounts summary with pagination',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AccountsSummaryFilterZod).merge(
-        AccountSortZod,
-      ),
-      responses: {
-        200: IPaginatedAccountsSummaryResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    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,
-        500: InternalError,
-      },
-    },
-    // Admin
-    getAccountsAdmin: {
-      summary: '[ADMIN] Get accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(AccountFiltersZod).merge(
-          AccountsIncludeQuery,
-        ),
-      responses: {
-        200: IPaginatedAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    updateAccountAdmin: {
-      summary: '[ADMIN] Update account by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      body: CompliancePatchAccountZod,
-      responses: {
-        200: AccountZod,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    updateAccountStatusAdmin: {
-      summary: '[ADMIN] Update account status by id',
-      method: 'PATCH',
-      path: '/:id/status',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      body: UpdateAccountIssuersStatusZod,
-      responses: {
-        200: UpdateAccountStatusReponse,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    createAccount: {
-      summary: '[ADMIN] Create an account',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: CreateAccountZod,
-      responses: {
-        201: AccountZod,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAccountDetailSummary: {
-      summary: 'Get account detail summary',
-      method: 'GET',
-      path: '/:id/detail-summary',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      responses: {
-        200: AccountDetailSummaryZod,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    setAccountManagerForAccount: {
-      summary: 'Set account manager for account',
-      method: 'PATCH',
-      path: '/:id/set-account-manager-for-account',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      body: z.object({
-        accountManagerId: accountManagerIdSchema,
-      }),
-      responses: {
-        200: SetDefaultAccountManagerForAllAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'accounts',
-  },
-);

package/contracts/compliance/activities/index.ts

@@ -1,55 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ActivitiesFilters,
-  activityIdSchema,
-  ActivityZod,
-  IPaginatedActivity,
-} from '../../../../src/common/types/activity.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const activitiesContract = c.router(
-  {
-    getActivities: {
-      summary: 'Get activities',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ActivitiesFilters),
-      responses: {
-        200: IPaginatedActivity,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getActivity: {
-      summary: 'Get activity by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: activityIdSchema,
-      }),
-      responses: {
-        200: ActivityZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'activities',
-  },
-);

package/contracts/compliance/aic/index.ts

@@ -1,60 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  AicIncludeQuery,
-  AicZod,
-  BadRequestError,
-  ComplianceAicQueryZod,
-  ComplianceAttachAicFileBodyZod,
-  ForbiddenError,
-  individualIdSchema,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-export const aicContract = c.router(
-  {
-    getAic: {
-      summary: 'Get AIC',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        individualId: individualIdSchema,
-      }),
-      query: AicIncludeQuery.merge(ComplianceAicQueryZod),
-      responses: {
-        200: AicZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    attachAicFile: {
-      summary: 'Attach AIC File',
-      method: 'PUT',
-      path: '/file',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        individualId: individualIdSchema,
-      }),
-      body: ComplianceAttachAicFileBodyZod,
-      responses: {
-        200: AicZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'individual/:individualId/aic',
-  },
-);

package/contracts/compliance/api-keys/index.ts

@@ -1,91 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  UnauthorizedError,
-  InternalError,
-  PostApiKeyBody,
-  ApiKeyZod,
-  IPaginatedApiKeys,
-  PaginationOptionsZod,
-  BadRequestError,
-  apiKeyIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const apiKeysContract = c.router(
-  {
-    postApiKey: {
-      summary: '[ADMIN] Create API Key',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: PostApiKeyBody,
-      responses: {
-        201: ApiKeyZod,
-        400: BadRequestError,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getApiKeys: {
-      summary: '[ADMIN] Get API Keys',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPaginatedApiKeys,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getApiKey: {
-      summary: '[ADMIN] Get API Key',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: apiKeyIdSchema,
-      }),
-      responses: {
-        200: ApiKeyZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    deactivateApiKey: {
-      summary: 'Deactivate API Key by id',
-      method: 'PATCH',
-      path: '/:id/deactivate',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: apiKeyIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        202: ApiKeyZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'api-keys',
-  },
-);

package/contracts/compliance/assets/index.ts

@@ -1,122 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ConflictError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  AssetFiltersZod,
-  assetIdSchema,
-  AssetsIncludeQuery,
-  AssetSummaryFiltersZod,
-  IAsset,
-  IPaginatedAsset,
-  CompliancePostAsset,
-  CompliancePutAsset,
-  AssetSortZod,
-} from '../../../common/types/asset.types';
-import { z } from 'zod';
-
-const c = initContract();
-export const assetsContract = c.router(
-  {
-    getAssetsSummary: {
-      summary: 'Get assets summary',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AssetSummaryFiltersZod),
-      responses: {
-        200: IPaginatedAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAssets: {
-      summary: 'Get assets',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AssetsIncludeQuery)
-        .merge(AssetFiltersZod)
-        .merge(AssetSortZod),
-      responses: {
-        200: IPaginatedAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAsset: {
-      summary: 'Get asset by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(AssetsIncludeQuery),
-      pathParams: z.object({
-        id: assetIdSchema,
-      }),
-      responses: {
-        200: IAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postAssets: {
-      summary: 'Create an asset',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostAsset,
-      responses: {
-        201: IAsset,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        500: InternalError,
-      },
-    },
-    updateAsset: {
-      summary: 'Update asset',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: assetIdSchema,
-      }),
-      body: CompliancePutAsset,
-      responses: {
-        201: IAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-
-  {
-    pathPrefix: 'assets',
-  },
-);