@dalmore/api-contracts 0.0.0-dev.56068a6 → 0.0.0-dev.56f7e68

package/common/types/countries.types.ts

@@ -1,375 +0,0 @@
-import { z } from 'zod';
-
-const CountrySchema = z.object({
-  code: z.string().length(2),
-  name: z.string(),
-});
-type Country = z.infer<typeof CountrySchema>;
-
-const CountriesSchema = z.array(CountrySchema);
-
-const countries: Country[] = [
-  { code: 'AD', name: 'Andorra' },
-  { code: 'AE', name: 'United Arab Emirates' },
-  { code: 'AF', name: 'Afghanistan' },
-  { code: 'AG', name: 'Antigua and Barbuda' },
-  { code: 'AI', name: 'Anguilla' },
-  { code: 'AL', name: 'Albania' },
-  { code: 'AM', name: 'Armenia' },
-  { code: 'AO', name: 'Angola' },
-  { code: 'AQ', name: 'Antarctica' },
-  { code: 'AR', name: 'Argentina' },
-  { code: 'AS', name: 'American Samoa' },
-  { code: 'AT', name: 'Austria' },
-  { code: 'AU', name: 'Australia' },
-  { code: 'AW', name: 'Aruba' },
-  { code: 'AX', name: 'Åland Islands' },
-  { code: 'AZ', name: 'Azerbaijan' },
-  { code: 'BA', name: 'Bosnia and Herzegovina' },
-  { code: 'BB', name: 'Barbados' },
-  { code: 'BD', name: 'Bangladesh' },
-  { code: 'BE', name: 'Belgium' },
-  { code: 'BF', name: 'Burkina Faso' },
-  { code: 'BG', name: 'Bulgaria' },
-  { code: 'BH', name: 'Bahrain' },
-  { code: 'BI', name: 'Burundi' },
-  { code: 'BJ', name: 'Benin' },
-  { code: 'BL', name: 'Saint Barthélemy' },
-  { code: 'BM', name: 'Bermuda' },
-  { code: 'BN', name: 'Brunei Darussalam' },
-  { code: 'BO', name: 'Bolivia, Plurinational State of' },
-  { code: 'BQ', name: 'Bonaire, Sint Eustatius and Saba' },
-  { code: 'BR', name: 'Brazil' },
-  { code: 'BS', name: 'Bahamas' },
-  { code: 'BT', name: 'Bhutan' },
-  { code: 'BV', name: 'Bouvet Island' },
-  { code: 'BW', name: 'Botswana' },
-  { code: 'BY', name: 'Belarus' },
-  { code: 'BZ', name: 'Belize' },
-  { code: 'CA', name: 'Canada' },
-  { code: 'CC', name: 'Cocos (Keeling) Islands' },
-  { code: 'CD', name: 'Congo, Democratic Republic of the' },
-  { code: 'CF', name: 'Central African Republic' },
-  { code: 'CG', name: 'Congo' },
-  { code: 'CH', name: 'Switzerland' },
-  { code: 'CI', name: "Côte d'Ivoire" },
-  { code: 'CK', name: 'Cook Islands' },
-  { code: 'CL', name: 'Chile' },
-  { code: 'CM', name: 'Cameroon' },
-  { code: 'CN', name: 'China' },
-  { code: 'CO', name: 'Colombia' },
-  { code: 'CR', name: 'Costa Rica' },
-  { code: 'CU', name: 'Cuba' },
-  { code: 'CV', name: 'Cabo Verde' },
-  { code: 'CW', name: 'Curaçao' },
-  { code: 'CX', name: 'Christmas Island' },
-  { code: 'CY', name: 'Cyprus' },
-  { code: 'CZ', name: 'Czechia' },
-  { code: 'DE', name: 'Germany' },
-  { code: 'DJ', name: 'Djibouti' },
-  { code: 'DK', name: 'Denmark' },
-  { code: 'DM', name: 'Dominica' },
-  { code: 'DO', name: 'Dominican Republic' },
-  { code: 'DZ', name: 'Algeria' },
-  { code: 'EC', name: 'Ecuador' },
-  { code: 'EE', name: 'Estonia' },
-  { code: 'EG', name: 'Egypt' },
-  { code: 'EH', name: 'Western Sahara' },
-  { code: 'ER', name: 'Eritrea' },
-  { code: 'ES', name: 'Spain' },
-  { code: 'ET', name: 'Ethiopia' },
-  { code: 'FI', name: 'Finland' },
-  { code: 'FJ', name: 'Fiji' },
-  { code: 'FK', name: 'Falkland Islands (Malvinas)' },
-  { code: 'FM', name: 'Micronesia, Federated States of' },
-  { code: 'FO', name: 'Faroe Islands' },
-  { code: 'FR', name: 'France' },
-  { code: 'GA', name: 'Gabon' },
-  { code: 'GB', name: 'United Kingdom of Great Britain and Northern Ireland' },
-  { code: 'GD', name: 'Grenada' },
-  { code: 'GE', name: 'Georgia' },
-  { code: 'GF', name: 'French Guiana' },
-  { code: 'GG', name: 'Guernsey' },
-  { code: 'GH', name: 'Ghana' },
-  { code: 'GI', name: 'Gibraltar' },
-  { code: 'GL', name: 'Greenland' },
-  { code: 'GM', name: 'Gambia' },
-  { code: 'GN', name: 'Guinea' },
-  { code: 'GP', name: 'Guadeloupe' },
-  { code: 'GQ', name: 'Equatorial Guinea' },
-  { code: 'GR', name: 'Greece' },
-  { code: 'GS', name: 'South Georgia and the South Sandwich Islands' },
-  { code: 'GT', name: 'Guatemala' },
-  { code: 'GU', name: 'Guam' },
-  { code: 'GW', name: 'Guinea-Bissau' },
-  { code: 'GY', name: 'Guyana' },
-  { code: 'HK', name: 'Hong Kong' },
-  { code: 'HM', name: 'Heard Island and McDonald Islands' },
-  { code: 'HN', name: 'Honduras' },
-  { code: 'HR', name: 'Croatia' },
-  { code: 'HT', name: 'Haiti' },
-  { code: 'HU', name: 'Hungary' },
-  { code: 'ID', name: 'Indonesia' },
-  { code: 'IE', name: 'Ireland' },
-  { code: 'IL', name: 'Israel' },
-  { code: 'IM', name: 'Isle of Man' },
-  { code: 'IN', name: 'India' },
-  { code: 'IO', name: 'British Indian Ocean Territory' },
-  { code: 'IQ', name: 'Iraq' },
-  { code: 'IR', name: 'Iran, Islamic Republic of' },
-  { code: 'IS', name: 'Iceland' },
-  { code: 'IT', name: 'Italy' },
-  { code: 'JE', name: 'Jersey' },
-  { code: 'JM', name: 'Jamaica' },
-  { code: 'JO', name: 'Jordan' },
-  { code: 'JP', name: 'Japan' },
-  { code: 'KE', name: 'Kenya' },
-  { code: 'KG', name: 'Kyrgyzstan' },
-  { code: 'KH', name: 'Cambodia' },
-  { code: 'KI', name: 'Kiribati' },
-  { code: 'KM', name: 'Comoros' },
-  { code: 'KN', name: 'Saint Kitts and Nevis' },
-  { code: 'KP', name: "Korea, Democratic People's Republic of" },
-  { code: 'KR', name: 'Korea, Republic of' },
-  { code: 'KW', name: 'Kuwait' },
-  { code: 'KY', name: 'Cayman Islands' },
-  { code: 'KZ', name: 'Kazakhstan' },
-  { code: 'LA', name: "Lao People's Democratic Republic" },
-  { code: 'LB', name: 'Lebanon' },
-  { code: 'LC', name: 'Saint Lucia' },
-  { code: 'LI', name: 'Liechtenstein' },
-  { code: 'LK', name: 'Sri Lanka' },
-  { code: 'LR', name: 'Liberia' },
-  { code: 'LS', name: 'Lesotho' },
-  { code: 'LT', name: 'Lithuania' },
-  { code: 'LU', name: 'Luxembourg' },
-  { code: 'LV', name: 'Latvia' },
-  { code: 'LY', name: 'Libya' },
-  { code: 'MA', name: 'Morocco' },
-  { code: 'MC', name: 'Monaco' },
-  { code: 'MD', name: 'Moldova, Republic of' },
-  { code: 'ME', name: 'Montenegro' },
-  { code: 'MF', name: 'Saint Martin, (French part)' },
-  { code: 'MG', name: 'Madagascar' },
-  { code: 'MH', name: 'Marshall Islands' },
-  { code: 'MK', name: 'North Macedonia' },
-  { code: 'ML', name: 'Mali' },
-  { code: 'MM', name: 'Myanmar' },
-  { code: 'MN', name: 'Mongolia' },
-  { code: 'MO', name: 'Macao' },
-  { code: 'MP', name: 'Northern Mariana Islands' },
-  { code: 'MQ', name: 'Martinique' },
-  { code: 'MR', name: 'Mauritania' },
-  { code: 'MS', name: 'Montserrat' },
-  { code: 'MT', name: 'Malta' },
-  { code: 'MU', name: 'Mauritius' },
-  { code: 'MV', name: 'Maldives' },
-  { code: 'MW', name: 'Malawi' },
-  { code: 'MX', name: 'Mexico' },
-  { code: 'MY', name: 'Malaysia' },
-  { code: 'MZ', name: 'Mozambique' },
-  { code: 'NA', name: 'Namibia' },
-  { code: 'NC', name: 'New Caledonia' },
-  { code: 'NE', name: 'Niger' },
-  { code: 'NF', name: 'Norfolk Island' },
-  { code: 'NG', name: 'Nigeria' },
-  { code: 'NI', name: 'Nicaragua' },
-  { code: 'NL', name: 'Netherlands' },
-  { code: 'NO', name: 'Norway' },
-  { code: 'NP', name: 'Nepal' },
-  { code: 'NR', name: 'Nauru' },
-  { code: 'NU', name: 'Niue' },
-  { code: 'NZ', name: 'New Zealand' },
-  { code: 'OM', name: 'Oman' },
-  { code: 'PA', name: 'Panama' },
-  { code: 'PE', name: 'Peru' },
-  { code: 'PF', name: 'French Polynesia' },
-  { code: 'PG', name: 'Papua New Guinea' },
-  { code: 'PH', name: 'Philippines' },
-  { code: 'PK', name: 'Pakistan' },
-  { code: 'PL', name: 'Poland' },
-  { code: 'PM', name: 'Saint Pierre and Miquelon' },
-  { code: 'PN', name: 'Pitcairn' },
-  { code: 'PR', name: 'Puerto Rico' },
-  { code: 'PS', name: 'Palestine, State of' },
-  { code: 'PT', name: 'Portugal' },
-  { code: 'PW', name: 'Palau' },
-  { code: 'PY', name: 'Paraguay' },
-  { code: 'QA', name: 'Qatar' },
-  { code: 'RE', name: 'Réunion' },
-  { code: 'RO', name: 'Romania' },
-  { code: 'RS', name: 'Serbia' },
-  { code: 'RU', name: 'Russian Federation' },
-  { code: 'RW', name: 'Rwanda' },
-  { code: 'SA', name: 'Saudi Arabia' },
-  { code: 'SB', name: 'Solomon Islands' },
-  { code: 'SC', name: 'Seychelles' },
-  { code: 'SD', name: 'Sudan' },
-  { code: 'SE', name: 'Sweden' },
-  { code: 'SG', name: 'Singapore' },
-  { code: 'SH', name: 'Saint Helena, Ascension and Tristan da Cunha' },
-  { code: 'SI', name: 'Slovenia' },
-  { code: 'SJ', name: 'Svalbard and Jan Mayen' },
-  { code: 'SK', name: 'Slovakia' },
-  { code: 'SL', name: 'Sierra Leone' },
-  { code: 'SM', name: 'San Marino' },
-  { code: 'SN', name: 'Senegal' },
-  { code: 'SO', name: 'Somalia' },
-  { code: 'SR', name: 'Suriname' },
-  { code: 'SS', name: 'South Sudan' },
-  { code: 'ST', name: 'Sao Tome and Principe' },
-  { code: 'SV', name: 'El Salvador' },
-  { code: 'SX', name: 'Sint Maarten, (Dutch part)' },
-  { code: 'SY', name: 'Syrian Arab Republic' },
-  { code: 'SZ', name: 'Eswatini' },
-  { code: 'TC', name: 'Turks and Caicos Islands' },
-  { code: 'TD', name: 'Chad' },
-  { code: 'TF', name: 'French Southern Territories' },
-  { code: 'TG', name: 'Togo' },
-  { code: 'TH', name: 'Thailand' },
-  { code: 'TJ', name: 'Tajikistan' },
-  { code: 'TK', name: 'Tokelau' },
-  { code: 'TL', name: 'Timor-Leste' },
-  { code: 'TM', name: 'Turkmenistan' },
-  { code: 'TN', name: 'Tunisia' },
-  { code: 'TO', name: 'Tonga' },
-  { code: 'TR', name: 'Türkiye' },
-  { code: 'TT', name: 'Trinidad and Tobago' },
-  { code: 'TV', name: 'Tuvalu' },
-  { code: 'TW', name: 'Taiwan, Province of China' },
-  { code: 'TZ', name: 'Tanzania, United Republic of' },
-  { code: 'UA', name: 'Ukraine' },
-  { code: 'UG', name: 'Uganda' },
-  { code: 'UM', name: 'United States Minor Outlying Islands' },
-  { code: 'US', name: 'United States of America' },
-  { code: 'UY', name: 'Uruguay' },
-  { code: 'UZ', name: 'Uzbekistan' },
-  { code: 'VA', name: 'Holy See' },
-  { code: 'VC', name: 'Saint Vincent and the Grenadines' },
-  { code: 'VE', name: 'Venezuela, Bolivarian Republic of' },
-  { code: 'VG', name: 'Virgin Islands, British' },
-  { code: 'VI', name: 'Virgin Islands, U.S.' },
-  { code: 'VN', name: 'Viet Nam' },
-  { code: 'VU', name: 'Vanuatu' },
-  { code: 'WF', name: 'Wallis and Futuna' },
-  { code: 'WS', name: 'Samoa' },
-  { code: 'YE', name: 'Yemen' },
-  { code: 'YT', name: 'Mayotte' },
-  { code: 'ZA', name: 'South Africa' },
-  { code: 'ZM', name: 'Zambia' },
-  { code: 'ZW', name: 'Zimbabwe' },
-] as const;
-const validatedCountries = CountriesSchema.parse(countries);
-
-export const CountryCodes = countries.map((c) => c.code);
-
-const countryEnum = countries.reduce(
-  (acc, country) => {
-    acc[country.code] = country.code;
-    return acc;
-  },
-  {} as Record<string, string>,
-);
-
-export const CountryCode = Object.freeze(countryEnum);
-
-export const CountryEnumSchema = z.nativeEnum(CountryCode);
-
-/**
- * Grey list of countries
- * This list contains country codes that are considered "grey listed"
- */
-export const GREY_LIST_COUNTRIES: readonly Country[] = [
-  { code: 'DZ', name: 'Algeria' },
-  { code: 'AO', name: 'Angola' },
-  { code: 'BG', name: 'Bulgaria' },
-  { code: 'BF', name: 'Burkina Faso' },
-  { code: 'CM', name: 'Cameroon' },
-  { code: 'CI', name: "Côte d'Ivoire" },
-  { code: 'HR', name: 'Croatia' },
-  { code: 'CD', name: 'Congo, Democratic Republic of the' },
-  { code: 'HT', name: 'Haiti' },
-  { code: 'KE', name: 'Kenya' },
-  { code: 'LA', name: "Lao People's Democratic Republic" },
-  { code: 'LB', name: 'Lebanon' },
-  { code: 'ML', name: 'Mali' },
-  { code: 'MC', name: 'Monaco' },
-  { code: 'MZ', name: 'Mozambique' },
-  { code: 'NA', name: 'Namibia' },
-  { code: 'NP', name: 'Nepal' },
-  { code: 'NG', name: 'Nigeria' },
-  { code: 'ZA', name: 'South Africa' },
-  { code: 'SS', name: 'South Sudan' },
-  { code: 'SY', name: 'Syrian Arab Republic' },
-  { code: 'TZ', name: 'Tanzania, United Republic of' },
-  { code: 'VE', name: 'Venezuela, Bolivarian Republic of' },
-  { code: 'VN', name: 'Viet Nam' },
-  { code: 'YE', name: 'Yemen' },
-];
-
-/**
- * Black list of countries
- * This list contains country codes that are considered "black listed"
- */
-export const BLACK_LIST_COUNTRIES: readonly Country[] = [
-  { code: 'KP', name: "Korea, Democratic People's Republic of" },
-  { code: 'IR', name: 'Iran, Islamic Republic of' },
-  { code: 'MM', name: 'Myanmar' },
-];
-
-/**
- * List of grey list country codes for easier lookups
- */
-export const GREY_LIST_COUNTRY_CODES = GREY_LIST_COUNTRIES.map((c) => c.code);
-
-/**
- * List of black list country codes for easier lookups
- */
-export const BLACK_LIST_COUNTRY_CODES = BLACK_LIST_COUNTRIES.map((c) => c.code);
-
-/**
- * Checks if a country is in the grey list
- * @param code The country code to check
- * @returns {boolean} True if the country is in the grey list
- *
- * @example
- * const isGreyListed = isGreyListedCountry('VN');
- */
-export function isGreyListedCountry(code: string): boolean {
-  return GREY_LIST_COUNTRY_CODES.includes(code.toUpperCase());
-}
-
-/**
- * Checks if a country is in the black list
- * @param code The country code to check
- * @returns {boolean} True if the country is in the black list
- *
- * @example
- * const isBlackListed = isBlackListedCountry('IR');
- */
-export function isBlackListedCountry(code: string): boolean {
-  return BLACK_LIST_COUNTRY_CODES.includes(code.toUpperCase());
-}
-
-/**
- *
- * @param code  The country code
- * @returns {Country | undefined}  The country object
- *
- * @example
- * const usa = findCountryByCode('US');
- * console.log(usa); // { code: "US", name: "United States of America" }
- */
-function findCountryByCode(code: string): Country | undefined {
-  return validatedCountries.find(
-    (country) => country.code === code.toUpperCase(),
-  );
-}
-
-export {
-  CountrySchema,
-  CountriesSchema,
-  validatedCountries,
-  findCountryByCode,
-};
-export type { Country };

