@dalmore/api-contracts 0.0.0-dev.ee0e6b6 → 0.0.0-dev.fb640f0

package/common/types/activity.types.ts

@@ -1,274 +0,0 @@
-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,
-  JOIN = BaseStatus.JOIN,
-  RESTORE = BaseStatus.RESTORE,
-}
-
-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.nullable(),
-  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()
-    .openapi({
-      example: 'disbursement_01j6aqmtfyfwy9spjdcnh7yqk7',
-    })
-    .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(),
-  targetIds: z
-    .string()
-    .optional()
-    .openapi({
-      example:
-        'disbursement_01j6aqmtfyfwy9spjdcnh7yqk7,disbursement_01j6aqmtfyfwy9spjdcnh7yqk8',
-    })
-    .transform((str) => {
-      if (!str) return [];
-      // Split by comma, trim whitespace, and remove duplicates using Set
-      const ids = str.split(',').map((id) => id.trim());
-      return Array.from(new Set(ids));
-    })
-    .refine(
-      (value) => {
-        if (!value || value.length === 0) return true;
-
-        // Validate each ID
-        return value.every((id) => {
-          try {
-            const tid = TypeID.fromString(id);
-            return Object.values(TargetTableConfig).some(
-              (config) => config.idPrefix === tid.getType(),
-            );
-          } catch {
-            return false;
-          }
-        });
-      },
-      {
-        message: `Invalid target IDs. All IDs must match the corresponding table's ID prefix. Valid prefix: ${TargetTableEnum.toString().toLowerCase()}. Example: disbursement_01j6aqmtfyfwy9spjdcnh7yqk7`,
-      },
-    ),
-});
-export type ActivitiesFilters = z.infer<typeof ActivitiesFilters>;

package/common/types/address.types.ts

@@ -1,41 +0,0 @@
-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

@@ -1,246 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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.preprocess(Number, 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>;