@dalmore/api-contracts 1.0.0

package/common/types/activity.types.ts

@@ -0,0 +1,236 @@
+import { z } from 'zod';
+import {
+  BaseAction,
+  BaseStatus,
+  IPaginationMeta,
+  PortalType,
+  TargetTableConfig,
+  TargetTableEnum,
+} from './common.types';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+
+/**
+ * WARNING!!!
+ * ANY CHANGES TO:
+ * - ActivityTypeCategory
+ * - ActivityTypeResource
+ * - ActivityTypeAction
+ * Will require a migration to add the new combinations to the database. See activity-type.entity.ts
+ * Also, previous migrations will have to be updated to prevent the new combination from being seeded before the new migration introduces it.
+ * see: SeedActivityActionTable1733789494520
+ * This is required only for backwards compatibility when developing locally and e2e tests.
+ */
+export enum ActivityTypeCategory {
+  CLIENT = PortalType.CLIENT,
+  INVESTOR = PortalType.INVESTOR,
+  COMPLIANCE = PortalType.COMPLIANCE,
+  ISSUER = PortalType.ISSUER,
+}
+
+export const CategoryMap: { [key: string]: ActivityTypeCategory } = {
+  compliance: ActivityTypeCategory.COMPLIANCE,
+  issuers: ActivityTypeCategory.ISSUER,
+  clients: ActivityTypeCategory.CLIENT,
+  investors: ActivityTypeCategory.INVESTOR,
+};
+
+export enum ActivityTypeResource {
+  KYCS = 'KYCS',
+  KYBS = 'KYBS',
+  INDIVIDUALS = 'INDIVIDUALS',
+  LEGAL_ENTITIES = 'LEGAL_ENTITIES',
+  INVESTOR_ACCOUNTS = 'INVESTOR_ACCOUNTS',
+  TRADES = 'TRADES',
+  OFFERINGS = 'OFFERINGS',
+  ISSUERS = 'ISSUERS',
+  COVERED_PERSONS = 'COVERED_PERSONS',
+  PAYMENT_METHODS = 'PAYMENT_METHODS',
+  NOTES = 'NOTES',
+  USERS = 'USERS',
+  ACCOUNTS = 'ACCOUNTS',
+  FILES = 'FILES',
+  PAGES = 'PAGES',
+  AMLS = 'AMLS',
+  DISBURSEMENTS = 'DISBURSEMENTS',
+  DISBURSEMENT_REVIEWS = 'DISBURSEMENT_REVIEWS',
+  TRADE_LINE_ITEMS = 'TRADE_LINE_ITEMS',
+  TRANSACTIONS = 'TRANSACTIONS',
+  AICS = 'AICS',
+  SITES = 'SITES',
+  THEMES = 'THEMES',
+  THEME_SETTINGS = 'THEME_SETTINGS',
+}
+
+export const ResourceMap: { [key: string]: ActivityTypeResource } = {
+  trades: ActivityTypeResource.TRADES,
+  'trade-line-items': ActivityTypeResource.TRADE_LINE_ITEMS,
+  transactions: ActivityTypeResource.TRANSACTIONS,
+  users: ActivityTypeResource.USERS,
+  offerings: ActivityTypeResource.OFFERINGS,
+  'investor-accounts': ActivityTypeResource.INVESTOR_ACCOUNTS,
+  individuals: ActivityTypeResource.INDIVIDUALS,
+  'payment-methods': ActivityTypeResource.PAYMENT_METHODS,
+  notes: ActivityTypeResource.NOTES,
+  issuers: ActivityTypeResource.ISSUERS,
+  'covered-persons': ActivityTypeResource.COVERED_PERSONS,
+  kyc: ActivityTypeResource.KYCS,
+  aml: ActivityTypeResource.AMLS,
+  aic: ActivityTypeResource.AICS,
+  kyb: ActivityTypeResource.KYBS,
+  'legal-entities': ActivityTypeResource.LEGAL_ENTITIES,
+  accounts: ActivityTypeResource.ACCOUNTS,
+  files: ActivityTypeResource.FILES,
+  'files-public': ActivityTypeResource.FILES,
+  pages: ActivityTypeResource.PAGES,
+  disbursements: ActivityTypeResource.DISBURSEMENTS,
+  'disbursement-reviews': ActivityTypeResource.DISBURSEMENT_REVIEWS,
+  sites: ActivityTypeResource.SITES,
+  themes: ActivityTypeResource.THEMES,
+  'theme-settings': ActivityTypeResource.THEME_SETTINGS,
+};
+
+/**
+ * WARNING!!!
+ * ANY CHANGES TO:
+ * - ActivityTypeAction
+ * Will require a migration to add the new combinations to the database. See activity-type.entity.ts
+ * Also, previous migrations will have to be updated to prevent the new combination from being seeded before the new migration introduces it.
+ * see:
+ * SeedActivityActionTable1733789494520
+ * SeedActivityResourceTableFiles1735884938590
+ * SeedAmlPagesInActivityTypes1740995815856
+ * SeedActivityResourceTypeDisbursement1742689286845
+ * SeedActivityResourceTradeLineItem1746449328700
+ * SeedActivityReset2faAction1746791323564
+ * SeedActivityResourceUserCombinations1747289941817
+ * AddedResubmitActivityType1747999619404
+ * AddedDeclinedAndSignedActivityAction1748011929459
+ * SeedActivityResourceTypeDisbursementReview1753945998383
+ * SeedActivityResourceTypeTransaction1754457409040
+ * AddedAicTargetTable1756265520122
+ * AddedReporcessActivityTypeAction1758023244400
+ * AddedActivityActionSave1761715000038
+ * AddedAcceptedActivityAction1762848949484
+ */
+export enum ActivityTypeAction {
+  CREATE = BaseAction.CREATE,
+  UPDATE = BaseAction.UPDATE,
+  DELETE = BaseAction.DELETE,
+  IMPORT = BaseAction.IMPORT,
+  APPROVED = BaseStatus.APPROVED,
+  REJECTED = BaseStatus.REJECTED,
+  SUBMITTED = BaseStatus.SUBMITTED,
+  DECLINED = BaseStatus.DECLINED,
+  SIGNED = BaseStatus.SIGNED,
+  COMPLETED = BaseStatus.COMPLETED,
+  RE_SIGN = BaseStatus.RE_SIGN,
+  RESUBMIT = BaseStatus.RESUBMIT,
+  RESET_2FA = BaseStatus.RESET_2FA,
+  LOGIN = BaseStatus.LOGIN,
+  RESET_PASSWORD = BaseStatus.RESET_PASSWORD,
+  TWO_FACTOR_LOGIN = BaseStatus.TWO_FACTOR_LOGIN,
+  FORGOT_PASSWORD = BaseStatus.FORGOT_PASSWORD,
+  RE_PROCESS = BaseStatus.RE_PROCESS,
+  SAVE = BaseStatus.SAVE,
+  ACCEPTED = BaseStatus.ACCEPTED,
+}
+
+export const MethodMap: { [key: string]: ActivityTypeAction } = {
+  POST: ActivityTypeAction.CREATE,
+  PUT: ActivityTypeAction.UPDATE,
+  PATCH: ActivityTypeAction.UPDATE,
+  DELETE: ActivityTypeAction.DELETE,
+};
+
+export const activityIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'activity';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid activity ID format. Must be a valid TypeID with "activity" prefix. Example: activity_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export const UserLoginForActivityZod = z.object({
+  id: z.string().openapi({
+    example: 'user_login_01jepymte1feb8a4j46gy6850k',
+  }),
+  firstName: z.string().openapi({
+    example: 'Daniel',
+  }),
+  lastName: z.string().openapi({
+    example: 'Ice',
+  }),
+  email: z.string().email().openapi({
+    example: 'dice@dalmoregroup.com',
+  }),
+  __entity: z.string().optional(),
+});
+
+const UserForActivityZod = z.object({
+  id: z.string(),
+  roleId: z.string().nullable(),
+  accountId: z.string().nullable(),
+  userLogin: UserLoginForActivityZod,
+  __entity: z.string().optional(),
+});
+
+const ActivityTypeZod = IBaseEntity.extend({
+  category: z.nativeEnum(ActivityTypeCategory),
+  resource: z.enum(TargetTableEnum),
+  action: z.nativeEnum(ActivityTypeAction),
+  __entity: z.string().optional(),
+});
+
+export const ActivityZod = IBaseEntity.extend({
+  id: activityIdSchema,
+  message: z.string(),
+  targetTable: z.enum(TargetTableEnum),
+  targetId: z.string(),
+  userId: z.string().nullable(),
+  activityTypeId: z.string(),
+  accountId: z.string().nullable(),
+  user: UserForActivityZod,
+  activityType: ActivityTypeZod,
+  targetObject: z.string().nullable().optional(),
+  __entity: z.string().optional(),
+});
+export type ActivityZod = z.infer<typeof ActivityZod>;
+
+export const IPaginatedActivity = z.object({
+  items: z.array(ActivityZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedActivity = z.infer<typeof IPaginatedActivity>;
+
+export const ActivitiesFilters = z.object({
+  targetTable: z.enum(TargetTableEnum).optional(),
+  targetId: z
+    .string()
+    .optional()
+    .refine(
+      (value) => {
+        try {
+          if (!value) return true;
+          const tid = TypeID.fromString(value);
+          return Object.values(TargetTableConfig).some(
+            (config) => config.idPrefix === tid.getType(),
+          );
+        } catch {
+          return false;
+        }
+      },
+      {
+        message: `Invalid target ID format. Must match the corresponding table's ID prefix. Valid prefix: ${TargetTableEnum.toString().toLowerCase()}. Example: disbursement_01j6aqmtfyfwy9spjdcnh7yqk7`,
+      },
+    ),
+  search: z.string().max(50).optional(),
+});
+export type ActivitiesFilters = z.infer<typeof ActivitiesFilters>;

package/common/types/address.types.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { CountryStateSchema, RequiredCountryStateSchema } from './states.types';
+import { CountryZipSchema, RequiredCountryZipSchema } from './zip.type';
+
+export const AddressSchema = z
+  .object({
+    address: z
+      .string()
+      .min(2, 'address is less than 2 characters')
+      .nullable()
+      .optional(),
+    address2: z.string().nullable().optional(),
+    city: z
+      .string()
+      .min(2, 'city is less than 2 characters')
+      .max(30, 'city is more than 30 characters')
+      .nullable()
+      .optional(),
+  })
+  .and(CountryStateSchema)
+  .and(CountryZipSchema);
+
+export type AddressType = z.infer<typeof AddressSchema>;
+
+export const RequiredAddressSchema = z
+  .object({
+    address: z.string().min(2, 'Address must be at least 2 characters'),
+    address2: z
+      .string()
+      .max(100, 'Address2 cannot exceed 100 characters')
+      .nullable()
+      .optional(),
+    city: z
+      .string()
+      .min(2, 'City must be at least 2 characters')
+      .max(50, 'City cannot exceed 50 characters'),
+  })
+  .and(RequiredCountryStateSchema)
+  .and(RequiredCountryZipSchema);
+
+export type RequiredAddressType = z.infer<typeof RequiredAddressSchema>;

package/common/types/aic.types.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { fileIdSchema } from './file.types';
+import {
+  AccountType,
+  AicAccreditationType,
+  ComplianceReview,
+  FilingStatus,
+  SystemReviewStatus,
+} from './common.types';
+import { IIndividualZod, individualIdSchema } from './individuals.types';
+import { userIdSchema, UserZod } from './user.types';
+import { accountIdSchema } from './account.types';
+
+extendZodWithOpenApi(z);
+
+export const aicIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'aic';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid aic ID format. Must be a valid TypeID with "aic" prefix. Example: aic_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export enum ProfessionalType {
+  SECURITIES_LICENSES = 'SECURITIES_LICENSES',
+  DIRECTORS = 'DIRECTORS',
+  FAMILY_OFFICE = 'FAMILY_OFFICE',
+}
+
+export enum ResultType {
+  PASS = 'PASS',
+  FAIL = 'FAIL',
+}
+
+const aicInclude = z.enum(['individual']);
+
+export const AicIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          aicInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${aicInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${aicInclude.options.join(',')}`,
+    }),
+});
+
+export const IncomeDataEntryZod = z.object({
+  year: z
+    .number()
+    .int()
+    .min(2020)
+    .max(new Date().getFullYear() - 1),
+  filingStatus: z.nativeEnum(FilingStatus),
+  income: z.number().min(0).multipleOf(0.01),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type IncomeDataEntryZod = z.infer<typeof IncomeDataEntryZod>;
+
+export const NetWorthDataEntryZod = z.object({
+  institution: z.string().min(1).max(100),
+  accountType: z.nativeEnum(AccountType),
+  balance: z.number().min(0).multipleOf(0.01),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type NetWorthDataEntryZod = z.infer<typeof NetWorthDataEntryZod>;
+
+export const ProfessionalDataEntryZod = z
+  .object({
+    professionalType: z.nativeEnum(ProfessionalType),
+    licenseNumber: z.string().min(1).max(50).optional().nullable(),
+    fileId: z
+      .lazy(() => fileIdSchema)
+      .optional()
+      .nullable(),
+  })
+  .refine(
+    (data) => {
+      if (data.professionalType === ProfessionalType.SECURITIES_LICENSES) {
+        return !!data.licenseNumber;
+      }
+      return true;
+    },
+    {
+      message: `License number is required when professional type is ${ProfessionalType.SECURITIES_LICENSES}`,
+      path: ['licenseNumber'],
+    },
+  );
+
+export type ProfessionalDataEntryZod = z.infer<typeof ProfessionalDataEntryZod>;
+
+export const EmployeeDataEntryZod = z.object({
+  position: z.string().min(1).max(100),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type EmployeeDataEntryZod = z.infer<typeof EmployeeDataEntryZod>;
+
+// Validation configuration types
+export interface AicValidationConfig<T> {
+  schema: z.ZodType<T>;
+  errorPrefix: string;
+}
+
+export type AicValidationConfigMap = {
+  [AicAccreditationType.INCOME]: AicValidationConfig<IncomeDataEntryZod>;
+  [AicAccreditationType.NET_WORTH]: AicValidationConfig<NetWorthDataEntryZod>;
+  [AicAccreditationType.PROFESSIONAL_CERTIFICATION]: AicValidationConfig<ProfessionalDataEntryZod>;
+  [AicAccreditationType.KNOWLEDGEABLE_EMPLOYEE]: AicValidationConfig<EmployeeDataEntryZod>;
+};
+
+export const validationConfig: AicValidationConfigMap = {
+  [AicAccreditationType.INCOME]: {
+    schema: IncomeDataEntryZod,
+    errorPrefix: 'Income verification',
+  },
+  [AicAccreditationType.NET_WORTH]: {
+    schema: NetWorthDataEntryZod,
+    errorPrefix: 'Net worth verification',
+  },
+  [AicAccreditationType.PROFESSIONAL_CERTIFICATION]: {
+    schema: ProfessionalDataEntryZod,
+    errorPrefix: 'Professional certification',
+  },
+  [AicAccreditationType.KNOWLEDGEABLE_EMPLOYEE]: {
+    schema: EmployeeDataEntryZod,
+    errorPrefix: 'Employee verification',
+  },
+} as const;
+
+export const AicSystemLogEntryZod = z.object({
+  check: z.string().min(1),
+  entered: z.number().optional(),
+  extracted: z.number().optional(),
+  result: z.nativeEnum(ResultType),
+  reason: z.string().optional(),
+});
+
+export type AicSystemLogEntryZod = z.infer<typeof AicSystemLogEntryZod>;
+
+export const AicZod = IBaseEntity.extend({
+  individualId: z.lazy(() => individualIdSchema),
+  individual: z
+    .lazy(() => IIndividualZod)
+    .nullable()
+    .optional(),
+  complianceReview: z.nativeEnum(ComplianceReview),
+  reviewedById: z.lazy(() => userIdSchema).nullable(),
+  reviewedBy: z
+    .lazy(() => UserZod)
+    .nullable()
+    .optional(),
+  reviewedAt: z.date().nullable(),
+  systemReview: z.nativeEnum(SystemReviewStatus),
+  systemLog: z.array(AicSystemLogEntryZod).nullable(),
+  firstName: z.string(),
+  lastName: z.string(),
+  method: z.nativeEnum(AicAccreditationType),
+  incomeData: z.array(IncomeDataEntryZod).nullable(),
+  netWorthData: z.array(NetWorthDataEntryZod).nullable(),
+  professionalData: z.array(ProfessionalDataEntryZod).nullable(),
+  employeeData: z.array(EmployeeDataEntryZod).nullable(),
+});
+
+export type AicZod = z.infer<typeof AicZod>;
+
+export const PostAicZod = z.object({
+  firstName: z.string().min(1).max(50),
+  lastName: z.string().min(1).max(50),
+  method: z.nativeEnum(AicAccreditationType),
+});
+
+export type PostAicZod = z.infer<typeof PostAicZod>;
+
+export const UpdateAicZod = z.object({
+  firstName: z.string().min(1).max(50),
+  lastName: z.string().min(1).max(50),
+  method: z.nativeEnum(AicAccreditationType),
+});
+
+export type UpdateAicZod = z.infer<typeof UpdateAicZod>;
+
+export const AttachAicFilePathParamsZod = z.object({
+  individualId: z.lazy(() => individualIdSchema),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type AttachAicFilePathParamsZod = z.infer<
+  typeof AttachAicFilePathParamsZod
+>;
+
+export const AttachAicFileBodyZod = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(AicAccreditationType.INCOME),
+    metadata: z.array(IncomeDataEntryZod),
+  }),
+  z.object({
+    type: z.literal(AicAccreditationType.NET_WORTH),
+    metadata: z.array(NetWorthDataEntryZod),
+  }),
+  z.object({
+    type: z.literal(AicAccreditationType.PROFESSIONAL_CERTIFICATION),
+    metadata: z.array(ProfessionalDataEntryZod),
+  }),
+  z.object({
+    type: z.literal(AicAccreditationType.KNOWLEDGEABLE_EMPLOYEE),
+    metadata: z.array(EmployeeDataEntryZod),
+  }),
+]);
+
+export type AttachAicFilePathBodyZod = z.infer<typeof AttachAicFileBodyZod>;
+
+export const ComplianceAicQueryZod = z.object({
+  accountId: z.lazy(() => accountIdSchema),
+});
+
+export type ComplianceAicQueryZod = z.infer<typeof ComplianceAicQueryZod>;
+
+export const ComplianceAttachAicFileBodyZod = AttachAicFileBodyZod.and(
+  z.object({
+    accountId: z.lazy(() => accountIdSchema),
+  }),
+);
+
+export type ComplianceAttachAicFileBodyZod = z.infer<
+  typeof ComplianceAttachAicFileBodyZod
+>;

package/common/types/aml.types.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { AMLStatus } from './common.types';
+
+extendZodWithOpenApi(z);
+
+export const AmlZod = IBaseEntity.extend({
+  tid: z.string().openapi({ example: 'third_party_kyc_123' }).nullable(),
+  provider: z.string().nullable().openapi({ example: 'AML Provider' }),
+  url: z.string().nullable().openapi({ example: 'https://example.com/aml' }),
+  status: z.nativeEnum(AMLStatus).openapi({ example: 'PENDING' }),
+  checkedAt: z.date().nullable().openapi({ example: '2022-01-01T00:00:00Z' }),
+  individualId: z
+    .string()
+    .openapi({ example: 'individual_01j1xgme5qeqq97gpdztd7e4a6' }),
+});
+export type AmlZod = z.infer<typeof AmlZod>;

package/common/types/api-key-logs.types.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { HttpStatus } from '@nestjs/common';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IPaginationMeta, HttpMethod, dateSchema } from './common.types';
+import { apiKeyIdSchema } from './api-keys.types';
+import { IBaseEntity } from './entity.types';
+
+extendZodWithOpenApi(z);
+
+export const ApiLogsFiltersZod = z.object({
+  endpoint: z.string().optional(),
+  apiKeyId: apiKeyIdSchema.optional(),
+  method: z.nativeEnum(HttpMethod).optional(),
+  status: z.nativeEnum(HttpStatus).optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type ApiLogsFiltersZod = z.infer<typeof ApiLogsFiltersZod>;
+
+export const apiKeyLogIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'api_key_log';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid Api Key Log ID format. Must be a valid TypeID with "api_key_log" prefix. Example: api_key_log_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export const ApiKeyLogZod = IBaseEntity.extend({
+  id: apiKeyLogIdSchema,
+  apiKeyId: apiKeyIdSchema,
+  method: z.nativeEnum(HttpMethod),
+  path: z.string(),
+  status: z.nativeEnum(HttpStatus),
+  durationMs: z.number(),
+  requestBody: z.record(z.any()).nullable(),
+  responseBody: z.record(z.any()).nullable(),
+});
+export type ApiKeyLogZod = z.infer<typeof ApiKeyLogZod>;
+
+export const ApiLogsTotalsFiltersZod = z.object({
+  apiKeyId: apiKeyIdSchema.optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type ApiLogsTotalsFiltersZod = z.infer<typeof ApiLogsTotalsFiltersZod>;
+
+export const ApiLogsTotalsZod = z.object({
+  success: z.number(),
+  failed: z.number(),
+  total: z.number().optional(),
+});
+export type ApiLogsTotalsZod = z.infer<typeof ApiLogsTotalsZod>;
+
+export const IPaginatedApiLogs = z.object({
+  items: z.array(ApiKeyLogZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedApiLogs = z.infer<typeof IPaginatedApiLogs>;

package/common/types/api-keys.types.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta, PortalType } from './common.types';
+import { accountIdSchema } from './account.types';
+extendZodWithOpenApi(z);
+
+export const apiKeyIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'api_key';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid Api Key ID format. Must be a valid TypeID with "api_key" prefix. Example: api_key_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export const ApiKeyZod = IBaseEntity.extend({
+  id: apiKeyIdSchema,
+  name: z.string(),
+  description: z.string().nullable(),
+  key: z.string(),
+  keyHash: z.string(),
+  active: z.boolean(),
+  lastUsedAt: z.date().nullable(),
+  accountId: z.string(),
+  roleId: z.string().nullable(),
+});
+export type ApiKeyZod = z.infer<typeof ApiKeyZod>;
+
+export const IPaginatedApiKeys = z.object({
+  items: z.array(ApiKeyZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedApiKeys = z.infer<typeof IPaginatedApiKeys>;
+
+export const PostApiKeyBody = z.object({
+  name: z
+    .string()
+    .min(2, 'name is less than 2 characters')
+    .max(30, 'name is more than 30 characters')
+    .openapi({ description: 'Name of the API key' }),
+  description: z
+    .string()
+    .min(2, 'description is less than 2 characters')
+    .max(50, 'description is more than 50 characters')
+    .optional()
+    .openapi({ description: 'Description of the API key' }),
+  accountId: accountIdSchema,
+  contract: z
+    .enum([
+      PortalType.CLIENT,
+      PortalType.SECONDARIES,
+      PortalType.COMPLIANCE_APIKEY,
+    ])
+    .default(PortalType.CLIENT),
+});
+export type PostApiKeyBody = z.infer<typeof PostApiKeyBody>;
+
+//It removes accountId because issuers use user.accountId from authentication, so the request body shouldn't include it.
+export const PostIssuerApiKeyBody = PostApiKeyBody.omit({ accountId: true });
+
+export type PostIssuerApiKeyBody = z.infer<typeof PostIssuerApiKeyBody>;