@devizovaburza/mdm-sdk 0.0.11 → 0.0.12

package/dist/v1/index.cjs

@@ -33,7 +33,7 @@ const AddressTypeZod$1 = [
   "REGISTERED_OFFICE",
   "CONTACT_ADDRESS"
 ];
-const ContactTypeZod = [
+const ContactTypeZod$1 = [
   "EMAIL",
   "PHONE_AUTH",
   "PHONE_CONTACT",
@@ -46,7 +46,7 @@ const IdDocStatusZod$1 = [
   "EXPIRE_SOON",
   "REVOKED"
 ];
-const PartyRelationshipTypeZod = [
+const PartyRelationshipTypeZod$1 = [
   "AUTHORIZED_SIGNATORY",
   "POA_HOLDER",
   "BOARD_MEMBER",
@@ -74,7 +74,7 @@ const PartyTypeZod$1 = [
   "SELF_EMPLOYED",
   "ORGANIZATION"
 ];
-const AmlScoreTypeZod = [
+const AmlScoreTypeZod$1 = [
   "LOW",
   "MEDIUM",
   "HIGH",
@@ -87,19 +87,25 @@ const IdentificationTypeZod = [
   "REMOTE_IDENTIFICATION"
 ];
 const GenderZod$1 = ["M", "F", "OTHER"];
-const KycStatusZod = [
+const KycStatusZod$1 = [
   "NOT_APPROVED",
   "VERIFIED",
   "UNVERIFIED",
   "REJECTED"
 ];
-const TRADER_TYPE = ["PERSON", "COMPANY", "OSVC"];
+const TRADER_TYPE$1 = ["PERSON", "COMPANY", "OSVC"];
 
 const AddressTypeZod = [
   "PERMANENT_ADDRESS",
   "REGISTERED_OFFICE",
   "CONTACT_ADDRESS"
 ];
+const ContactTypeZod = [
+  "EMAIL",
+  "PHONE_AUTH",
+  "PHONE_CONTACT",
+  "PHONE_WORK"
+];
 const IdDocTypeZod = ["PASSPORT", "ID", "DRIVING_LICENSE"];
 const IdDocStatusZod = [
   "ACTIVE",
@@ -107,6 +113,12 @@ const IdDocStatusZod = [
   "EXPIRE_SOON",
   "REVOKED"
 ];
+const PartyRelationshipTypeZod = [
+  "AUTHORIZED_SIGNATORY",
+  "POA_HOLDER",
+  "BOARD_MEMBER",
+  "UBO"
+];
 const CustomerStatusZod = [
   // 'LEAD',
   "NEW",
@@ -121,289 +133,47 @@ const PartyTypeZod = [
   "SELF_EMPLOYED",
   "ORGANIZATION"
 ];
+const AmlScoreTypeZod = [
+  "LOW",
+  "MEDIUM",
+  "HIGH",
+  "UNACCEPTABLE",
+  "UNVERIFIED",
+  "UNCLASSIFIED"
+];
 const GenderZod = ["M", "F", "OTHER"];
+const KycStatusZod = [
+  "NOT_APPROVED",
+  "VERIFIED",
+  "UNVERIFIED",
+  "REJECTED"
+];
+const TRADER_TYPE = ["PERSON", "COMPANY", "OSVC"];
 
-const individualInsertSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid().optional(),
-  internalId: zodOpenapi.z.string().optional(),
-  name: zodOpenapi.z.string(),
-  surname: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().optional(),
-  phone: zodOpenapi.z.string().optional(),
-  birthDate: zodOpenapi.z.string().optional(),
-  birthPlace: zodOpenapi.z.string(),
-  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  personalId: zodOpenapi.z.uuid(),
-  gender: zodOpenapi.z.enum(GenderZod),
-  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  employer: zodOpenapi.z.string().optional(),
-  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  registeredNumber: zodOpenapi.z.string(),
-  isPep: zodOpenapi.z.boolean(),
-  titleBefore: zodOpenapi.z.string().optional(),
-  titleAfter: zodOpenapi.z.string().optional(),
-  birthSurname: zodOpenapi.z.string().optional(),
-  vocativeTitle: zodOpenapi.z.string().optional(),
-  deathDate: zodOpenapi.z.date().optional(),
-  deathNotification: zodOpenapi.z.date().optional(),
-  pin: zodOpenapi.z.string().optional(),
-  stayAbroad: zodOpenapi.z.boolean().optional(),
-  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
-});
-const individualUpdateSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().optional(),
-  name: zodOpenapi.z.string().optional(),
-  surname: zodOpenapi.z.string().optional(),
-  email: zodOpenapi.z.string().optional(),
-  phone: zodOpenapi.z.string().optional(),
-  birthDate: zodOpenapi.z.string().optional(),
-  birthPlace: zodOpenapi.z.string().optional(),
-  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  personalId: zodOpenapi.z.uuid().optional(),
-  gender: zodOpenapi.z.enum(GenderZod).optional(),
-  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  employer: zodOpenapi.z.string().optional(),
-  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  registeredNumber: zodOpenapi.z.string().optional(),
-  isPep: zodOpenapi.z.boolean().optional(),
-  titleBefore: zodOpenapi.z.string().optional(),
-  titleAfter: zodOpenapi.z.string().optional(),
-  birthSurname: zodOpenapi.z.string().optional(),
-  vocativeTitle: zodOpenapi.z.string().optional(),
-  deathDate: zodOpenapi.z.date().optional(),
-  deathNotification: zodOpenapi.z.date().optional(),
-  pin: zodOpenapi.z.string().optional(),
-  stayAbroad: zodOpenapi.z.boolean().optional(),
-  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
-});
-const individualOutputSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid().nullable(),
-  internalId: zodOpenapi.z.string().nullable(),
-  name: zodOpenapi.z.string(),
-  surname: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().nullable(),
-  phone: zodOpenapi.z.string().nullable(),
-  birthDate: zodOpenapi.z.string().nullable(),
-  birthPlace: zodOpenapi.z.string(),
-  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  personalId: zodOpenapi.z.uuid(),
-  gender: zodOpenapi.z.enum(GenderZod),
-  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  employer: zodOpenapi.z.string().nullable(),
-  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  registeredNumber: zodOpenapi.z.string(),
-  isPep: zodOpenapi.z.boolean(),
-  titleBefore: zodOpenapi.z.string().nullable(),
-  titleAfter: zodOpenapi.z.string().nullable(),
-  birthSurname: zodOpenapi.z.string().nullable(),
-  vocativeTitle: zodOpenapi.z.string().nullable(),
-  deathDate: zodOpenapi.z.coerce.date().nullable(),
-  deathNotification: zodOpenapi.z.coerce.date().nullable(),
-  pin: zodOpenapi.z.string().nullable(),
-  stayAbroad: zodOpenapi.z.boolean().nullable(),
-  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  createdAt: zodOpenapi.z.coerce.date().nullable(),
-  updatedAt: zodOpenapi.z.coerce.date().nullable()
-});
-
-zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid().optional(),
-  internalId: zodOpenapi.z.string().optional(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.email("Invalid email format").optional(),
-  phone: zodOpenapi.z.string().optional(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number().optional(),
-  prosecuted: zodOpenapi.z.string().optional(),
-  location: zodOpenapi.z.string().optional(),
-  fileNumber: zodOpenapi.z.string().optional(),
-  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional(),
-  vatPayer: zodOpenapi.z.boolean(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessTypes: zodOpenapi.z.string().optional()
-});
-const organizationUpdateSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid().optional(),
-  internalId: zodOpenapi.z.string().optional(),
-  businessName: zodOpenapi.z.string().optional(),
-  email: zodOpenapi.z.email("Invalid email format").optional(),
-  phone: zodOpenapi.z.string().optional(),
-  registeredNumber: zodOpenapi.z.string().optional(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  monthlyVolumeIn: zodOpenapi.z.number().optional(),
-  monthlyVolumeOut: zodOpenapi.z.number().optional(),
-  ownedBy: zodOpenapi.z.string().optional(),
-  companyObjects: zodOpenapi.z.string().optional(),
-  annualTurnover: zodOpenapi.z.number().optional(),
-  numberOfEmployees: zodOpenapi.z.number().optional(),
-  prosecuted: zodOpenapi.z.string().optional(),
-  location: zodOpenapi.z.string().optional(),
-  fileNumber: zodOpenapi.z.string().optional(),
-  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional(),
-  vatPayer: zodOpenapi.z.boolean().optional(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessTypes: zodOpenapi.z.string().optional()
-});
-zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().nullable(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().nullable(),
-  phone: zodOpenapi.z.string().nullable(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number().nullable(),
-  prosecuted: zodOpenapi.z.string().nullable(),
-  location: zodOpenapi.z.string().nullable(),
-  fileNumber: zodOpenapi.z.string().nullable(),
-  websiteUrl: zodOpenapi.z.string().nullable(),
-  vatPayer: zodOpenapi.z.boolean(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessTypes: zodOpenapi.z.string().nullable(),
-  createdAt: zodOpenapi.z.coerce.date().nullable(),
-  updatedAt: zodOpenapi.z.coerce.date().nullable()
-});
-const createOrganizationInputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid().optional(),
-  internalId: zodOpenapi.z.string().optional(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().optional(),
-  phone: zodOpenapi.z.string().optional(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number(),
-  prosecuted: zodOpenapi.z.string().optional(),
-  location: zodOpenapi.z.string().optional(),
-  fileNumber: zodOpenapi.z.string().optional(),
-  websiteUrl: zodOpenapi.z.string().optional(),
-  vatPayer: zodOpenapi.z.boolean(),
-  message: zodOpenapi.z.string(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessTypes: zodOpenapi.z.string().optional()
-});
-const createOrganizationOutputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().nullable(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().nullable(),
-  phone: zodOpenapi.z.string().nullable(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number().nullable(),
-  prosecuted: zodOpenapi.z.string().nullable(),
-  location: zodOpenapi.z.string().nullable(),
-  fileNumber: zodOpenapi.z.string().nullable(),
-  websiteUrl: zodOpenapi.z.string().nullable(),
-  vatPayer: zodOpenapi.z.boolean(),
-  message: zodOpenapi.z.string().nullable(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessTypes: zodOpenapi.z.string().nullable()
-});
-
-const disponentSchema = zodOpenapi.z.discriminatedUnion("partyType", [
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
-    data: individualInsertSchema
-  }),
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("ORGANIZATION"),
-    data: createOrganizationInputSchema
-  })
-]);
-const disponentUpdateSchema = zodOpenapi.z.discriminatedUnion("partyType", [
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
-    data: individualUpdateSchema
-  }),
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("ORGANIZATION"),
-    data: organizationUpdateSchema
-  })
-]);
-const disponentOutputSchema = zodOpenapi.z.discriminatedUnion("partyType", [
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
-    data: individualOutputSchema.nullable()
-  }),
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("ORGANIZATION"),
-    data: createOrganizationOutputSchema.nullable()
-  })
-]);
-
-const entityKind = Symbol.for("drizzle:entityKind");
-function is(value, type) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (value instanceof type) {
-    return true;
-  }
-  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
-    throw new Error(
-      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
-    );
-  }
-  let cls = Object.getPrototypeOf(value).constructor;
-  if (cls) {
-    while (cls) {
-      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
-        return true;
-      }
-      cls = Object.getPrototypeOf(cls);
-    }
-  }
-  return false;
-}
+const entityKind = Symbol.for("drizzle:entityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(
+      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
 
 class Column {
   constructor(table, config) {
@@ -560,7 +330,7 @@ class ColumnBuilder {
 const TableName = Symbol.for("drizzle:Name");
 
 const isPgEnumSym = Symbol.for("drizzle:isPgEnum");
-function isPgEnum(obj) {
+function isPgEnum$1(obj) {
   return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
 }
 
@@ -645,6 +415,9 @@ class Table {
     this[BaseName] = baseName;
   }
 }
+function isTable(table) {
+  return typeof table === "object" && table !== null && IsDrizzleTable in table;
+}
 
 function isSQLWrapper(value) {
   return value !== null && value !== void 0 && typeof value.getSQL === "function";
@@ -806,7 +579,7 @@ class SQL {
           new Name(chunk._.alias)
         ], config);
       }
-      if (isPgEnum(chunk)) {
+      if (isPgEnum$1(chunk)) {
         if (chunk.schema) {
           return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
         }
@@ -1006,6 +779,9 @@ class View {
     return new SQL([this]);
   }
 }
+function isView(view) {
+  return typeof view === "object" && view !== null && IsDrizzleView in view;
+}
 Column.prototype.getSQL = function() {
   return new SQL([this]);
 };
@@ -1016,13 +792,19 @@ Subquery.prototype.getSQL = function() {
   return new SQL([this]);
 };
 
+function getTableColumns(table) {
+  return table[Table.Symbol.Columns];
+}
+function getViewSelectedFields(view) {
+  return view[ViewBaseConfig].selectedFields;
+}
 function getColumnNameAndConfig(a, b) {
   return {
     name: typeof a === "string" && a.length > 0 ? a : "",
     config: typeof a === "object" ? a : b
   };
 }
-typeof TextDecoder === "undefined" ? null : new TextDecoder();
+const textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
 
 class ForeignKeyBuilder {
   static [entityKind] = "SQLiteForeignKeyBuilder";
@@ -1134,6 +916,141 @@ class SQLiteColumn extends Column {
   static [entityKind] = "SQLiteColumn";
 }
 
+class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+}
+class SQLiteBigInt extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return BigInt(buf.toString("utf8"));
+    }
+    return BigInt(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+}
+class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobJson(
+      table,
+      this.config
+    );
+  }
+}
+class SQLiteBlobJson extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return JSON.parse(buf.toString("utf8"));
+    }
+    return JSON.parse(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+}
+class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+}
+class SQLiteBlobBuffer extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  mapFromDriverValue(value) {
+    if (Buffer.isBuffer(value)) {
+      return value;
+    }
+    return Buffer.from(value);
+  }
+  getSQLType() {
+    return "blob";
+  }
+}
+function blob(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "json") {
+    return new SQLiteBlobJsonBuilder(name);
+  }
+  if (config?.mode === "bigint") {
+    return new SQLiteBigIntBuilder(name);
+  }
+  return new SQLiteBlobBufferBuilder(name);
+}
+
+class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteCustomColumn(
+      table,
+      this.config
+    );
+  }
+}
+class SQLiteCustomColumn extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+}
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(
+      name,
+      config,
+      customTypeParams
+    );
+  };
+}
+
 class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteBaseIntegerBuilder";
   constructor(name, dataType, columnType) {
@@ -1242,6 +1159,100 @@ function integer(a, b) {
   return new SQLiteIntegerBuilder(name);
 }
 
+class SQLiteNumericBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumeric(
+      table,
+      this.config
+    );
+  }
+}
+class SQLiteNumeric extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  mapFromDriverValue(value) {
+    if (typeof value === "string") return value;
+    return String(value);
+  }
+  getSQLType() {
+    return "numeric";
+  }
+}
+class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericNumberBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteNumericNumber");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericNumber(
+      table,
+      this.config
+    );
+  }
+}
+class SQLiteNumericNumber extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericNumber";
+  mapFromDriverValue(value) {
+    if (typeof value === "number") return value;
+    return Number(value);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteNumericBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericBigInt(
+      table,
+      this.config
+    );
+  }
+}
+class SQLiteNumericBigInt extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+function numeric(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  const mode = config?.mode;
+  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
+}
+
+class SQLiteRealBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteReal");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+}
+class SQLiteReal extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+}
+function real(name) {
+  return new SQLiteRealBuilder(name ?? "");
+}
+
 class SQLiteTextBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteTextBuilder";
   constructor(name, config) {
@@ -1301,54 +1312,399 @@ function text(a, b = {}) {
   return new SQLiteTextBuilder(name, config);
 }
 
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text
+  };
+}
+
+const InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
+class SQLiteTable extends Table {
+  static [entityKind] = "SQLiteTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  /** @internal */
+  [Table.Symbol.Columns];
+  /** @internal */
+  [InlineForeignKeys] = [];
+  /** @internal */
+  [Table.Symbol.ExtraConfigBuilder] = void 0;
+}
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new SQLiteTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(
+    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+      const colBuilder = colBuilderBase;
+      colBuilder.setName(name2);
+      const column = colBuilder.build(rawTable);
+      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+      return [name2, column];
+    })
+  );
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  return table;
+}
+const sqliteTable = (name, columns, extraConfig) => {
+  return sqliteTableBase(name, columns);
+};
+
+const CONSTANTS = {
+    INT8_MIN: -128,
+    INT8_MAX: 127,
+    INT8_UNSIGNED_MAX: 255,
+    INT16_MIN: -32768,
+    INT16_MAX: 32767,
+    INT16_UNSIGNED_MAX: 65535,
+    INT24_MIN: -8388608,
+    INT24_MAX: 8388607,
+    INT24_UNSIGNED_MAX: 16777215,
+    INT32_MIN: -2147483648,
+    INT32_MAX: 2147483647,
+    INT32_UNSIGNED_MAX: 4294967295,
+    INT48_MIN: -140737488355328,
+    INT48_MAX: 140737488355327,
+    INT48_UNSIGNED_MAX: 281474976710655,
+    INT64_MIN: -9223372036854775808n,
+    INT64_MAX: 9223372036854775807n,
+    INT64_UNSIGNED_MAX: 18446744073709551615n,
+};
+
+function isColumnType(column, columnTypes) {
+    return columnTypes.includes(column.columnType);
+}
+function isWithEnum(column) {
+    return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
+}
+const isPgEnum = isWithEnum;
+
 const literalSchema = v4.z.union([v4.z.string(), v4.z.number(), v4.z.boolean(), v4.z.null()]);