package/common/types/covered-person.types.ts

@@ -1,275 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import {
-  AccountZod,
-  ComplianceReview,
-  CoveredPersonsRoleType,
-  CoveredPersonsStatus,
-  EmailSchema,
-  IDType,
-  IPaginationMeta,
-} from './common.types';
-import { IBaseEntity } from './entity.types';
-
-import { IIssuer, issuerIdSchema } from './issuer.types';
-import { fileIdSchema } from './file.types';
-import { accountIdSchema } from './account.types';
-
-extendZodWithOpenApi(z);
-export const coveredPersonIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'covered_person';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid covered person ID format. Must be a valid TypeID with "covered_person" prefix.',
-  },
-);
-
-export const coveredPersonsInclude = z.enum(['issuer', 'parent', 'account']);
-
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(CoveredPersonsIncludeQuery),
- */
-export const CoveredPersonsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          coveredPersonsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${coveredPersonsInclude.options.join(', ')}`,
-      },
-    )
-    .openapi({
-      example: `${coveredPersonsInclude.options.join(', ')}`,
-    }),
-});
-export interface CoveredPersonsIncludeQuery
-  extends z.infer<typeof CoveredPersonsIncludeQuery> {}
-
-export const PostCoveredPersonsZod = z
-  .object({
-    firstName: z.string().min(2).max(50).openapi({ example: 'John' }),
-    lastName: z
-      .string()
-      .min(2)
-      .max(50)
-      .nullable()
-      .optional()
-      .openapi({ example: 'Doe' }),
-    issuerId: z
-      .lazy(() => issuerIdSchema)
-      .openapi({
-        example: 'issuer_01jatr819xff9s6wek8d2tng3x',
-      }),
-    email: z.string().email().nullable().optional(),
-    role: z
-      .nativeEnum(CoveredPersonsRoleType)
-      .openapi({ example: CoveredPersonsRoleType.ACCOUNTING }),
-    ownership: z.number().min(0).max(100).default(0).openapi({ example: 15 }),
-    parentId: coveredPersonIdSchema
-
-      .nullable()
-      .openapi({ example: 'covered_person_01jatr819xff9s6wek8d2tng3x' }),
-    idType: z
-      .nativeEnum(IDType)
-      .nullable()
-      .optional()
-      .openapi({ example: IDType.DRIVERS_LICENSE }),
-  })
-  .superRefine((data, ctx) => {
-    if (data.role !== CoveredPersonsRoleType.ENTITY) {
-      if (!data.email) {
-        ctx.addIssue({
-          path: ['email'],
-          message: 'Email is required when role type is not ENTITY.',
-          code: 'custom',
-        });
-      }
-      if (!data.idType || data.idType == null) {
-        ctx.addIssue({
-          path: ['idType'],
-          message: 'IdType is required when role type is not ENTITY',
-          code: 'custom',
-        });
-      }
-    } else {
-      if (data.lastName) {
-        ctx.addIssue({
-          path: ['lastName'],
-          message: 'Last name is not allowed when the role type is ENTITY',
-          code: 'custom',
-        });
-      }
-      if (data.idType) {
-        ctx.addIssue({
-          path: ['idType'],
-          message: 'Id Type is not allowed when the role type is ENTITY',
-          code: 'custom',
-        });
-      }
-    }
-  });
-export type PostCoveredPersonsZod = z.infer<typeof PostCoveredPersonsZod>;
-export const PatchCoveredPersonsZod = z
-  .object({
-    firstName: z
-      .string()
-      .min(2)
-      .max(50)
-      .optional()
-      .openapi({ example: 'John' }),
-    lastName: z.string().min(2).max(50).optional().openapi({ example: 'Doe' }),
-    role: z
-      .nativeEnum(CoveredPersonsRoleType)
-      .optional()
-      .openapi({ example: CoveredPersonsRoleType.ACCOUNTING }),
-
-    ownership: z.number().min(0).max(100).openapi({ example: 15 }).optional(),
-    email: EmailSchema.nullable().optional(),
-    idType: z
-      .nativeEnum(IDType)
-      .optional()
-      .nullable()
-      .openapi({ example: IDType.DRIVERS_LICENSE }),
-    identityFileFrontId: z
-      .lazy(() => fileIdSchema)
-      .optional()
-      .nullable(),
-    identityFileBackId: z
-      .lazy(() => fileIdSchema)
-      .optional()
-      .nullable(),
-    badActorReportFileId: z
-      .lazy(() => fileIdSchema)
-      .optional()
-      .nullable(),
-  })
-  .superRefine((data, ctx) => {
-    if (data.role !== CoveredPersonsRoleType.ENTITY && data.role) {
-      if (!data.email) {
-        ctx.addIssue({
-          path: ['email'],
-          message: 'Email is required when role type is not ENTITY.',
-          code: 'custom',
-        });
-      }
-      if (!data.idType || data.idType == null) {
-        ctx.addIssue({
-          path: ['idType'],
-          message: 'IdType is required when role type is not ENTITY',
-          code: 'custom',
-        });
-      }
-    } else if (data.role && data.role === CoveredPersonsRoleType.ENTITY) {
-      if (data.lastName) {
-        ctx.addIssue({
-          path: ['lastName'],
-          message: 'Last name is not allowed when the role type is ENTITY',
-          code: 'custom',
-        });
-      }
-      if (data.idType) {
-        ctx.addIssue({
-          path: ['idType'],
-          message: 'Id Type is not allowed when the role type is ENTITY',
-          code: 'custom',
-        });
-      }
-    }
-  });
-export type PatchCoveredPersonsZod = z.infer<typeof PatchCoveredPersonsZod>;
-
-export const ReviewCoveredPersons = z.object({
-  complianceReview: z.enum([
-    ComplianceReview.APPROVED,
-    ComplianceReview.REJECTED,
-  ]),
-  coveredPersons: z
-    .array(coveredPersonIdSchema)
-    .min(1, 'At least one coveredPerson is required')
-    .max(50, 'Maximum of 50 coveredPersons allowed')
-    .openapi({
-      example: [
-        'covered_person_01jjsdrx1seqfse7z4z47sgdp5',
-        'covered_person_01jjsdrx27enkszq5cnc3hdhrf',
-      ],
-    }),
-});
-export type ReviewCoveredPersons = z.infer<typeof ReviewCoveredPersons>;
-
-export const ICoveredPerson = IBaseEntity.extend({
-  firstName: z.string().nullable().optional().openapi({ example: 'John' }),
-  lastName: z.string().nullable().optional().openapi({ example: 'Doe' }),
-  role: z
-    .nativeEnum(CoveredPersonsRoleType)
-    .openapi({ example: CoveredPersonsRoleType.ENTITY }),
-  ownership: z.number().openapi({ example: 15 }),
-  accountId: z.string(),
-  account: AccountZod.optional().nullable(),
-  issuer: z
-    .lazy(() => IIssuer)
-    .optional()
-    .nullable(),
-  issuerId: z.string(),
-  parent: z.lazy(() => ICoveredPerson.optional().nullable()),
-  parentId: z.string().nullable().optional().default(null),
-  idType: z.nativeEnum(IDType).nullable(),
-  email: z.string().nullable(),
-  identityFileFrontId: z.string().optional().nullable(),
-  identityFileBackId: z.string().optional().nullable(),
-  badActorReportFileId: z.string().optional().nullable(),
-  status: z.nativeEnum(CoveredPersonsStatus),
-});
-
-export type ICoveredPerson = z.infer<typeof ICoveredPerson>;
-
-export const IPaginatedCoveredPerson = z.object({
-  items: z.array(ICoveredPerson),
-  meta: IPaginationMeta,
-});
-export type IPaginatedCoveredPerson = z.infer<typeof IPaginatedCoveredPerson>;
-
-export const GetCoveredPersonsZod = z.object({
-  id: coveredPersonIdSchema.optional(),
-  issuerId: z.lazy(() => issuerIdSchema).optional(),
-  parentId: z
-    .union([coveredPersonIdSchema, z.literal('null'), z.undefined()])
-    .optional() // Allow valid parentId, "null", or undefined
-    .transform((value) => {
-      if (value === 'null') {
-        return null; // Transform "null" string to actual null
-      }
-      return value; // Return valid parentId or undefined as is
-    }),
-
-  firstName: z.string().min(2).max(50).optional().openapi({ example: 'John' }),
-  role: z
-    .nativeEnum(CoveredPersonsRoleType)
-
-    .optional()
-    .openapi({ example: CoveredPersonsRoleType.ACCOUNTING }),
-  status: z.nativeEnum(CoveredPersonsStatus).optional(),
-  accountId: accountIdSchema.optional(),
-});
-
-export type GetCoveredPersonsZod = z.infer<typeof GetCoveredPersonsZod>;
-
-export const CoveredPersonDeleteResponse = z.object({
-  message: z.string(),
-});
-export type CoveredPersonDeleteResponse = z.infer<
-  typeof CoveredPersonDeleteResponse
->;