-v4.z.union([
+const jsonSchema = v4.z.union([
     literalSchema,
     v4.z.record(v4.z.string(), v4.z.any()),
     v4.z.array(v4.z.any()),
 ]);
-v4.z.custom((v) => v instanceof Buffer); // eslint-disable-line no-instanceof/no-instanceof
-
-var esprima$1 = {exports: {}};
-
-var esprima = esprima$1.exports;
-
-var hasRequiredEsprima;
-
-function requireEsprima () {
-	if (hasRequiredEsprima) return esprima$1.exports;
-	hasRequiredEsprima = 1;
-	(function (module, exports$1) {
-		(function webpackUniversalModuleDefinition(root, factory) {
-		/* istanbul ignore next */
-			module.exports = factory();
-		})(esprima, function() {
-		return /******/ (function(modules) { // webpackBootstrap
-		/******/ 	// The module cache
-		/******/ 	var installedModules = {};
-
-		/******/ 	// The require function
-		/******/ 	function __webpack_require__(moduleId) {
-
-		/******/ 		// Check if module is in cache
-		/* istanbul ignore if */
-		/******/ 		if(installedModules[moduleId])
-		/******/ 			return installedModules[moduleId].exports;
-
-		/******/ 		// Create a new module (and put it into the cache)
-		/******/ 		var module = installedModules[moduleId] = {
-		/******/ 			exports: {},
-		/******/ 			id: moduleId,
-		/******/ 			loaded: false
-		/******/ 		};
-
-		/******/ 		// Execute the module function
-		/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-
-		/******/ 		// Flag the module as loaded
-		/******/ 		module.loaded = true;
-
-		/******/ 		// Return the exports of the module
+const bufferSchema = v4.z.custom((v) => v instanceof Buffer); // eslint-disable-line no-instanceof/no-instanceof
+function columnToSchema(column, factory) {
+    const z$1 = v4.z;
+    const coerce = {};
+    let schema;
+    if (isWithEnum(column)) {
+        schema = column.enumValues.length ? z$1.enum(column.enumValues) : z$1.string();
+    }
+    if (!schema) {
+        // Handle specific types
+        if (isColumnType(column, ['PgGeometry', 'PgPointTuple'])) {
+            schema = z$1.tuple([z$1.number(), z$1.number()]);
+        }
+        else if (isColumnType(column, ['PgGeometryObject', 'PgPointObject'])) {
+            schema = z$1.object({ x: z$1.number(), y: z$1.number() });
+        }
+        else if (isColumnType(column, ['PgHalfVector', 'PgVector'])) {
+            schema = z$1.array(z$1.number());
+            schema = column.dimensions ? schema.length(column.dimensions) : schema;
+        }
+        else if (isColumnType(column, ['PgLine'])) {
+            schema = z$1.tuple([z$1.number(), z$1.number(), z$1.number()]);
+        }
+        else if (isColumnType(column, ['PgLineABC'])) {
+            schema = z$1.object({
+                a: z$1.number(),
+                b: z$1.number(),
+                c: z$1.number(),
+            });
+        } // Handle other types
+        else if (isColumnType(column, ['PgArray'])) {
+            schema = z$1.array(columnToSchema(column.baseColumn));
+            schema = column.size ? schema.length(column.size) : schema;
+        }
+        else if (column.dataType === 'array') {
+            schema = z$1.array(z$1.any());
+        }
+        else if (column.dataType === 'number') {
+            schema = numberColumnToSchema(column, z$1, coerce);
+        }
+        else if (column.dataType === 'bigint') {
+            schema = bigintColumnToSchema(column, z$1, coerce);
+        }
+        else if (column.dataType === 'boolean') {
+            schema = coerce === true || coerce.boolean ? z$1.coerce.boolean() : z$1.boolean();
+        }
+        else if (column.dataType === 'date') {
+            schema = coerce === true || coerce.date ? z$1.coerce.date() : z$1.date();
+        }
+        else if (column.dataType === 'string') {
+            schema = stringColumnToSchema(column, z$1, coerce);
+        }
+        else if (column.dataType === 'json') {
+            schema = jsonSchema;
+        }
+        else if (column.dataType === 'custom') {
+            schema = z$1.any();
+        }
+        else if (column.dataType === 'buffer') {
+            schema = bufferSchema;
+        }
+    }
+    if (!schema) {
+        schema = z$1.any();
+    }
+    return schema;
+}
+function numberColumnToSchema(column, z, coerce) {
+    let unsigned = column.getSQLType().includes('unsigned');
+    let min;
+    let max;
+    let integer = false;
+    if (isColumnType(column, ['MySqlTinyInt', 'SingleStoreTinyInt'])) {
+        min = unsigned ? 0 : CONSTANTS.INT8_MIN;
+        max = unsigned ? CONSTANTS.INT8_UNSIGNED_MAX : CONSTANTS.INT8_MAX;
+        integer = true;
+    }
+    else if (isColumnType(column, [
+        'PgSmallInt',
+        'PgSmallSerial',
+        'MySqlSmallInt',
+        'SingleStoreSmallInt',
+    ])) {
+        min = unsigned ? 0 : CONSTANTS.INT16_MIN;
+        max = unsigned ? CONSTANTS.INT16_UNSIGNED_MAX : CONSTANTS.INT16_MAX;
+        integer = true;
+    }
+    else if (isColumnType(column, [
+        'PgReal',
+        'MySqlFloat',
+        'MySqlMediumInt',
+        'SingleStoreMediumInt',
+        'SingleStoreFloat',
+    ])) {
+        min = unsigned ? 0 : CONSTANTS.INT24_MIN;
+        max = unsigned ? CONSTANTS.INT24_UNSIGNED_MAX : CONSTANTS.INT24_MAX;
+        integer = isColumnType(column, ['MySqlMediumInt', 'SingleStoreMediumInt']);
+    }
+    else if (isColumnType(column, [
+        'PgInteger',
+        'PgSerial',
+        'MySqlInt',
+        'SingleStoreInt',
+    ])) {
+        min = unsigned ? 0 : CONSTANTS.INT32_MIN;
+        max = unsigned ? CONSTANTS.INT32_UNSIGNED_MAX : CONSTANTS.INT32_MAX;
+        integer = true;
+    }
+    else if (isColumnType(column, [
+        'PgDoublePrecision',
+        'MySqlReal',
+        'MySqlDouble',
+        'SingleStoreReal',
+        'SingleStoreDouble',
+        'SQLiteReal',
+    ])) {
+        min = unsigned ? 0 : CONSTANTS.INT48_MIN;
+        max = unsigned ? CONSTANTS.INT48_UNSIGNED_MAX : CONSTANTS.INT48_MAX;
+    }
+    else if (isColumnType(column, [
+        'PgBigInt53',
+        'PgBigSerial53',
+        'MySqlBigInt53',
+        'MySqlSerial',
+        'SingleStoreBigInt53',
+        'SingleStoreSerial',
+        'SQLiteInteger',
+    ])) {
+        unsigned = unsigned || isColumnType(column, ['MySqlSerial', 'SingleStoreSerial']);
+        min = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
+        max = Number.MAX_SAFE_INTEGER;
+        integer = true;
+    }
+    else if (isColumnType(column, ['MySqlYear', 'SingleStoreYear'])) {
+        min = 1901;
+        max = 2155;
+        integer = true;
+    }
+    else {
+        min = Number.MIN_SAFE_INTEGER;
+        max = Number.MAX_SAFE_INTEGER;
+    }
+    let schema = coerce === true || coerce?.number
+        ? integer ? z.coerce.number() : z.coerce.number().int()
+        : integer
+            ? z.int()
+            : z.number();
+    schema = schema.gte(min).lte(max);
+    return schema;
+}
+function bigintColumnToSchema(column, z, coerce) {
+    const unsigned = column.getSQLType().includes('unsigned');
+    const min = unsigned ? 0n : CONSTANTS.INT64_MIN;
+    const max = unsigned ? CONSTANTS.INT64_UNSIGNED_MAX : CONSTANTS.INT64_MAX;
+    const schema = coerce === true || coerce?.bigint ? z.coerce.bigint() : z.bigint();
+    return schema.gte(min).lte(max);
+}
+function stringColumnToSchema(column, z, coerce) {
+    if (isColumnType(column, ['PgUUID'])) {
+        return z.uuid();
+    }
+    let max;
+    let regex;
+    let fixed = false;
+    if (isColumnType(column, ['PgVarchar', 'SQLiteText'])) {
+        max = column.length;
+    }
+    else if (isColumnType(column, ['MySqlVarChar', 'SingleStoreVarChar'])) {
+        max = column.length ?? CONSTANTS.INT16_UNSIGNED_MAX;
+    }
+    else if (isColumnType(column, ['MySqlText', 'SingleStoreText'])) {
+        if (column.textType === 'longtext') {
+            max = CONSTANTS.INT32_UNSIGNED_MAX;
+        }
+        else if (column.textType === 'mediumtext') {
+            max = CONSTANTS.INT24_UNSIGNED_MAX;
+        }
+        else if (column.textType === 'text') {
+            max = CONSTANTS.INT16_UNSIGNED_MAX;
+        }
+        else {
+            max = CONSTANTS.INT8_UNSIGNED_MAX;
+        }
+    }
+    if (isColumnType(column, [
+        'PgChar',
+        'MySqlChar',
+        'SingleStoreChar',
+    ])) {
+        max = column.length;
+        fixed = true;
+    }
+    if (isColumnType(column, ['PgBinaryVector'])) {
+        regex = /^[01]+$/;
+        max = column.dimensions;
+    }
+    let schema = coerce === true || coerce?.string ? z.coerce.string() : z.string();
+    schema = regex ? schema.regex(regex) : schema;
+    return max && fixed ? schema.length(max) : max ? schema.max(max) : schema;
+}
+
+function getColumns(tableLike) {
+    return isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
+}
+function handleColumns(columns, refinements, conditions, factory) {
+    const columnSchemas = {};
+    for (const [key, selected] of Object.entries(columns)) {
+        if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+            const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+            columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
+            continue;
+        }
+        const refinement = refinements[key];
+        if (refinement !== undefined && typeof refinement !== 'function') {
+            columnSchemas[key] = refinement;
+            continue;
+        }
+        const column = is(selected, Column) ? selected : undefined;
+        const schema = column ? columnToSchema(column) : v4.z.any();
+        const refined = typeof refinement === 'function' ? refinement(schema) : schema;
+        if (conditions.never(column)) {
+            continue;
+        }
+        else {
+            columnSchemas[key] = refined;
+        }
+        if (column) {
+            if (conditions.nullable(column)) {
+                columnSchemas[key] = columnSchemas[key].nullable();
+            }
+            if (conditions.optional(column)) {
+                columnSchemas[key] = columnSchemas[key].optional();
+            }
+        }
+    }
+    return v4.z.object(columnSchemas);
+}
+function handleEnum(enum_, factory) {
+    const zod = v4.z;
+    return zod.enum(enum_.enumValues);
+}
+const selectConditions = {
+    never: () => false,
+    optional: () => false,
+    nullable: (column) => !column.notNull,
+};
+const insertConditions = {
+    never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
+    optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+    nullable: (column) => !column.notNull,
+};
+const updateConditions = {
+    never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
+    optional: () => true,
+    nullable: (column) => !column.notNull,
+};
+const createSelectSchema = (entity, refine) => {
+    if (isPgEnum(entity)) {
+        return handleEnum(entity);
+    }
+    const columns = getColumns(entity);
+    return handleColumns(columns, {}, selectConditions);
+};
+const createInsertSchema = (entity, refine) => {
+    const columns = getColumns(entity);
+    return handleColumns(columns, {}, insertConditions);
+};
+const createUpdateSchema = (entity, refine) => {
+    const columns = getColumns(entity);
+    return handleColumns(columns, {}, updateConditions);
+};
+
+var esprima$1 = {exports: {}};
+
+var esprima = esprima$1.exports;
+
+var hasRequiredEsprima;
+
+function requireEsprima () {
+	if (hasRequiredEsprima) return esprima$1.exports;
+	hasRequiredEsprima = 1;
+	(function (module, exports$1) {
+		(function webpackUniversalModuleDefinition(root, factory) {
+		/* istanbul ignore next */
+			module.exports = factory();
+		})(esprima, function() {
+		return /******/ (function(modules) { // webpackBootstrap
+		/******/ 	// The module cache
+		/******/ 	var installedModules = {};
+
+		/******/ 	// The require function
+		/******/ 	function __webpack_require__(moduleId) {
+
+		/******/ 		// Check if module is in cache
+		/* istanbul ignore if */
+		/******/ 		if(installedModules[moduleId])
+		/******/ 			return installedModules[moduleId].exports;
+
+		/******/ 		// Create a new module (and put it into the cache)
+		/******/ 		var module = installedModules[moduleId] = {
+		/******/ 			exports: {},
+		/******/ 			id: moduleId,
+		/******/ 			loaded: false
+		/******/ 		};
+
+		/******/ 		// Execute the module function
+		/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+		/******/ 		// Flag the module as loaded
+		/******/ 		module.loaded = true;
+
+		/******/ 		// Return the exports of the module
 		/******/ 		return module.exports;
 		/******/ 	}
 
@@ -11745,7 +12101,7 @@ SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJS
 SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
 SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
 
-({
+const base = {
   id: text("id").primaryKey(),
   createdAt: integer("created_at", { mode: "timestamp_ms" }).default(
     sql`(unixepoch('subsec') * 1000)`
@@ -11755,9 +12111,9 @@ SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(Super
   updatedBy: text("updated_by").default(sql`null`),
   deletedAt: integer("deleted_at", { mode: "timestamp_ms" }).default(sql`null`),
   deletedBy: text("deleted_by").default(sql`null`)
-});
+};
 
-({
+const bankAccount$1 = {
   holderName: text("holder_name").notNull(),
   number: text("number"),
   bankCode: text("bank_code", { enum: generalCodes.BANK_CODES }),
@@ -11777,144 +12133,1396 @@ SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(Super
   // Australia
   brBankNumber: text("br_bank_number")
   // Brazil
-});
+};
 
 const ibanSchema = zod.z.string().min(1).regex(/^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}$/, {
   message: "Invalid IBAN format"
 });
-const bicSchema = zod.z.string().min(1).regex(/^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/, {
-  message: "Invalid SWIFT/BIC format"
+const bicSchema = zod.z.string().min(1).regex(/^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/, {
+  message: "Invalid SWIFT/BIC format"
+});
+const bankAccountMetadataSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  number: zod.z.string().optional(),
+  bankCode: zod.z.enum(generalCodes.BANK_CODES).optional(),
+  holderName: zod.z.string().optional(),
+  iban: ibanSchema.optional(),
+  address: zod.z.string().optional(),
+  swiftBic: bicSchema.optional(),
+  bicCor: bicSchema.optional(),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES).optional(),
+  countryCode: zod.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  routingNumber: zod.z.string().optional(),
+  // US
+  sortCode: zod.z.string().optional(),
+  // UK
+  clabe: zod.z.string().optional(),
+  // Mexico
+  bsb: zod.z.string().optional(),
+  // Australia
+  brBankNumber: zod.z.string().optional()
+  // Brazil
+});
+
+zod.z.object({
+  status: zod.z.enum([
+    "queued",
+    // means that instance is waiting to be started (see concurrency limits)
+    "running",
+    "paused",
+    "errored",
+    "terminated",
+    // user terminated the instance while it was running
+    "complete",
+    "waiting",
+    // instance is hibernating and waiting for sleep or event to finish
+    "waitingForPause",
+    // instance is finishing the current work to pause
+    "unknown"
+  ]),
+  error: zod.z.object({
+    message: zod.z.string(),
+    name: zod.z.string().optional()
+  }).optional(),
+  output: zod.z.unknown().optional()
+});
+
+new z__namespace.$ZodObject({
+  type: "object",
+  shape: {
+    page: new z__namespace.$ZodDefault({
+      type: "default",
+      innerType: new z__namespace.$ZodNumber({
+        type: "number",
+        coerce: true
+      }),
+      defaultValue: () => 1
+    }),
+    limit: new z__namespace.$ZodDefault({
+      type: "default",
+      innerType: new z__namespace.$ZodNumber({
+        type: "number",
+        coerce: true
+      }),
+      defaultValue: () => 20
+    }),
+    sort: new z__namespace.$ZodDefault({
+      type: "default",
+      innerType: new z__namespace.$ZodObject({
+        type: "object",
+        shape: {
+          column: new z__namespace.$ZodDefault({
+            type: "default",
+            innerType: new z__namespace.$ZodEnum({
+              type: "enum",
+              entries: {
+                createdAt: "createdAt",
+                updatedAt: "updatedAt",
+                deletedAt: "deletedAt"
+              }
+            }),
+            defaultValue: () => "updatedAt"
+          }),
+          direction: new z__namespace.$ZodDefault({
+            type: "default",
+            innerType: new z__namespace.$ZodEnum({
+              type: "enum",
+              entries: {
+                asc: "asc",
+                desc: "desc"
+              }
+            }),
+            defaultValue: () => "desc"
+          })
+        }
+      }),
+      defaultValue: () => ({ column: "updatedAt", direction: "desc" })
+    })
+  }
+});
+new z__namespace.$ZodObject({
+  type: "object",
+  shape: {
+    page: new z__namespace.$ZodNumber({
+      type: "number"
+    }),
+    limit: new z__namespace.$ZodNumber({
+      type: "number"
+    }),
+    sort: new z__namespace.$ZodObject({
+      type: "object",
+      shape: {
+        column: new z__namespace.$ZodEnum({
+          type: "enum",
+          entries: {
+            createdAt: "createdAt",
+            updatedAt: "updatedAt",
+            deletedAt: "deletedAt"
+          }
+        }),
+        direction: new z__namespace.$ZodEnum({
+          type: "enum",
+          entries: {
+            asc: "asc",
+            desc: "desc"
+          }
+        })
+      }
+    })
+  }
+});
+
+const baseMdmSqlite = {
+  ...base
+};
+
+const party = sqliteTable("party", {
+  ...base,
+  internalId: text("internal_id"),
+  note: text("note"),
+  customerStatus: text("customer_status", {
+    enum: CustomerStatusZod
+  }).notNull(),
+  partyType: text("party_type", { enum: PartyTypeZod }).notNull(),
+  language: text("language", { enum: generalCodes.LANGUAGE_CODES }).notNull(),
+  countryCode: text("country_code", { enum: generalCodes.COUNTRY_CODES_2 }),
+  isClient: integer("is_client", { mode: "boolean" }).notNull().default(false),
+  legacyId: text("legacy_id")
+});
+
+const address = sqliteTable("address", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().references(() => party.id),
+  ruianCode: text("ruian_code"),
+  addressType: text("address_type", { enum: AddressTypeZod }).notNull(),
+  street: text("street"),
+  orientationNumber: text("orientation_number"),
+  descriptiveNumber: text("descriptive_number"),
+  municipality: text("municipality").notNull(),
+  municipalityPart: text("municipality_part"),
+  zipCode: text("zip_code").notNull(),
+  district: text("district"),
+  region: text("region"),
+  countryCode: text("state", { enum: generalCodes.COUNTRY_CODES_2 }).notNull()
+});
+
+const contact = sqliteTable("contact", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().references(() => party.id),
+  contactType: text("contact_type", { enum: ContactTypeZod }),
+  email: text("email").notNull(),
+  phoneNumber: text("phone_number").notNull()
+});
+
+const idDocument = sqliteTable("id_document", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().references(() => party.id),
+  idDocType: text("id_doc_type", { enum: IdDocTypeZod }).notNull(),
+  idDocNumber: text("id_doc_number").notNull(),
+  idDocHolderName: text("id_doc_holder_name").notNull(),
+  issueDate: integer("issue_date", { mode: "timestamp_ms" }),
+  expirationDate: integer("expiration_date", { mode: "timestamp_ms" }),
+  issuer: text("issuer"),
+  countryOfIssue: text("country_of_issue", { enum: generalCodes.COUNTRY_CODES_2 }),
+  frontImageUri: text("front_image_uri"),
+  backImageUri: text("back_image_uri"),
+  idDocStatus: text("id_doc_status", { enum: IdDocStatusZod })
+});
+
+const individual = sqliteTable("individual", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().unique().references(() => party.id),
+  name: text("name").notNull(),
+  email: text("email"),
+  phone: text("phone"),
+  surname: text("surname").notNull(),
+  birthDate: text("birth_date"),
+  birthPlace: text("birth_place").notNull(),
+  countryOfBirth: text("country_of_birth", { enum: generalCodes.COUNTRY_CODES_2 }),
+  personalId: text("personal_id").notNull(),
+  gender: text("gender", { enum: GenderZod }).notNull(),
+  citizenship: text("citizenship", { enum: generalCodes.COUNTRY_CODES_2 }).notNull(),
+  citizenshipOther: text("citizenship_other", { enum: generalCodes.COUNTRY_CODES_2 }),
+  employer: text("employer"),
+  employerCountry: text("employer_country", { enum: generalCodes.COUNTRY_CODES_2 }),
+  registeredNumber: text("registered_number").notNull(),
+  isPep: integer("is_pep", { mode: "boolean" }).notNull(),
+  titleBefore: text("title_before"),
+  titleAfter: text("title_after"),
+  birthSurname: text("birth_surname"),
+  vocativeTitle: text("vocative_title"),
+  deathDate: integer("death_date", { mode: "timestamp_ms" }),
+  deathNotification: integer("death_notification", { mode: "timestamp_ms" }),
+  pin: text("pin"),
+  stayAbroad: integer("stay_abroad", { mode: "boolean" }),
+  stayAbroadCountries: text("stay_abroad_countries", {
+    enum: generalCodes.COUNTRY_CODES_2
+  })
+});
+
+const organization = sqliteTable("organization", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().unique().references(() => party.id),
+  businessName: text("business_name").notNull(),
+  email: text("email"),
+  phone: text("phone"),
+  registeredNumber: text("registered_number").notNull(),
+  registeredIn: text("registered_in", { enum: generalCodes.COUNTRY_CODES_2 }).notNull(),
+  operatesIn: text("operates_in", { enum: generalCodes.COUNTRY_CODES_2 }).notNull(),
+  presentIn: text("present_in", { enum: generalCodes.COUNTRY_CODES_2 }).notNull(),
+  monthlyVolumeIn: integer("monthly_volume_in").notNull(),
+  monthlyVolumeOut: integer("monthly_volume_out").notNull(),
+  ownedBy: text("owned_by").notNull(),
+  // UBO, skutecny majitel, podle Marianovy tabulky by toto mela byt mozna relace na party
+  companyObjects: text("company_objects").notNull(),
+  // predmet cinnosti
+  companyObjectsDescription: text("company_objects_description").notNull(),
+  turnover3years: integer("turnover_3_years").notNull(),
+  operationCountries: text("operation_countries").notNull(),
+  annualTurnover: integer("annual_turnover").notNull(),
+  riskyBusinessType: text("risky_business_type"),
+  numberOfEmployees: integer("number_of_employees"),
+  prosecuted: text("prosecuted"),
+  // vedeno u soudu
+  location: text("location"),
+  // v lokalite
+  fileNumber: text("file_number"),
+  // spisova znacka
+  websiteUrl: text("website_url"),
+  vatPayer: integer("vat_payer", { mode: "boolean" }).notNull(),
+  stayAbroad: integer("stay_abroad", { mode: "boolean" }),
+  stayAbroadCountries: text("stay_abroad_countries", {
+    enum: generalCodes.COUNTRY_CODES_2
+  })
+});
+
+const partyRelationship = sqliteTable("party_relationship", {
+  ...base,
+  internalId: text("internal_id"),
+  relationshipType: text("relationship_type", {
+    enum: PartyRelationshipTypeZod
+  }),
+  fromPartyId: text("from_party_id").references(() => party.id),
+  toPartyId: text("to_party_id").references(() => party.id),
+  fromDate: integer("from_date", { mode: "timestamp_ms" }),
+  // FIXME: Treba se doptat https://develitio.slack.com/archives/C09VAF0G70E/p1769766644943189
+  // viz
+  //   - Celé pole `owner[]`
+  //  - `titleBefore`, `firstName`, `lastName`, `titleAfter`
+  //  - `dateOfBirth`, `idNumber`, `address`
+  //  - `sharePercentage`
+  //  - `dateOfEstablishmentOfShare`
+  //  - `pep`
+  sharePercentage: integer("share_percentage")
+});
+
+const taxResidence = sqliteTable("tax_residence", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().unique().references(() => party.id),
+  country: text("country", { enum: generalCodes.COUNTRY_CODES_2 }).notNull(),
+  taxIdentificationNumber: text("tax_identification_number").notNull()
+});
+
+const partyChange = sqliteTable("party_change", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().references(() => party.id),
+  operation: text("operation").notNull(),
+  diff: text("diff", { mode: "json" }).notNull(),
+  snapshotBefore: text("snapshot_before", { mode: "json" }).notNull(),
+  snapshotAfter: text("snapshot_after", { mode: "json" }).notNull()
+});
+
+const bankAccount = sqliteTable("bank_account", {
+  ...base,
+  internalId: text("internal_id"),
+  ...bankAccount$1,
+  partyId: text("party_id").notNull().references(() => party.id)
+});
+
+const aml = sqliteTable("aml", {
+  ...base,
+  internalId: text("internal_id"),
+  partyId: text("party_id").notNull().unique().references(() => party.id),
+  sourceOfWealth: text("source_of_wealth").notNull(),
+  yearlyIncome: text("yearly_income").notNull(),
+  tradesPurpose: text("trades_purpose"),
+  sourceOfIncome: text("source_of_income").notNull(),
+  transactionType: text("transaction_type"),
+  transactionTypeExpiry: integer("transaction_type_expiry", {
+    mode: "timestamp_ms"
+  }),
+  estTxsVolumeMonth: text("est_txs_volume_month").notNull(),
+  estTxsVolumeYear: text("est_txs_volume_year").notNull(),
+  tradingCountries: text("trading_countries").notNull(),
+  tradingSide: text("trading_side").notNull(),
+  acceptedAMLTermsAndConditions: integer("accepted_aml_terms_and_conditions", {
+    mode: "boolean"
+  }).notNull(),
+  signatureMethod: text("signature_method"),
+  existencePeriod: text("existence_period"),
+  reputation: text("reputation"),
+  isDistraint: integer("is_distraint", { mode: "boolean" }).notNull().default(false),
+  riskLevel: text("risk_level", { enum: AmlScoreTypeZod }).notNull(),
+  kycStatus: text("kyc_status", { enum: KycStatusZod })
+});
+
+const recipient = sqliteTable("recipient", {
+  ...base,
+  internalId: text("internal_id"),
+  ...bankAccount$1,
+  partyId: text("party_id").notNull().references(() => party.id)
+});
+
+const trader = sqliteTable("trader", {
+  ...base,
+  internalId: text("internal_id"),
+  type: text("trader", { length: 50, enum: TRADER_TYPE }).$type().notNull(),
+  firstName: text("first_name", { length: 255 }),
+  lastName: text("last_name", { length: 255 }),
+  companyName: text("company_name", { length: 255 }),
+  ico: text("ico", { length: 255 }),
+  dic: text("dic", { length: 255 }),
+  commission: real("commission").notNull(),
+  legacyId: text("legacy_id")
+});
+
+sqliteTable("trader_client", {
+  ...base,
+  clientId: text("client_id").references(() => party.id),
+  traderId: text("trader_id").references(() => trader.id),
+  internalId: text("internal_id"),
+  legacyId: text("legacy_id")
+});
+
+sqliteTable("base", baseMdmSqlite);
+
+createInsertSchema(address);
+createUpdateSchema(address);
+createSelectSchema(address);
+const addressInsertSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid().optional(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  ruianCode: zodOpenapi.z.string().optional().nullable(),
+  addressType: zodOpenapi.z.enum(AddressTypeZod),
+  street: zodOpenapi.z.string().optional().nullable(),
+  orientationNumber: zodOpenapi.z.string().optional().nullable(),
+  descriptiveNumber: zodOpenapi.z.string().optional().nullable(),
+  municipality: zodOpenapi.z.string(),
+  municipalityPart: zodOpenapi.z.string().optional().nullable(),
+  zipCode: zodOpenapi.z.string(),
+  district: zodOpenapi.z.string().optional().nullable(),
+  region: zodOpenapi.z.string().optional().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2)
+});
+const addressUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  ruianCode: zodOpenapi.z.string().optional().nullable(),
+  addressType: zodOpenapi.z.enum(AddressTypeZod).optional(),
+  street: zodOpenapi.z.string().optional().nullable(),
+  orientationNumber: zodOpenapi.z.string().optional().nullable(),
+  descriptiveNumber: zodOpenapi.z.string().optional().nullable(),
+  municipality: zodOpenapi.z.string().optional(),
+  municipalityPart: zodOpenapi.z.string().optional().nullable(),
+  zipCode: zodOpenapi.z.string().optional(),
+  district: zodOpenapi.z.string().optional().nullable(),
+  region: zodOpenapi.z.string().optional().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  createdAt: zodOpenapi.z.coerce.date().nullable().optional()
+});
+const addressSelectSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  ruianCode: zodOpenapi.z.string().nullable(),
+  addressType: zodOpenapi.z.enum(AddressTypeZod),
+  street: zodOpenapi.z.string().nullable(),
+  orientationNumber: zodOpenapi.z.string().nullable(),
+  descriptiveNumber: zodOpenapi.z.string().nullable(),
+  municipality: zodOpenapi.z.string(),
+  municipalityPart: zodOpenapi.z.string().nullable(),
+  zipCode: zodOpenapi.z.string(),
+  district: zodOpenapi.z.string().nullable(),
+  region: zodOpenapi.z.string().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  createdAt: zodOpenapi.z.coerce.date().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable()
+});
+
+createInsertSchema(aml);
+createUpdateSchema(aml);
+const amlBaseSelectSchema = createSelectSchema(aml);
+const amlInsertSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  sourceOfWealth: zodOpenapi.z.string(),
+  yearlyIncome: zodOpenapi.z.string(),
+  tradesPurpose: zodOpenapi.z.string().optional().nullable(),
+  sourceOfIncome: zodOpenapi.z.string(),
+  transactionType: zodOpenapi.z.string().optional().nullable(),
+  transactionTypeExpiry: zodOpenapi.z.date().optional().nullable(),
+  isDistraint: zodOpenapi.z.boolean().default(false),
+  estTxsVolumeMonth: zodOpenapi.z.string(),
+  estTxsVolumeYear: zodOpenapi.z.string(),
+  tradingCountries: zodOpenapi.z.string(),
+  tradingSide: zodOpenapi.z.string(),
+  acceptedAMLTermsAndConditions: zodOpenapi.z.boolean(),
+  signatureMethod: zodOpenapi.z.string().nullable().optional(),
+  existencePeriod: zodOpenapi.z.string().nullable().optional(),
+  reputation: zodOpenapi.z.string().nullable().optional(),
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).nullable().optional(),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod).nullable().optional()
+});
+const amlUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  sourceOfWealth: zodOpenapi.z.string().optional(),
+  yearlyIncome: zodOpenapi.z.string().optional(),
+  tradesPurpose: zodOpenapi.z.string().optional().nullable(),
+  sourceOfIncome: zodOpenapi.z.string().optional(),
+  transactionType: zodOpenapi.z.string().optional().nullable(),
+  transactionTypeExpiry: zodOpenapi.z.date().optional().nullable(),
+  isDistraint: zodOpenapi.z.boolean().optional(),
+  estTxsVolumeMonth: zodOpenapi.z.string(),
+  estTxsVolumeYear: zodOpenapi.z.string(),
+  tradingCountries: zodOpenapi.z.string(),
+  tradingSide: zodOpenapi.z.string(),
+  acceptedAMLTermsAndConditions: zodOpenapi.z.boolean(),
+  signatureMethod: zodOpenapi.z.string().nullable().optional(),
+  existencePeriod: zodOpenapi.z.string().nullable().optional(),
+  reputation: zodOpenapi.z.string().nullable().optional(),
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).nullable().optional(),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod).nullable().optional()
+});
+const amlSelectSchema = amlBaseSelectSchema;
+
+const bankAccountBaseInsertSchema = createInsertSchema(bankAccount);
+createUpdateSchema(bankAccount);
+createSelectSchema(bankAccount);
+const bankAccountUpdateSchema = bankAccountBaseInsertSchema.extend({ partyId: zodOpenapi.z.uuid() }).omit({});
+const bankAccountInsertSchema = bankAccountUpdateSchema.omit({
+  id: true
+});
+const bankAccountUpsertSchema = bankAccountBaseInsertSchema.required({
+  id: true
+});
+const bankAccountSelectSchema = bankAccountUpdateSchema.required();
+zodOpenapi.z.array(bankAccountSelectSchema);
+
+createInsertSchema(contact);
+createUpdateSchema(contact);
+createSelectSchema(contact);
+const contactInsertSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  contactType: zodOpenapi.z.enum(ContactTypeZod).optional(),
+  email: zodOpenapi.z.email("Invalid email format"),
+  phoneNumber: zodOpenapi.z.string()
+});
+const contactUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  contactType: zodOpenapi.z.enum(ContactTypeZod).optional(),
+  email: zodOpenapi.z.email("Invalid email format").optional(),
+  phoneNumber: zodOpenapi.z.string().optional()
+});
+
+createInsertSchema(individual);
+createUpdateSchema(individual);
+createSelectSchema(individual);
+const individualInsertSchema$1 = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  name: zodOpenapi.z.string(),
+  surname: zodOpenapi.z.string(),
+  email: zodOpenapi.z.email("Invalid email format").optional().nullable(),
+  phone: zodOpenapi.z.string().optional().nullable(),
+  birthDate: zodOpenapi.z.string().optional().nullable(),
+  birthPlace: zodOpenapi.z.string(),
+  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  personalId: zodOpenapi.z.string(),
+  gender: zodOpenapi.z.enum(GenderZod),
+  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  employer: zodOpenapi.z.string().optional().nullable(),
+  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  isPep: zodOpenapi.z.boolean(),
+  titleBefore: zodOpenapi.z.string().optional().nullable(),
+  titleAfter: zodOpenapi.z.string().optional().nullable(),
+  birthSurname: zodOpenapi.z.string().optional().nullable(),
+  vocativeTitle: zodOpenapi.z.string().optional().nullable(),
+  deathDate: zodOpenapi.z.date().optional().nullable(),
+  deathNotification: zodOpenapi.z.date().optional().nullable(),
+  pin: zodOpenapi.z.string().optional().nullable(),
+  stayAbroad: zodOpenapi.z.boolean().optional().nullable(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable()
+});
+const individualUpdateSchema$1 = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  id: zodOpenapi.z.uuid(),
+  name: zodOpenapi.z.string().optional(),
+  surname: zodOpenapi.z.string().optional(),
+  email: zodOpenapi.z.email("Invalid email format").optional().nullable(),
+  phone: zodOpenapi.z.string().optional().nullable(),
+  birthDate: zodOpenapi.z.string().optional().nullable(),
+  birthPlace: zodOpenapi.z.string().optional(),
+  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  personalId: zodOpenapi.z.string().optional(),
+  gender: zodOpenapi.z.enum(GenderZod).optional(),
+  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  employer: zodOpenapi.z.string().optional().nullable(),
+  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  registeredNumber: zodOpenapi.z.string().optional(),
+  isPep: zodOpenapi.z.boolean().optional(),
+  titleBefore: zodOpenapi.z.string().optional().nullable(),
+  titleAfter: zodOpenapi.z.string().optional().nullable(),
+  birthSurname: zodOpenapi.z.string().optional().nullable(),
+  vocativeTitle: zodOpenapi.z.string().optional().nullable(),
+  deathDate: zodOpenapi.z.date().optional().nullable(),
+  deathNotification: zodOpenapi.z.date().optional().nullable(),
+  pin: zodOpenapi.z.string().optional().nullable(),
+  stayAbroad: zodOpenapi.z.boolean().optional().nullable(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable()
+});
+const individualSelectSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  name: zodOpenapi.z.string(),
+  surname: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().nullable(),
+  phone: zodOpenapi.z.string().nullable(),
+  birthDate: zodOpenapi.z.string().nullable(),
+  birthPlace: zodOpenapi.z.string(),
+  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  personalId: zodOpenapi.z.string(),
+  gender: zodOpenapi.z.enum(GenderZod),
+  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  employer: zodOpenapi.z.string().nullable(),
+  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  isPep: zodOpenapi.z.boolean(),
+  titleBefore: zodOpenapi.z.string().nullable(),
+  titleAfter: zodOpenapi.z.string().nullable(),
+  birthSurname: zodOpenapi.z.string().nullable(),
+  vocativeTitle: zodOpenapi.z.string().nullable(),
+  deathDate: zodOpenapi.z.coerce.date().nullable(),
+  deathNotification: zodOpenapi.z.coerce.date().nullable(),
+  pin: zodOpenapi.z.string().nullable(),
+  stayAbroad: zodOpenapi.z.boolean().nullable(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  createdAt: zodOpenapi.z.coerce.date().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable()
+});
+
+createInsertSchema(organization);
+createUpdateSchema(organization);
+createSelectSchema(organization);
+const organizationInsertSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  businessName: zodOpenapi.z.string(),
+  email: zodOpenapi.z.email("Invalid email format").optional().nullable(),
+  phone: zodOpenapi.z.string().optional().nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  monthlyVolumeIn: zodOpenapi.z.number(),
+  monthlyVolumeOut: zodOpenapi.z.number(),
+  ownedBy: zodOpenapi.z.string(),
+  companyObjects: zodOpenapi.z.string(),
+  annualTurnover: zodOpenapi.z.number(),
+  numberOfEmployees: zodOpenapi.z.number().optional().nullable(),
+  prosecuted: zodOpenapi.z.string().optional().nullable(),
+  location: zodOpenapi.z.string().optional().nullable(),
+  fileNumber: zodOpenapi.z.string().optional().nullable(),
+  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional().nullable(),
+  vatPayer: zodOpenapi.z.boolean(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().optional().nullable()
+});
+const organizationUpdateSchema$1 = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid().optional(),
+  id: zodOpenapi.z.uuid(),
+  businessName: zodOpenapi.z.string().optional(),
+  email: zodOpenapi.z.email("Invalid email format").optional().nullable(),
+  phone: zodOpenapi.z.string().optional().nullable(),
+  registeredNumber: zodOpenapi.z.string().optional(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  monthlyVolumeIn: zodOpenapi.z.number().optional(),
+  monthlyVolumeOut: zodOpenapi.z.number().optional(),
+  ownedBy: zodOpenapi.z.string().optional(),
+  companyObjects: zodOpenapi.z.string().optional(),
+  annualTurnover: zodOpenapi.z.number().optional(),
+  numberOfEmployees: zodOpenapi.z.number().optional().nullable(),
+  prosecuted: zodOpenapi.z.string().optional().nullable(),
+  location: zodOpenapi.z.string().optional().nullable(),
+  fileNumber: zodOpenapi.z.string().optional().nullable(),
+  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional().nullable(),
+  vatPayer: zodOpenapi.z.boolean().optional(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().optional().nullable()
+});
+const organizationOutputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  businessName: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().nullable(),
+  phone: zodOpenapi.z.string().nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  monthlyVolumeIn: zodOpenapi.z.number(),
+  monthlyVolumeOut: zodOpenapi.z.number(),
+  ownedBy: zodOpenapi.z.string(),
+  companyObjects: zodOpenapi.z.string(),
+  annualTurnover: zodOpenapi.z.number(),
+  numberOfEmployees: zodOpenapi.z.number().nullable(),
+  prosecuted: zodOpenapi.z.string().nullable(),
+  location: zodOpenapi.z.string().nullable(),
+  fileNumber: zodOpenapi.z.string().nullable(),
+  websiteUrl: zodOpenapi.z.string().nullable(),
+  vatPayer: zodOpenapi.z.boolean(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().nullable(),
+  stayAbroad: zodOpenapi.z.boolean().nullable(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  createdAt: zodOpenapi.z.coerce.date().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable()
+});
+const organizationSelectSchema = organizationOutputSchema;
+zodOpenapi.z.array(organizationOutputSchema);
+
+zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualInsertSchema$1
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: organizationInsertSchema
+  })
+]);
+const disponentCreateSchema = zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualInsertSchema$1.omit({ partyId: true })
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: organizationInsertSchema.omit({ partyId: true })
+  })
+]);
+const disponentUpdateSchema$1 = zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualUpdateSchema$1
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: organizationUpdateSchema$1
+  })
+]);
+const disponentSelectSchema = zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualSelectSchema
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: organizationSelectSchema
+  })
+]);
+zodOpenapi.z.array(disponentSelectSchema).optional();
+zodOpenapi.z.array(disponentUpdateSchema$1).optional();
+
+createInsertSchema(idDocument);
+createUpdateSchema(idDocument);
+createSelectSchema(idDocument);
+const idDocumentInsertSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  idDocType: zodOpenapi.z.enum(IdDocTypeZod),
+  idDocNumber: zodOpenapi.z.string(),
+  idDocHolderName: zodOpenapi.z.string(),
+  issueDate: zodOpenapi.z.date().optional().nullable(),
+  expirationDate: zodOpenapi.z.date().optional().nullable(),
+  issuer: zodOpenapi.z.string().optional().nullable(),
+  countryOfIssue: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  frontImageUri: zodOpenapi.z.url().optional().nullable(),
+  backImageUri: zodOpenapi.z.url().optional().nullable(),
+  idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).optional().nullable()
+});
+const idDocumentUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  idDocType: zodOpenapi.z.enum(IdDocTypeZod).optional(),
+  idDocNumber: zodOpenapi.z.string().optional(),
+  idDocHolderName: zodOpenapi.z.string().optional(),
+  issueDate: zodOpenapi.z.date().optional().nullable(),
+  expirationDate: zodOpenapi.z.date().optional().nullable(),
+  issuer: zodOpenapi.z.string().optional().nullable(),
+  countryOfIssue: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
+  frontImageUri: zodOpenapi.z.url("Invalid URL format").optional().nullable(),
+  backImageUri: zodOpenapi.z.url("Invalid URL format").optional().nullable(),
+  idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).optional().nullable()
+});
+
+const recipientBaseInsertSchema = createInsertSchema(recipient);
+createUpdateSchema(recipient);
+createSelectSchema(recipient);
+const recipientUpsertSchema = recipientBaseInsertSchema.required({
+  id: true
+});
+const recipientInsertSchema = bankAccountInsertSchema;
+const recipientUpdateSchema = bankAccountUpdateSchema;
+const recipientSelectSchema = bankAccountSelectSchema;
+
+createInsertSchema(party);
+createUpdateSchema(party);
+const partySchema$1 = zodOpenapi.z.object({
+  partyType: zodOpenapi.z.enum(PartyTypeZod),
+  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+  id: zodOpenapi.z.uuid().nullable(),
+  note: zodOpenapi.z.string().optional(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  customerStatus: zodOpenapi.z.enum(CustomerStatusZod).optional(),
+  legacyId: zodOpenapi.z.string().optional()
+});
+const partyOutputSchema$1 = zodOpenapi.z.object({
+  internalId: zodOpenapi.z.string().nullable(),
+  customerStatus: zodOpenapi.z.enum(CustomerStatusZod),
+  partyType: zodOpenapi.z.enum(PartyTypeZod),
+  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+  id: zodOpenapi.z.uuid(),
+  note: zodOpenapi.z.string().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  isClient: zodOpenapi.z.boolean(),
+  createdAt: zodOpenapi.z.date().nullable(),
+  updatedAt: zodOpenapi.z.date().nullable()
+});
+const createPartySchema = partySchema$1.omit({ id: true });
+zodOpenapi.z.object({
+  party: createPartySchema,
+  personalData: individualInsertSchema$1.omit({ partyId: true }).nullable(),
+  organizationData: organizationInsertSchema.omit({ partyId: true }).nullable(),
+  bankAccounts: zodOpenapi.z.array(bankAccountInsertSchema.omit({ partyId: true })).nullable(),
+  recipients: zodOpenapi.z.array(recipientInsertSchema.omit({ partyId: true })).nullable(),
+  disponents: zodOpenapi.z.array(disponentCreateSchema).nullable(),
+  addresses: zodOpenapi.z.array(addressInsertSchema.omit({ partyId: true })),
+  aml: amlInsertSchema.omit({ partyId: true })
+});
+zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  party: partySchema$1,
+  personalData: individualUpdateSchema$1.optional(),
+  organizationData: organizationUpdateSchema$1.optional(),
+  bankAccounts: zodOpenapi.z.array(bankAccountUpsertSchema).optional(),
+  recipients: zodOpenapi.z.array(recipientUpsertSchema).optional(),
+  disponents: zodOpenapi.z.array(disponentUpdateSchema$1).optional(),
+  addresses: zodOpenapi.z.array(addressUpdateSchema).optional(),
+  aml: amlUpdateSchema.optional()
+});
+const partySelectOutputSchema = zodOpenapi.z.object({
+  party: partyOutputSchema$1.nullable(),
+  personalData: individualSelectSchema.nullable(),
+  organizationData: organizationSelectSchema.nullable(),
+  aml: amlSelectSchema.nullable(),
+  bankAccounts: zodOpenapi.z.array(bankAccountSelectSchema).nullable(),
+  disponents: zodOpenapi.z.array(disponentSelectSchema).nullable(),
+  addresses: zodOpenapi.z.array(addressSelectSchema).nullable(),
+  recipients: zodOpenapi.z.array(recipientSelectSchema).nullable()
+});
+zodOpenapi.z.array(partySelectOutputSchema);
+const partySelectDataSchema = zodOpenapi.z.object({
+  party: partyOutputSchema$1.nullable(),
+  personalData: individualSelectSchema.nullable(),
+  organizationData: organizationSelectSchema.nullable(),
+  aml: amlSelectSchema.nullable()
+});
+const partySelectArrayDataSchema = zodOpenapi.z.object({
+  bankAccounts: zodOpenapi.z.array(bankAccountSelectSchema).nullable(),
+  addresses: zodOpenapi.z.array(addressSelectSchema).nullable(),
+  disponents: zodOpenapi.z.array(disponentSelectSchema).nullable(),
+  recipients: zodOpenapi.z.array(recipientSelectSchema).nullable()
+});
+zodOpenapi.z.object({
+  ...partySelectDataSchema.shape,
+  ...partySelectArrayDataSchema.shape
+});
+
+createInsertSchema(partyChange);
+createUpdateSchema(partyChange);
+createSelectSchema(partyChange);
+zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid().optional().nullable(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  operation: zodOpenapi.z.string(),
+  diff: zodOpenapi.z.json(),
+  snapshotBefore: zodOpenapi.z.json(),
+  snapshotAfter: zodOpenapi.z.json()
+});
+zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional().nullable(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  operation: zodOpenapi.z.string().optional(),
+  diff: zodOpenapi.z.json().optional(),
+  snapshotBefore: zodOpenapi.z.json().optional(),
+  snapshotAfter: zodOpenapi.z.json().optional()
+});
+
+createInsertSchema(partyRelationship);
+createUpdateSchema(partyRelationship);
+createSelectSchema(partyRelationship);
+zodOpenapi.z.object({
+  relationshipType: zodOpenapi.z.enum(PartyRelationshipTypeZod).optional(),
+  frompartyId: zodOpenapi.z.uuid().optional().nullable(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  topartyId: zodOpenapi.z.uuid().optional().nullable(),
+  fromDate: zodOpenapi.z.date().optional().nullable(),
+  sharePercentage: zodOpenapi.z.number().max(100).optional().nullable()
+});
+zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  relationshipType: zodOpenapi.z.enum(PartyRelationshipTypeZod).optional(),
+  frompartyId: zodOpenapi.z.uuid().optional().nullable(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
+  topartyId: zodOpenapi.z.uuid().optional().nullable(),
+  fromDate: zodOpenapi.z.date().optional().nullable(),
+  sharePercentage: zodOpenapi.z.number().max(100).optional().nullable()
+});
+
+createInsertSchema(taxResidence);
+createUpdateSchema(taxResidence);
+createSelectSchema(taxResidence);
+zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  country: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  taxIdentificationNumber: zodOpenapi.z.string()
+});
+zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  country: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  taxIdentificationNumber: zodOpenapi.z.string().optional()
+});
+
+createInsertSchema(trader);
+createUpdateSchema(trader);
+createSelectSchema(trader);
+const traderInsertSchema = zodOpenapi.z.object({
+  type: zodOpenapi.z.enum(TRADER_TYPE),
+  commission: zodOpenapi.z.number(),
+  firstName: zodOpenapi.z.string().optional(),
+  lastName: zodOpenapi.z.string().optional(),
+  companyName: zodOpenapi.z.string().optional(),
+  ico: zodOpenapi.z.string().optional(),
+  dic: zodOpenapi.z.string().optional(),
+  legacyId: zodOpenapi.z.string().optional()
+});
+const traderUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  type: zodOpenapi.z.enum(TRADER_TYPE).optional(),
+  commission: zodOpenapi.z.number().optional(),
+  internalId: zodOpenapi.z.string().optional(),
+  firstName: zodOpenapi.z.string().optional(),
+  lastName: zodOpenapi.z.string().optional(),
+  companyName: zodOpenapi.z.string().optional(),
+  ico: zodOpenapi.z.string().optional(),
+  dic: zodOpenapi.z.string().optional(),
+  legacyId: zodOpenapi.z.string().optional()
+});
+zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  createdAt: zodOpenapi.z.coerce.date().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable(),
+  deletedAt: zodOpenapi.z.coerce.date().nullable(),
+  type: zodOpenapi.z.enum(TRADER_TYPE),
+  commission: zodOpenapi.z.number(),
+  internalId: zodOpenapi.z.string().nullable(),
+  firstName: zodOpenapi.z.string().nullable(),
+  lastName: zodOpenapi.z.string().nullable(),
+  companyName: zodOpenapi.z.string().nullable(),
+  ico: zodOpenapi.z.string().nullable(),
+  dic: zodOpenapi.z.string().nullable(),
+  legacyId: zodOpenapi.z.string().nullable()
+});
+
+zod.z.object({
+  recipient: recipientInsertSchema,
+  partyId: zod.z.string().uuid()
+});
+
+zod.z.object({
+  recipient: recipientUpdateSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+const ALLOWED_RECIPIENTS_FILTERS = {
+  NAME: "filterRecipientName",
+  BANK_CODE: "filterRecipientBankCode",
+  CURRENCY: "filterRecipientCurrency"
+};
+zod.z.object({
+  page: zod.z.number().positive(),
+  limit: zod.z.number().positive(),
+  sort: zod.z.object({
+    column: zod.z.string(),
+    direction: zod.z.enum(["asc", "desc"])
+  }),
+  [ALLOWED_RECIPIENTS_FILTERS.NAME]: zod.z.union([zod.z.string(), zod.z.string().array()]).optional(),
+  [ALLOWED_RECIPIENTS_FILTERS.BANK_CODE]: zod.z.union([zod.z.enum(generalCodes.BANK_CODES), zod.z.enum(generalCodes.BANK_CODES).array()]).optional(),
+  [ALLOWED_RECIPIENTS_FILTERS.CURRENCY]: zod.z.union([zod.z.enum(generalCodes.CURRENCY_CODES), zod.z.enum(generalCodes.CURRENCY_CODES).array()]).optional(),
+  search: zod.z.string().optional()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  trader: traderInsertSchema
+});
+
+zod.z.object({
+  trader: traderUpdateSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  page: zod.z.number().positive(),
+  limit: zod.z.number().positive(),
+  sort: zod.z.object({
+    column: zod.z.string(),
+    direction: zod.z.enum(["asc", "desc"])
+  }),
+  search: zod.z.string().optional(),
+  ids: zod.z.array(zod.z.uuid()).optional()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  traderId: zod.z.uuid(),
+  clientId: zod.z.uuid()
+});
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  bankAccount: bankAccountInsertSchema,
+  partyId: zod.z.string().uuid()
+});
+
+zod.z.object({
+  bankAccount: bankAccountUpsertSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  address: addressInsertSchema,
+  partyId: zod.z.uuid()
+});
+
+zod.z.object({
+  address: addressUpdateSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  contact: contactInsertSchema,
+  partyId: zod.z.string().uuid()
+});
+
+zod.z.object({
+  contact: contactUpdateSchema
+});
+
+zod.z.object({
+  idDocument: idDocumentInsertSchema,
+  partyId: zod.z.string()
+});
+
+zod.z.object({
+  idDocument: idDocumentUpdateSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+const ALLOWED_ID_DOCUMENTS_FILTERS = {
+  PARTY_ID: "filterIdDocumentPartyId",
+  ISSUER: "filterIdDocumentIssuer"
+};
+zod.z.object({
+  pagination: zod.z.object({
+    page: zod.z.number().positive(),
+    limit: zod.z.number().positive(),
+    sort: zod.z.object({
+      column: zod.z.string(),
+      direction: zod.z.enum(["asc", "desc"])
+    }),
+    [ALLOWED_ID_DOCUMENTS_FILTERS.PARTY_ID]: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
+    [ALLOWED_ID_DOCUMENTS_FILTERS.ISSUER]: zod.z.union([zod.z.string(), zod.z.string().array()]).optional(),
+    search: zod.z.string().optional()
+  })
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  organization: organizationInsertSchema
+});
+
+zod.z.object({
+  organization: organizationInsertSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  individual: individualInsertSchema$1
+});
+
+zod.z.object({
+  individual: individualInsertSchema$1
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+zod.z.object({
+  aml: amlInsertSchema
+});
+
+zod.z.object({
+  aml: amlInsertSchema
+});
+
+zod.z.object({
+  id: zod.z.uuid()
+});
+
+const individualInsertSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  name: zodOpenapi.z.string(),
+  surname: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().optional(),
+  phone: zodOpenapi.z.string().optional(),
+  birthDate: zodOpenapi.z.string().optional(),
+  birthPlace: zodOpenapi.z.string(),
+  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  personalId: zodOpenapi.z.string(),
+  gender: zodOpenapi.z.enum(GenderZod),
+  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  employer: zodOpenapi.z.string().optional(),
+  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  registeredNumber: zodOpenapi.z.string(),
+  isPep: zodOpenapi.z.boolean(),
+  titleBefore: zodOpenapi.z.string().optional(),
+  titleAfter: zodOpenapi.z.string().optional(),
+  birthSurname: zodOpenapi.z.string().optional(),
+  vocativeTitle: zodOpenapi.z.string().optional(),
+  deathDate: zodOpenapi.z.date().optional(),
+  deathNotification: zodOpenapi.z.date().optional(),
+  pin: zodOpenapi.z.string().optional(),
+  stayAbroad: zodOpenapi.z.boolean().optional(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
+});
+const individualUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  name: zodOpenapi.z.string().optional(),
+  surname: zodOpenapi.z.string().optional(),
+  email: zodOpenapi.z.string().optional(),
+  phone: zodOpenapi.z.string().optional(),
+  birthDate: zodOpenapi.z.string().optional(),
+  birthPlace: zodOpenapi.z.string().optional(),
+  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  personalId: zodOpenapi.z.string().optional(),
+  gender: zodOpenapi.z.enum(GenderZod).optional(),
+  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  employer: zodOpenapi.z.string().optional(),
+  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  registeredNumber: zodOpenapi.z.string().optional(),
+  isPep: zodOpenapi.z.boolean().optional(),
+  titleBefore: zodOpenapi.z.string().optional(),
+  titleAfter: zodOpenapi.z.string().optional(),
+  birthSurname: zodOpenapi.z.string().optional(),
+  vocativeTitle: zodOpenapi.z.string().optional(),
+  deathDate: zodOpenapi.z.date().optional(),
+  deathNotification: zodOpenapi.z.date().optional(),
+  pin: zodOpenapi.z.string().optional(),
+  stayAbroad: zodOpenapi.z.boolean().optional(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
+});
+const individualOutputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  name: zodOpenapi.z.string(),
+  surname: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().nullable(),
+  phone: zodOpenapi.z.string().nullable(),
+  birthDate: zodOpenapi.z.string().nullable(),
+  birthPlace: zodOpenapi.z.string(),
+  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  personalId: zodOpenapi.z.string(),
+  gender: zodOpenapi.z.enum(GenderZod),
+  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  employer: zodOpenapi.z.string().nullable(),
+  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  isPep: zodOpenapi.z.boolean(),
+  titleBefore: zodOpenapi.z.string().nullable(),
+  titleAfter: zodOpenapi.z.string().nullable(),
+  birthSurname: zodOpenapi.z.string().nullable(),
+  vocativeTitle: zodOpenapi.z.string().nullable(),
+  deathDate: zodOpenapi.z.coerce.date().nullable(),
+  deathNotification: zodOpenapi.z.coerce.date().nullable(),
+  pin: zodOpenapi.z.string().nullable(),
+  stayAbroad: zodOpenapi.z.boolean().nullable(),
+  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  createdAt: zodOpenapi.z.coerce.date().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable()
+});
+
+zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  businessName: zodOpenapi.z.string(),
+  email: zodOpenapi.z.email("Invalid email format").optional(),
+  phone: zodOpenapi.z.string().optional(),
+  registeredNumber: zodOpenapi.z.string(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  monthlyVolumeIn: zodOpenapi.z.number(),
+  monthlyVolumeOut: zodOpenapi.z.number(),
+  ownedBy: zodOpenapi.z.string(),
+  companyObjects: zodOpenapi.z.string(),
+  annualTurnover: zodOpenapi.z.number(),
+  numberOfEmployees: zodOpenapi.z.number().optional(),
+  prosecuted: zodOpenapi.z.string().optional(),
+  location: zodOpenapi.z.string().optional(),
+  fileNumber: zodOpenapi.z.string().optional(),
+  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional(),
+  vatPayer: zodOpenapi.z.boolean(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().optional()
+});
+const organizationUpdateSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  internalId: zodOpenapi.z.string().optional(),
+  businessName: zodOpenapi.z.string().optional(),
+  email: zodOpenapi.z.email("Invalid email format").optional(),
+  phone: zodOpenapi.z.string().optional(),
+  registeredNumber: zodOpenapi.z.string().optional(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  monthlyVolumeIn: zodOpenapi.z.number().optional(),
+  monthlyVolumeOut: zodOpenapi.z.number().optional(),
+  ownedBy: zodOpenapi.z.string().optional(),
+  companyObjects: zodOpenapi.z.string().optional(),
+  annualTurnover: zodOpenapi.z.number().optional(),
+  numberOfEmployees: zodOpenapi.z.number().optional(),
+  prosecuted: zodOpenapi.z.string().optional(),
+  location: zodOpenapi.z.string().optional(),
+  fileNumber: zodOpenapi.z.string().optional(),
+  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional(),
+  vatPayer: zodOpenapi.z.boolean().optional(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().optional()
+});
+zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  businessName: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().nullable(),
+  phone: zodOpenapi.z.string().nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  monthlyVolumeIn: zodOpenapi.z.number(),
+  monthlyVolumeOut: zodOpenapi.z.number(),
+  ownedBy: zodOpenapi.z.string(),
+  companyObjects: zodOpenapi.z.string(),
+  annualTurnover: zodOpenapi.z.number(),
+  numberOfEmployees: zodOpenapi.z.number().nullable(),
+  prosecuted: zodOpenapi.z.string().nullable(),
+  location: zodOpenapi.z.string().nullable(),
+  fileNumber: zodOpenapi.z.string().nullable(),
+  websiteUrl: zodOpenapi.z.string().nullable(),
+  vatPayer: zodOpenapi.z.boolean(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().nullable(),
+  createdAt: zodOpenapi.z.coerce.date().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable()
 });
-const bankAccountMetadataSchema = zod.z.object({
-  id: zod.z.string().optional(),
-  number: zod.z.string().optional(),
-  bankCode: zod.z.enum(generalCodes.BANK_CODES).optional(),
-  holderName: zod.z.string().optional(),
-  iban: ibanSchema.optional(),
-  address: zod.z.string().optional(),
-  swiftBic: bicSchema.optional(),
-  bicCor: bicSchema.optional(),
-  currency: zod.z.enum(generalCodes.CURRENCY_CODES).optional(),
-  countryCode: zod.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  routingNumber: zod.z.string().optional(),
-  // US
-  sortCode: zod.z.string().optional(),
-  // UK
-  clabe: zod.z.string().optional(),
-  // Mexico
-  bsb: zod.z.string().optional(),
-  // Australia
-  brBankNumber: zod.z.string().optional()
-  // Brazil
+const createOrganizationInputSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  businessName: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().optional(),
+  phone: zodOpenapi.z.string().optional(),
+  registeredNumber: zodOpenapi.z.string(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  monthlyVolumeIn: zodOpenapi.z.number(),
+  monthlyVolumeOut: zodOpenapi.z.number(),
+  ownedBy: zodOpenapi.z.string(),
+  companyObjects: zodOpenapi.z.string(),
+  annualTurnover: zodOpenapi.z.number(),
+  numberOfEmployees: zodOpenapi.z.number(),
+  prosecuted: zodOpenapi.z.string().optional(),
+  location: zodOpenapi.z.string().optional(),
+  fileNumber: zodOpenapi.z.string().optional(),
+  websiteUrl: zodOpenapi.z.string().optional(),
+  vatPayer: zodOpenapi.z.boolean(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().optional()
 });
-
-zod.z.object({
-  status: zod.z.enum([
-    "queued",
-    // means that instance is waiting to be started (see concurrency limits)
-    "running",
-    "paused",
-    "errored",
-    "terminated",
-    // user terminated the instance while it was running
-    "complete",
-    "waiting",
-    // instance is hibernating and waiting for sleep or event to finish
-    "waitingForPause",
-    // instance is finishing the current work to pause
-    "unknown"
-  ]),
-  error: zod.z.object({
-    message: zod.z.string(),
-    name: zod.z.string().optional()
-  }).optional(),
-  output: zod.z.unknown().optional()
+const createOrganizationOutputSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  businessName: zodOpenapi.z.string(),
+  email: zodOpenapi.z.string().nullable(),
+  phone: zodOpenapi.z.string().nullable(),
+  registeredNumber: zodOpenapi.z.string(),
+  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
+  monthlyVolumeIn: zodOpenapi.z.number(),
+  monthlyVolumeOut: zodOpenapi.z.number(),
+  ownedBy: zodOpenapi.z.string(),
+  companyObjects: zodOpenapi.z.string(),
+  annualTurnover: zodOpenapi.z.number(),
+  numberOfEmployees: zodOpenapi.z.number().nullable(),
+  prosecuted: zodOpenapi.z.string().nullable(),
+  location: zodOpenapi.z.string().nullable(),
+  fileNumber: zodOpenapi.z.string().nullable(),
+  websiteUrl: zodOpenapi.z.string().nullable(),
+  vatPayer: zodOpenapi.z.boolean(),
+  companyObjectsDescription: zodOpenapi.z.string(),
+  turnover3years: zodOpenapi.z.number(),
+  operationCountries: zodOpenapi.z.string(),
+  riskyBusinessType: zodOpenapi.z.string().nullable()
 });
 
-new z__namespace.$ZodObject({
-  type: "object",
-  shape: {
-    page: new z__namespace.$ZodDefault({
-      type: "default",
-      innerType: new z__namespace.$ZodNumber({
-        type: "number",
-        coerce: true
-      }),
-      defaultValue: () => 1
-    }),
-    limit: new z__namespace.$ZodDefault({
-      type: "default",
-      innerType: new z__namespace.$ZodNumber({
-        type: "number",
-        coerce: true
-      }),
-      defaultValue: () => 20
-    }),
-    sort: new z__namespace.$ZodDefault({
-      type: "default",
-      innerType: new z__namespace.$ZodObject({
-        type: "object",
-        shape: {
-          column: new z__namespace.$ZodDefault({
-            type: "default",
-            innerType: new z__namespace.$ZodEnum({
-              type: "enum",
-              entries: {
-                createdAt: "createdAt",
-                updatedAt: "updatedAt",
-                deletedAt: "deletedAt"
-              }
-            }),
-            defaultValue: () => "updatedAt"
-          }),
-          direction: new z__namespace.$ZodDefault({
-            type: "default",
-            innerType: new z__namespace.$ZodEnum({
-              type: "enum",
-              entries: {
-                asc: "asc",
-                desc: "desc"
-              }
-            }),
-            defaultValue: () => "desc"
-          })
-        }
-      }),
-      defaultValue: () => ({ column: "updatedAt", direction: "desc" })
-    })
-  }
-});
-new z__namespace.$ZodObject({
-  type: "object",
-  shape: {
-    page: new z__namespace.$ZodNumber({
-      type: "number"
-    }),
-    limit: new z__namespace.$ZodNumber({
-      type: "number"
-    }),
-    sort: new z__namespace.$ZodObject({
-      type: "object",
-      shape: {
-        column: new z__namespace.$ZodEnum({
-          type: "enum",
-          entries: {
-            createdAt: "createdAt",
-            updatedAt: "updatedAt",
-            deletedAt: "deletedAt"
-          }
-        }),
-        direction: new z__namespace.$ZodEnum({
-          type: "enum",
-          entries: {
-            asc: "asc",
-            desc: "desc"
-          }
-        })
-      }
-    })
-  }
-});
+const disponentSchema = zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualInsertSchema.omit({ partyId: true })
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: createOrganizationInputSchema.omit({ partyId: true })
+  })
+]);
+const disponentUpdateSchema = zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualUpdateSchema
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: organizationUpdateSchema
+  })
+]);
+const disponentOutputSchema = zodOpenapi.z.discriminatedUnion("partyType", [
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
+    data: individualOutputSchema.nullable()
+  }),
+  zodOpenapi.z.object({
+    partyType: zodOpenapi.z.literal("ORGANIZATION"),
+    data: createOrganizationOutputSchema.nullable()
+  })
+]);
 
 const updateBankAccountSchema = zodOpenapi.z.object({
   ...bankAccountMetadataSchema.shape,
@@ -11933,7 +13541,7 @@ const bankAccountInputSchema = updateBankAccountSchema.required({
 }).omit({ id: true, partyId: true });
 const bankAccountOutputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.string(),
-  partyId: zodOpenapi.z.uuid().nullable(),
+  partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().nullable(),
   holderName: zodOpenapi.z.string(),
   number: zodOpenapi.z.string().nullable(),
@@ -11953,7 +13561,7 @@ const bankAccountOutputSchema = zodOpenapi.z.object({
 });
 
 const createAmlInputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid().optional(),
+  partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().optional(),
   sourceOfWealth: zodOpenapi.z.string(),
   yearlyIncome: zodOpenapi.z.string(),
@@ -11970,8 +13578,8 @@ const createAmlInputSchema = zodOpenapi.z.object({
   signatureMethod: zodOpenapi.z.string().optional(),
   existencePeriod: zodOpenapi.z.string().optional(),
   reputation: zodOpenapi.z.string().optional(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).optional(),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod).optional()
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod$1).optional(),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod$1).optional()
 });
 const updateAmlInputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
@@ -11992,12 +13600,12 @@ const updateAmlInputSchema = zodOpenapi.z.object({
   signatureMethod: zodOpenapi.z.string().optional(),
   existencePeriod: zodOpenapi.z.string().optional(),
   reputation: zodOpenapi.z.string().optional(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).optional(),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod).optional()
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod$1).optional(),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod$1).optional()
 });
 const createAmlOutputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid().nullable(),
+  partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().nullable(),
   sourceOfWealth: zodOpenapi.z.string(),
   yearlyIncome: zodOpenapi.z.string(),
@@ -12014,13 +13622,14 @@ const createAmlOutputSchema = zodOpenapi.z.object({
   signatureMethod: zodOpenapi.z.string().nullable(),
   existencePeriod: zodOpenapi.z.string().nullable(),
   reputation: zodOpenapi.z.string().nullable(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod).nullable(),
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod$1),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod$1).nullable(),
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
 });
 
 const createAddressInputSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
   addressType: zodOpenapi.z.enum(AddressTypeZod),
   internalId: zodOpenapi.z.string().optional(),
   street: zodOpenapi.z.string(),
@@ -12036,7 +13645,7 @@ const createAddressInputSchema = zodOpenapi.z.object({
 });
 const createAddressOutputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid().nullable(),
+  partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().nullable(),
   addressType: zodOpenapi.z.enum(AddressTypeZod),
   street: zodOpenapi.z.string().nullable(),
@@ -12048,7 +13657,6 @@ const createAddressOutputSchema = zodOpenapi.z.object({
   district: zodOpenapi.z.string().nullable(),
   region: zodOpenapi.z.string().nullable(),
   countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  externalId: zodOpenapi.z.uuid().nullable(),
   ruianCode: zodOpenapi.z.string().nullable(),
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
@@ -12102,12 +13710,12 @@ zodOpenapi.z.object({
 });
 const createPartyInputSchema = zodOpenapi.z.object({
   party: partySchema.omit({ id: true }),
-  personalData: individualInsertSchema.nullable(),
-  organizationData: createOrganizationInputSchema.nullable(),
+  personalData: individualInsertSchema.omit({ partyId: true }).nullable(),
+  organizationData: createOrganizationInputSchema.omit({ partyId: true }).nullable(),
   bankAccounts: zodOpenapi.z.array(bankAccountInputSchema),
   disponents: zodOpenapi.z.array(disponentSchema),
-  addresses: zodOpenapi.z.array(createAddressInputSchema),
-  aml: createAmlInputSchema,
+  addresses: zodOpenapi.z.array(createAddressInputSchema.omit({ partyId: true })),
+  aml: createAmlInputSchema.omit({ partyId: true }),
   recipients: zodOpenapi.z.array(bankAccountInputSchema)
 });
 const partyOutputSchema = zodOpenapi.z.object({
@@ -12148,7 +13756,7 @@ const idDocumentOutputSchema = zodOpenapi.z.object({
   createdAt: zodOpenapi.z.iso.datetime().nullable(),
   updatedAt: zodOpenapi.z.iso.datetime().nullable(),
   deletedAt: zodOpenapi.z.iso.datetime().nullable(),
-  partyId: zodOpenapi.z.uuid().nullable(),
+  partyId: zodOpenapi.z.uuid(),
   idDocType: zodOpenapi.z.enum(IdDocTypeZod),
   idDocNumber: zodOpenapi.z.string(),
   idDocHolderName: zodOpenapi.z.string(),
@@ -12200,19 +13808,19 @@ const messageResponseSchema = zodOpenapi.z.object({
 });
 
 exports.AddressTypeZod = AddressTypeZod$1;
-exports.AmlScoreTypeZod = AmlScoreTypeZod;
+exports.AmlScoreTypeZod = AmlScoreTypeZod$1;
 exports.ClientStatusActionZod = ClientStatusActionZod;
-exports.ContactTypeZod = ContactTypeZod;
+exports.ContactTypeZod = ContactTypeZod$1;
 exports.CustomerStatusZod = CustomerStatusZod$1;
 exports.DOCUMENT_SIDE = DOCUMENT_SIDE;
 exports.GenderZod = GenderZod$1;
 exports.IdDocStatusZod = IdDocStatusZod$1;
 exports.IdDocTypeZod = IdDocTypeZod$1;
 exports.IdentificationTypeZod = IdentificationTypeZod;
-exports.KycStatusZod = KycStatusZod;
-exports.PartyRelationshipTypeZod = PartyRelationshipTypeZod;
+exports.KycStatusZod = KycStatusZod$1;
+exports.PartyRelationshipTypeZod = PartyRelationshipTypeZod$1;
 exports.PartyTypeZod = PartyTypeZod$1;
-exports.TRADER_TYPE = TRADER_TYPE;
+exports.TRADER_TYPE = TRADER_TYPE$1;
 exports.createMdmClient = createMdmClient;
 exports.createPartyInputSchema = createPartyInputSchema;
 exports.idDocumentCreateInputSchema = idDocumentCreateInputSchema;