@devizovaburza/mdm-sdk 0.0.11 → 0.0.13

package/dist/v1/index.cjs

@@ -9,6 +9,8 @@ const z = require('zod/v4/core');
 require('node:fs');
 require('node:crypto');
 require('node:path');
+const factory = require('hono/factory');
+const httpException = require('hono/http-exception');
 
 function _interopNamespaceCompat(e) {
   if (e && typeof e === 'object' && 'default' in e) return e;
@@ -33,7 +35,7 @@ const AddressTypeZod$1 = [
   "REGISTERED_OFFICE",
   "CONTACT_ADDRESS"
 ];
-const ContactTypeZod = [
+const ContactTypeZod$1 = [
   "EMAIL",
   "PHONE_AUTH",
   "PHONE_CONTACT",
@@ -46,7 +48,7 @@ const IdDocStatusZod$1 = [
   "EXPIRE_SOON",
   "REVOKED"
 ];
-const PartyRelationshipTypeZod = [
+const PartyRelationshipTypeZod$1 = [
   "AUTHORIZED_SIGNATORY",
   "POA_HOLDER",
   "BOARD_MEMBER",
@@ -74,7 +76,7 @@ const PartyTypeZod$1 = [
   "SELF_EMPLOYED",
   "ORGANIZATION"
 ];
-const AmlScoreTypeZod = [
+const AmlScoreTypeZod$1 = [
   "LOW",
   "MEDIUM",
   "HIGH",
@@ -87,19 +89,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 +115,12 @@ const IdDocStatusZod = [
   "EXPIRE_SOON",
   "REVOKED"
 ];
+const PartyRelationshipTypeZod = [
+  "AUTHORIZED_SIGNATORY",
+  "POA_HOLDER",
+  "BOARD_MEMBER",
+  "UBO"
+];
 const CustomerStatusZod = [
   // 'LEAD',
   "NEW",
@@ -121,289 +135,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 +332,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 +417,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 +581,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 +781,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 +794,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 +918,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 +1161,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,51 +1314,396 @@ 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
+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
@@ -11745,7 +12103,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 +12113,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,7 +12135,7 @@ 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"
@@ -11916,143 +12274,1315 @@ new z__namespace.$ZodObject({
   }
 });
 
-const updateBankAccountSchema = zodOpenapi.z.object({
-  ...bankAccountMetadataSchema.shape,
+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(),
-  holderName: zodOpenapi.z.string(),
-  number: zodOpenapi.z.string().optional(),
-  currency: bankAccountMetadataSchema.shape.currency.nonoptional(),
-  countryCode: bankAccountMetadataSchema.shape.countryCode.nonoptional(),
-  id: bankAccountMetadataSchema.shape.id.nonoptional()
+  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 bankAccountInputSchema = updateBankAccountSchema.required({
-  holderName: true,
-  currency: true,
-  countryCode: true
-}).omit({ id: true, partyId: true });
-const bankAccountOutputSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.string(),
-  partyId: zodOpenapi.z.uuid().nullable(),
+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(),
-  holderName: zodOpenapi.z.string(),
-  number: zodOpenapi.z.string().nullable(),
-  bankCode: zodOpenapi.z.string().nullable(),
-  currency: zodOpenapi.z.string(),
-  countryCode: zodOpenapi.z.string(),
-  iban: zodOpenapi.z.string().nullable(),
-  address: zodOpenapi.z.string().nullable(),
-  swiftBic: zodOpenapi.z.string().nullable(),
-  bicCor: zodOpenapi.z.string().nullable(),
-  routingNumber: zodOpenapi.z.string().nullable(),
-  sortCode: zodOpenapi.z.string().nullable(),
-  clabe: zodOpenapi.z.string().nullable(),
-  bsb: zodOpenapi.z.string().nullable(),
-  brBankNumber: 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()
 });
 
-const createAmlInputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid().optional(),
-  internalId: zodOpenapi.z.string().optional(),
+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(),
+  tradesPurpose: zodOpenapi.z.string().optional().nullable(),
   sourceOfIncome: zodOpenapi.z.string(),
-  transactionType: zodOpenapi.z.string().optional(),
-  transactionTypeExpiry: zodOpenapi.z.date().optional(),
+  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().optional(),
-  existencePeriod: zodOpenapi.z.string().optional(),
-  reputation: zodOpenapi.z.string().optional(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).optional(),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod).optional()
+  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 updateAmlInputSchema = zodOpenapi.z.object({
+const amlUpdateSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
   partyId: zodOpenapi.z.uuid().optional(),
-  internalId: zodOpenapi.z.string().optional(),
+  internalId: zodOpenapi.z.string().optional().nullable(),
   sourceOfWealth: zodOpenapi.z.string().optional(),
   yearlyIncome: zodOpenapi.z.string().optional(),
-  tradesPurpose: zodOpenapi.z.string().optional(),
+  tradesPurpose: zodOpenapi.z.string().optional().nullable(),
   sourceOfIncome: zodOpenapi.z.string().optional(),
-  transactionType: zodOpenapi.z.string().optional(),
-  transactionTypeExpiry: zodOpenapi.z.date().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().optional(),
-  existencePeriod: zodOpenapi.z.string().optional(),
-  reputation: zodOpenapi.z.string().optional(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).optional(),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod).optional()
+  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 createAmlOutputSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid().nullable(),
-  internalId: zodOpenapi.z.string().nullable(),
-  sourceOfWealth: zodOpenapi.z.string(),
-  yearlyIncome: zodOpenapi.z.string(),
-  tradesPurpose: zodOpenapi.z.string().nullable(),
-  sourceOfIncome: zodOpenapi.z.string(),
-  transactionType: zodOpenapi.z.string().nullable(),
-  transactionTypeExpiry: zodOpenapi.z.date().nullable(),
-  isDistraint: zodOpenapi.z.boolean(),
-  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(),
-  existencePeriod: zodOpenapi.z.string().nullable(),
-  reputation: zodOpenapi.z.string().nullable(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod).nullable(),
-  createdAt: zodOpenapi.z.date().nullable(),
-  updatedAt: zodOpenapi.z.date().nullable()
+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);
 
-const createAddressInputSchema = zodOpenapi.z.object({
-  addressType: zodOpenapi.z.enum(AddressTypeZod),
-  internalId: zodOpenapi.z.string().optional(),
-  street: zodOpenapi.z.string(),
-  orientationNumber: zodOpenapi.z.string().optional(),
-  descriptiveNumber: zodOpenapi.z.string().optional(),
-  municipality: zodOpenapi.z.string().max(255),
-  municipalityPart: zodOpenapi.z.string().optional(),
-  zipCode: zodOpenapi.z.string().max(20),
-  district: zodOpenapi.z.string().max(255),
-  region: zodOpenapi.z.string().max(255),
-  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  ruianCode: zodOpenapi.z.string().optional()
+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 createAddressOutputSchema = zodOpenapi.z.object({
+const contactUpdateSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid().nullable(),
-  internalId: 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(),
+  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$2 = 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$2.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$2,
+  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$1 = {
+  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$1.PARTY_ID]: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
+    [ALLOWED_ID_DOCUMENTS_FILTERS$1.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 routeError = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  data: zodOpenapi.z.null(),
+  errorDetail: zodOpenapi.z.object({
+    message: zodOpenapi.z.string(),
+    code: zodOpenapi.z.number()
+  }).optional(),
+  error: zodOpenapi.z.boolean()
+});
+const errorResponse = (entityName, action = "creation") => ({
+  404: {
+    content: {
+      "application/json": {
+        schema: zodOpenapi.z.object({
+          message: zodOpenapi.z.string(),
+          stackTrace: zodOpenapi.z.string().optional()
+        })
+      }
+    },
+    description: `Not Found. This can occur when the ${entityName} is not found.`
+  },
+  500: {
+    content: {
+      "application/json": {
+        schema: zodOpenapi.z.object({
+          message: zodOpenapi.z.string(),
+          stackTrace: zodOpenapi.z.string().optional()
+        })
+      }
+    },
+    description: `Internal Server Error. This can occur when the ${entityName} ${action} fails.`
+  }
+});
+
+const partySchema$1 = zodOpenapi.z.object({
+  partyType: zodOpenapi.z.enum(PartyTypeZod),
+  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+  id: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  note: zodOpenapi.z.string().optional(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
+});
+const individualInsertSchema = zodOpenapi.z.object({
+  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 createOrganizationInputSchema = zodOpenapi.z.object({
+  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()
+});
+const updateBankAccountSchema$1 = zodOpenapi.z.object({
+  ...bankAccountMetadataSchema.shape,
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  holderName: zodOpenapi.z.string(),
+  number: zodOpenapi.z.string().optional(),
+  currency: bankAccountMetadataSchema.shape.currency.nonoptional(),
+  countryCode: bankAccountMetadataSchema.shape.countryCode.nonoptional(),
+  id: bankAccountMetadataSchema.shape.id.nonoptional()
+});
+const bankAccountInputSchema = updateBankAccountSchema$1.required({
+  holderName: true,
+  currency: true,
+  countryCode: true
+}).omit({ id: true, partyId: true });
+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 createAddressInputSchema = zodOpenapi.z.object({
+  addressType: zodOpenapi.z.enum(AddressTypeZod),
+  internalId: zodOpenapi.z.string().optional(),
+  street: zodOpenapi.z.string(),
+  orientationNumber: zodOpenapi.z.string().optional(),
+  descriptiveNumber: zodOpenapi.z.string().optional(),
+  municipality: zodOpenapi.z.string().max(255),
+  municipalityPart: zodOpenapi.z.string().optional(),
+  zipCode: zodOpenapi.z.string().max(20),
+  district: zodOpenapi.z.string().max(255),
+  region: zodOpenapi.z.string().max(255),
   countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  externalId: zodOpenapi.z.uuid().nullable(),
-  ruianCode: zodOpenapi.z.string().nullable(),
+  ruianCode: zodOpenapi.z.string().optional()
+});
+const createAmlInputSchema = zodOpenapi.z.object({
+  internalId: zodOpenapi.z.string().optional(),
+  sourceOfWealth: zodOpenapi.z.string(),
+  yearlyIncome: zodOpenapi.z.string(),
+  tradesPurpose: zodOpenapi.z.string().optional(),
+  sourceOfIncome: zodOpenapi.z.string(),
+  transactionType: zodOpenapi.z.string().optional(),
+  transactionTypeExpiry: zodOpenapi.z.date().optional(),
+  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().optional(),
+  existencePeriod: zodOpenapi.z.string().optional(),
+  reputation: zodOpenapi.z.string().optional(),
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).optional(),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod).optional()
+});
+const createPartyInputSchema = zodOpenapi.z.object({
+  party: partySchema$1.omit({ id: true }),
+  personalData: individualInsertSchema.nullable(),
+  organizationData: createOrganizationInputSchema.nullable(),
+  bankAccounts: zodOpenapi.z.array(bankAccountInputSchema),
+  disponents: zodOpenapi.z.array(disponentSchema),
+  addresses: zodOpenapi.z.array(createAddressInputSchema),
+  aml: createAmlInputSchema,
+  recipients: zodOpenapi.z.array(bankAccountInputSchema)
+});
+const partyCreateOutputSchema = zodOpenapi.z.object({
+  customerStatus: zodOpenapi.z.enum(CustomerStatusZod),
+  partyType: zodOpenapi.z.enum(PartyTypeZod),
+  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+  id: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  note: zodOpenapi.z.string().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
 });
+const responseBodySchema$5 = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  party: partyCreateOutputSchema
+});
+const createPartyRoute = zodOpenapi.createRoute({
+  method: "post",
+  path: "/",
+  summary: "Create party",
+  tags: ["Parties"],
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: createPartyInputSchema
+        }
+      },
+      required: true
+    }
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: responseBodySchema$5
+        }
+      },
+      description: "Creates a Party."
+    },
+    ...errorResponse("Party", "Creation")
+  }
+});
+new zodOpenapi.OpenAPIHono().openapi(
+  createPartyRoute,
+  async (context) => {
+    const party = context.req.valid("json");
+    const { data: partyData, error } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.createParty(party);
+    if (!partyData || error) {
+      return context.json(
+        {
+          message: "Could not create a party"
+        },
+        500
+      );
+    }
+    return context.json(
+      {
+        message: "party created",
+        party: partyData
+      },
+      200
+    );
+  }
+);
+
+const partySchema = zodOpenapi.z.object({
+  partyType: zodOpenapi.z.enum(PartyTypeZod),
+  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+  id: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  note: zodOpenapi.z.string().optional(),
+  countryCode: 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 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()
+});
+const updateBankAccountSchema = zodOpenapi.z.object({
+  ...bankAccountMetadataSchema.shape,
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().optional(),
+  holderName: zodOpenapi.z.string(),
+  number: zodOpenapi.z.string().optional(),
+  currency: bankAccountMetadataSchema.shape.currency.nonoptional(),
+  countryCode: bankAccountMetadataSchema.shape.countryCode.nonoptional(),
+  id: bankAccountMetadataSchema.shape.id.nonoptional()
+});
+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 updateAddressInputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
   partyId: zodOpenapi.z.uuid(),
@@ -12069,52 +13599,255 @@ const updateAddressInputSchema = zodOpenapi.z.object({
   countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
   ruianCode: zodOpenapi.z.string().optional()
 });
-
-const partySchema = zodOpenapi.z.object({
-  partyType: zodOpenapi.z.enum(PartyTypeZod),
-  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+const updateAmlInputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
   internalId: zodOpenapi.z.string().optional(),
-  note: zodOpenapi.z.string().optional(),
-  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
+  sourceOfWealth: zodOpenapi.z.string().optional(),
+  yearlyIncome: zodOpenapi.z.string().optional(),
+  tradesPurpose: zodOpenapi.z.string().optional(),
+  sourceOfIncome: zodOpenapi.z.string().optional(),
+  transactionType: zodOpenapi.z.string().optional(),
+  transactionTypeExpiry: zodOpenapi.z.date().optional(),
+  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().optional(),
+  existencePeriod: zodOpenapi.z.string().optional(),
+  reputation: zodOpenapi.z.string().optional(),
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod).optional(),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod).optional()
 });
-const partyCreateOutputSchema = zodOpenapi.z.object({
+const partyUpdateInputSchema = zodOpenapi.z.object({
+  party: partySchema,
+  personalData: individualUpdateSchema.nullable(),
+  organizationData: organizationUpdateSchema.nullable(),
+  bankAccounts: zodOpenapi.z.array(updateBankAccountSchema),
+  disponents: zodOpenapi.z.array(disponentUpdateSchema).optional(),
+  addresses: zodOpenapi.z.array(updateAddressInputSchema),
+  recipients: zodOpenapi.z.array(updateBankAccountSchema).nullable(),
+  aml: updateAmlInputSchema.optional()
+});
+const updatePartyOuputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  customerStatus: zodOpenapi.z.enum(CustomerStatusZod),
+  partyType: zodOpenapi.z.enum(PartyTypeZod),
+  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+  note: zodOpenapi.z.string().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable()
+});
+const responseBodySchema$4 = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  party: updatePartyOuputSchema
+});
+const updatePartyRoute = zodOpenapi.createRoute({
+  method: "put",
+  path: "/{partyId}",
+  summary: "Update party",
+  tags: ["Parties"],
+  security: [
+    {
+      JwtAuth: []
+    }
+  ],
+  request: {
+    params: zodOpenapi.z.object({ partyId: zodOpenapi.z.uuid() }),
+    body: {
+      content: {
+        "application/json": {
+          schema: partyUpdateInputSchema
+        }
+      },
+      required: true
+    }
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: responseBodySchema$4
+        }
+      },
+      description: "Updates a Party."
+    },
+    ...errorResponse("Party", "Update")
+  }
+});
+new zodOpenapi.OpenAPIHono().openapi(
+  updatePartyRoute,
+  async (context) => {
+    const party = context.req.valid("json");
+    const { partyId } = context.req.valid("param");
+    const { data: updatedParty, error: partyError } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.updateParty({
+      partyId,
+      party: party.party,
+      personalData: party.personalData ?? void 0,
+      organizationData: party.organizationData ?? void 0,
+      bankAccounts: party.bankAccounts ?? void 0,
+      disponents: party.disponents ?? void 0,
+      addresses: party.addresses ?? void 0,
+      recipients: party.recipients ?? void 0,
+      aml: party.aml ?? void 0
+    });
+    if (!updatedParty || partyError) {
+      return context.json({ message: "Could not update a Party" }, 404);
+    }
+    return context.json(
+      {
+        message: "Party updated successfully",
+        party: updatedParty
+      },
+      200
+    );
+  }
+);
+
+const partyBaseOutputSchema = zodOpenapi.z.object({
   customerStatus: zodOpenapi.z.enum(CustomerStatusZod),
   partyType: zodOpenapi.z.enum(PartyTypeZod),
   language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
   id: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().nullable(),
-  note: zodOpenapi.z.string().nullable(),
-  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  note: zodOpenapi.z.string().nullable(),
+  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  createdAt: zodOpenapi.z.date().nullable(),
+  updatedAt: zodOpenapi.z.date().nullable(),
+  isClient: zodOpenapi.z.boolean()
+});
+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()
+});
+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()
+});
+const bankAccountOutputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.string(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  holderName: zodOpenapi.z.string(),
+  number: zodOpenapi.z.string().nullable(),
+  bankCode: zodOpenapi.z.string().nullable(),
+  currency: zodOpenapi.z.string(),
+  countryCode: zodOpenapi.z.string(),
+  iban: zodOpenapi.z.string().nullable(),
+  address: zodOpenapi.z.string().nullable(),
+  swiftBic: zodOpenapi.z.string().nullable(),
+  bicCor: zodOpenapi.z.string().nullable(),
+  routingNumber: zodOpenapi.z.string().nullable(),
+  sortCode: zodOpenapi.z.string().nullable(),
+  clabe: zodOpenapi.z.string().nullable(),
+  bsb: zodOpenapi.z.string().nullable(),
+  brBankNumber: zodOpenapi.z.string().nullable(),
+  updatedAt: zodOpenapi.z.coerce.date().nullable()
+});
+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 createAddressOutputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
+  internalId: 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),
+  ruianCode: zodOpenapi.z.string().nullable(),
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
 });
-zodOpenapi.z.object({
-  customerStatus: zodOpenapi.z.enum(CustomerStatusZod),
-  partyType: zodOpenapi.z.enum(PartyTypeZod),
-  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
+const createAmlOutputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().nullable(),
-  note: zodOpenapi.z.string().nullable(),
-  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
+  sourceOfWealth: zodOpenapi.z.string(),
+  yearlyIncome: zodOpenapi.z.string(),
+  tradesPurpose: zodOpenapi.z.string().nullable(),
+  sourceOfIncome: zodOpenapi.z.string(),
+  transactionType: zodOpenapi.z.string().nullable(),
+  transactionTypeExpiry: zodOpenapi.z.date().nullable(),
+  isDistraint: zodOpenapi.z.boolean(),
+  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(),
+  existencePeriod: zodOpenapi.z.string().nullable(),
+  reputation: zodOpenapi.z.string().nullable(),
+  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod),
+  kycStatus: zodOpenapi.z.enum(KycStatusZod).nullable(),
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
 });
-const createPartyInputSchema = zodOpenapi.z.object({
-  party: partySchema.omit({ id: true }),
-  personalData: individualInsertSchema.nullable(),
-  organizationData: createOrganizationInputSchema.nullable(),
-  bankAccounts: zodOpenapi.z.array(bankAccountInputSchema),
-  disponents: zodOpenapi.z.array(disponentSchema),
-  addresses: zodOpenapi.z.array(createAddressInputSchema),
-  aml: createAmlInputSchema,
-  recipients: zodOpenapi.z.array(bankAccountInputSchema)
-});
 const partyOutputSchema = zodOpenapi.z.object({
-  party: partyCreateOutputSchema.extend({
-    id: zodOpenapi.z.uuid(),
-    isClient: zodOpenapi.z.boolean()
-  }).nullable(),
+  party: partyBaseOutputSchema.nullable(),
   personalData: individualOutputSchema.nullable(),
   organizationData: createOrganizationOutputSchema.nullable(),
   bankAccounts: zodOpenapi.z.array(bankAccountOutputSchema).nullable(),
@@ -12123,32 +13856,174 @@ const partyOutputSchema = zodOpenapi.z.object({
   aml: createAmlOutputSchema.nullable(),
   recipients: zodOpenapi.z.array(bankAccountOutputSchema).nullable()
 });
-const partiesOutputDataSchema = zodOpenapi.z.array(partyOutputSchema);
-const partyUpdateInputSchema = zodOpenapi.z.object({
-  party: partySchema,
-  personalData: individualUpdateSchema.nullable(),
-  organizationData: organizationUpdateSchema.nullable(),
-  bankAccounts: zodOpenapi.z.array(updateBankAccountSchema),
-  disponents: zodOpenapi.z.array(disponentUpdateSchema).optional(),
-  addresses: zodOpenapi.z.array(updateAddressInputSchema),
-  recipients: zodOpenapi.z.array(updateBankAccountSchema).nullable(),
-  aml: updateAmlInputSchema.optional()
+const responseBodySchema$3 = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  party: partyOutputSchema
 });
-const updatePartyOuputSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  customerStatus: zodOpenapi.z.enum(CustomerStatusZod),
-  partyType: zodOpenapi.z.enum(PartyTypeZod),
-  language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
-  note: zodOpenapi.z.string().nullable(),
-  countryCode: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable()
+const getPartyByPartyIdRoute = zodOpenapi.createRoute({
+  method: "get",
+  path: "/{partyId}",
+  summary: "Get party",
+  tags: ["Parties"],
+  request: {
+    params: zodOpenapi.z.object({ partyId: zodOpenapi.z.uuid() })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: responseBodySchema$3
+        }
+      },
+      description: "Get party by party Id"
+    },
+    ...errorResponse("party", "Get")
+  }
+});
+new zodOpenapi.OpenAPIHono().openapi(
+  getPartyByPartyIdRoute,
+  async (context) => {
+    const { partyId } = context.req.valid("param");
+    const { data: partyData, error: partyError } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.getParty({ partyId });
+    if (partyData == null || partyError) {
+      return context.json({ message: "Party not found" }, 404);
+    }
+    return context.json(
+      {
+        message: "Party Found",
+        party: partyData
+      },
+      200
+    );
+  }
+);
+
+const paginationSchema = zodOpenapi.z.object({
+  offset: zodOpenapi.z.number().default(1),
+  limit: zodOpenapi.z.number().default(10)
+});
+const paginationAndSearchSchema = zodOpenapi.z.object({
+  page: zodOpenapi.z.coerce.number().positive().default(1),
+  limit: zodOpenapi.z.coerce.number().positive().default(20),
+  column: zodOpenapi.z.string(),
+  direction: zodOpenapi.z.enum(["asc", "desc"]),
+  search: zodOpenapi.z.string().optional(),
+  ids: zodOpenapi.z.string().array().optional()
+});
+paginationSchema.extend({
+  partyId: zodOpenapi.z.uuid()
+});
+paginationSchema.extend({
+  id: zodOpenapi.z.uuid()
+});
+zodOpenapi.z.object({ partyId: zodOpenapi.z.uuid() });
+
+const partiesOutputDataSchema = zodOpenapi.z.array(partyOutputSchema);
+const getPartiesRoute = zodOpenapi.createRoute({
+  method: "get",
+  path: "/",
+  summary: "List parties",
+  tags: ["Parties"],
+  request: { query: paginationAndSearchSchema },
+  responses: {
+    500: {
+      description: "Internal Server Error",
+      content: {
+        "application/json": {
+          schema: routeError
+        }
+      }
+    },
+    200: {
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({
+            message: zodOpenapi.z.string(),
+            data: zodOpenapi.z.object({
+              parties: partiesOutputDataSchema,
+              totalCount: zodOpenapi.z.number()
+            })
+          })
+        }
+      },
+      description: "Get Parties."
+    }
+  }
 });
+new zodOpenapi.OpenAPIHono().openapi(
+  getPartiesRoute,
+  async (context) => {
+    const query = context.req.query();
+    const validatedQuery = {
+      page: query.page ? Number(query.page) : 1,
+      limit: query.limit ? Number(query.limit) : 10,
+      column: query.column || "createdAt",
+      direction: query.direction || "desc",
+      search: query.search,
+      ids: query.ids ? Array.isArray(query.ids) ? query.ids : [query.ids] : void 0
+    };
+    const {
+      data: parties,
+      error,
+      message,
+      status
+    } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.getParties(
+      validatedQuery
+    );
+    if (error || !parties) {
+      return context.json(
+        {
+          message: "Failed to get parties",
+          data: null,
+          errorDetail: {
+            message,
+            code: status
+          },
+          error: true
+        },
+        500
+      );
+    }
+    return context.json({ message, data: parties }, 200);
+  }
+);
 
+const DOCUMENT_SIDE = ["front", "back"];
+const paramsSchema$2 = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid()
+});
+const idDocumentCreateInputSchema = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid(),
+  idDocType: zodOpenapi.z.enum(IdDocTypeZod),
+  idDocNumber: zodOpenapi.z.string(),
+  idDocHolderName: zodOpenapi.z.string(),
+  issueDate: zodOpenapi.z.coerce.date().optional(),
+  expirationDate: zodOpenapi.z.coerce.date().optional(),
+  issuer: zodOpenapi.z.string().optional(),
+  countryOfIssue: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
+  idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).optional()
+});
+const idDocumentMultipartSchema = zodOpenapi.z.object({
+  idDocument: zodOpenapi.z.string(),
+  documentSide: zodOpenapi.z.enum(DOCUMENT_SIDE),
+  file: zodOpenapi.z.any()
+});
+const multipartOpenApiSchema = zodOpenapi.z.object({
+  idDocument: zodOpenapi.z.string().openapi({
+    description: "JSON stringified IdDocument payload"
+  }),
+  documentSide: zodOpenapi.z.enum(DOCUMENT_SIDE),
+  file: zodOpenapi.z.any().openapi({
+    type: "string",
+    format: "binary"
+  })
+});
 const idDocumentOutputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
   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(),
@@ -12160,21 +14035,422 @@ const idDocumentOutputSchema = zodOpenapi.z.object({
   backImageUri: zodOpenapi.z.string().nullable(),
   idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).nullable()
 });
+const responseBodySchema$2 = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  idDocument: idDocumentOutputSchema
+});
+const createDocumentRoute = zodOpenapi.createRoute({
+  method: "post",
+  path: "/{partyId}/id-documents",
+  summary: "Create ID document and upload file",
+  tags: ["Documents"],
+  // middleware: [jwt, signature(), idempotency()],
+  // security: [{ JwtAuth: [] }],
+  request: {
+    // headers: z.object({
+    //   'X-Idempotency-Key': XIdempotencyKeyHeaderSchema,
+    //   'X-Signature': XSignatureHeaderSchema,
+    //   'X-Signature-Key': XSignatureKeyHeaderSchema,
+    // }),
+    body: {
+      content: {
+        "multipart/form-data": {
+          schema: multipartOpenApiSchema
+        }
+      },
+      required: true
+    },
+    params: paramsSchema$2
+  },
+  responses: {
+    200: {
+      description: "Document created and file uploaded",
+      content: {
+        "application/json": {
+          schema: responseBodySchema$2
+        }
+      }
+    },
+    400: {
+      description: "Invalid request",
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({ message: zodOpenapi.z.string() })
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({ message: zodOpenapi.z.string() })
+        }
+      }
+    }
+  }
+});
+new zodOpenapi.OpenAPIHono().openapi(
+  createDocumentRoute,
+  async (context) => {
+    const rawBody = await context.req.parseBody();
+    const { partyId } = await context.req.param();
+    const idDocumentRaw = rawBody.idDocument;
+    const documentSide = rawBody.documentSide;
+    const file = rawBody.file;
+    if (typeof idDocumentRaw !== "string" || !DOCUMENT_SIDE.includes(documentSide) || !(file instanceof File)) {
+      return context.json({ message: "Invalid multipart payload" }, 400);
+    }
+    const idDocumentJson = JSON.parse(JSON.parse(idDocumentRaw));
+    const idDocumentResult = idDocumentCreateInputSchema.safeParse(idDocumentJson);
+    if (!idDocumentResult.success) {
+      console.error(idDocumentResult.error);
+      return context.json({ message: "Could not parse IdDocument" }, 400);
+    }
+    const {
+      data: createdIdDocument,
+      error: createError,
+      message
+    } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.createIdDocument({
+      idDocument: idDocumentResult.data,
+      partyId
+    });
+    if (!createdIdDocument || createError) {
+      console.error(message);
+      return context.json({ message: "Could not create IdDocument" }, 500);
+    }
+    const bytes = new Uint8Array(await file.arrayBuffer());
+    const { data: uploadResult, error: uploadError } = await context.env.DOCUMENT_SERVICE.uploadDocument({
+      entityType: "client",
+      entityId: createdIdDocument.id,
+      type: "kyc",
+      metadata: {},
+      file: {
+        bytes,
+        type: file.type,
+        name: file.name,
+        size: file.size
+      }
+    });
+    if (!uploadResult || uploadError) {
+      return context.json({ message: "File upload failed" }, 500);
+    }
+    return context.json(
+      {
+        message: "IdDocument created successfully",
+        idDocument: {
+          ...createdIdDocument,
+          frontImageUri: documentSide === "front" ? uploadResult.storageUrl : createdIdDocument.frontImageUri,
+          backImageUri: documentSide === "back" ? uploadResult.storageUrl : createdIdDocument.backImageUri
+        }
+      },
+      200
+    );
+  }
+);
+
+const XIdempotencyKeyHeaderSchema = zodOpenapi.z.string().openapi({
+  description: "Unique identifier header to ensure the request is processed only once.",
+  example: "4ac15c22-2bd3-426f-b915-bfd5febdb7df"
+});
+const XSignatureHeaderSchema = zodOpenapi.z.string().openapi({
+  description: "Payload signature header to verify request body integrity.",
+  example: "FIXAxHO6QqH3M7t4MatM8U6l/nIqWj7jIEW2U6/771MGUorSywy+GmKIG3B1mxT1jR7qPtBHQ5YSO8O53iCvOh6kIhbGXtVe/3C61dsEykLbmntV3nF4DY8/HyfF8a6c2Asc5bvgHrhosGi3s/ouoNowMpsckyq66We8H5gRbXlqJm4Bl1zWWQah4aQLX548L8DLx5+EIgArNMVVG8ryCES99aovJBKrQQMpQLwss1sSFuUZ1kdBCodtvxgTOXOugnZ1UNCmUNFXryQ6bn7wY7Punml/rwR/zTQ9j4SX07iFeQC5rgm9/zi29DBluegu+b8/G8oXrf6L4hugbMEKJfLRfKjNHCrjCooKtInoYxwNEfJyJ9mhqdBoeIBca9zgPpewdbwFLXVV82TYR+xZiywDcHKQ62IzQp07NOMCl4xArSJ3vIWUftSYpLIwomyjQEbY27oGiubUF4krEKgHnMYalCn0ruYOwFik2Pa6FEfIZo0TSXDC24UHQb5mJNPYpv2hny7U5CZPmBvjaRGMVnE+WgRUT19cwqlSL3pWAfeSn1Wro7lYBp/PmlRPgYIxl9GJwNlQ0G+NzP9cMSJbmI5fwErDNgJAaPaMwZbJ3y8ikmbBkkXNPKvQrWVGCJ4nP+/f8yYzMZq272EFx984pSoo2yAeBJnrxbW+AlZxyIo="
+});
+const XSignatureKeyHeaderSchema = zodOpenapi.z.string().openapi({
+  description: "Signature key identifier header to specify which key was used for payload signing.",
+  example: "ixtal"
+});
+const ALLOWED_ID_DOCUMENTS_FILTERS = {
+  PARTY_ID: "filterIdDocumentPartyId",
+  ISSUER: "filterIdDocumentIssuer"
+};
+
 const idDocumentsListOutputSchema = zodOpenapi.z.object({
   totalCount: zodOpenapi.z.number(),
   idDocuments: zodOpenapi.z.array(idDocumentOutputSchema)
 });
-const DOCUMENT_SIDE = ["front", "back"];
-const idDocumentCreateInputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid(),
-  idDocType: zodOpenapi.z.enum(IdDocTypeZod),
-  idDocNumber: zodOpenapi.z.string(),
-  idDocHolderName: zodOpenapi.z.string(),
-  issueDate: zodOpenapi.z.coerce.date().optional(),
-  expirationDate: zodOpenapi.z.coerce.date().optional(),
-  issuer: zodOpenapi.z.string().optional(),
-  countryOfIssue: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
-  idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).optional()
+const paramsSchema$1 = zodOpenapi.z.object({
+  partyId: zodOpenapi.z.uuid()
+});
+const arrayQuery = (schema) => zodOpenapi.z.preprocess((val) => {
+  if (typeof val === "string") {
+    return val.includes(",") ? val.split(",") : [val];
+  }
+  return val;
+}, schema.array()).optional();
+const querySchema = zodOpenapi.z.object({
+  page: zodOpenapi.z.coerce.number().positive().default(1),
+  limit: zodOpenapi.z.coerce.number().positive().default(20),
+  sortColumn: zodOpenapi.z.string().default("updatedAt"),
+  sortDirection: zodOpenapi.z.enum(["asc", "desc"]).default("desc"),
+  [ALLOWED_ID_DOCUMENTS_FILTERS.PARTY_ID]: arrayQuery(zodOpenapi.z.uuid()),
+  [ALLOWED_ID_DOCUMENTS_FILTERS.ISSUER]: arrayQuery(zodOpenapi.z.string()),
+  search: zodOpenapi.z.string().optional()
+});
+const responseBodySchema$1 = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  idDocumentsList: idDocumentsListOutputSchema
+});
+const getIdDocumentsListRoute = zodOpenapi.createRoute({
+  method: "get",
+  path: "/{partyId}/id-documents",
+  summary: "List party ID documents",
+  tags: ["Documents"],
+  request: {
+    params: paramsSchema$1,
+    query: querySchema
+  },
+  responses: {
+    200: {
+      description: "ID documents list fetched",
+      content: {
+        "application/json": {
+          schema: responseBodySchema$1
+        }
+      }
+    },
+    404: {
+      description: "ID documents not found",
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({ message: zodOpenapi.z.string() })
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({ message: zodOpenapi.z.string() })
+        }
+      }
+    }
+  }
+});
+new zodOpenapi.OpenAPIHono().openapi(
+  getIdDocumentsListRoute,
+  async (context) => {
+    const { partyId } = context.req.valid("param");
+    const { sortColumn, sortDirection, limit, page, ...filters } = context.req.valid("query");
+    const { data: idDocumentsList, error } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.getIdDocumentsList({
+      pagination: {
+        page,
+        limit,
+        sort: {
+          column: sortColumn,
+          direction: sortDirection
+        },
+        filterIdDocumentPartyId: partyId,
+        ...filters
+      }
+    });
+    if (!idDocumentsList || error) {
+      return context.json({ message: "Could not list id documents" }, 404);
+    }
+    return context.json(
+      {
+        message: "ID documents listed successfully",
+        idDocumentsList
+      },
+      200
+    );
+  }
+);
+
+const algParams = {
+  RSA: {
+    name: "RSASSA-PKCS1-v1_5",
+    hash: { name: "SHA-256" }
+  },
+  EC: {
+    name: "ECDSA",
+    namedCurve: "P-256"
+  },
+  HMAC: {
+    name: "HMAC",
+    hash: { name: "SHA-256" }
+  }
+};
+const verifyPayloadSignature = async ({
+  signature,
+  data,
+  publicKey,
+  algorithm = "RSA"
+}) => {
+  const binaryPublicKey = Uint8Array.from(
+    atob(publicKey),
+    (c) => c.charCodeAt(0)
+  );
+  const format = algorithm === "HMAC" ? "raw" : "spki";
+  const importedPublicKey = await crypto.subtle.importKey(
+    format,
+    binaryPublicKey,
+    algParams[algorithm],
+    false,
+    ["verify"]
+  );
+  const encodedPayload = new TextEncoder().encode(data);
+  const decodedSignature = Uint8Array.from(
+    atob(signature),
+    (c) => c.charCodeAt(0)
+  );
+  const isValid = await crypto.subtle.verify(
+    algParams[algorithm],
+    importedPublicKey,
+    decodedSignature,
+    encodedPayload
+  );
+  return isValid;
+};
+
+const validateBearerScheme = (header) => {
+  return header.startsWith("Bearer ") && header.length > 7 && !header.slice(7).includes(" ");
+};
+const extractBearerToken = (header) => {
+  return header.slice(7).trim();
+};
+const validateBearerToken = (bearerToken) => {
+  return zod.z.jwt().safeParse(bearerToken).success;
+};
+
+const idempotency = () => {
+  return factory.createMiddleware(async (context, next) => {
+    if (!context.env.MIDDLEWARE_IDEMPOTENCY_DISABLED) {
+      const idempotencyKeyHeader = context.req.header("x-idempotency-key");
+      if (!idempotencyKeyHeader) {
+        throw new httpException.HTTPException(401, {
+          message: `The 'x-idempotency-key' header must exist and must have a value.`
+        });
+      }
+      const existingIdempotencyRecord = await context.env.IDEMPOTENCY_KV.get(idempotencyKeyHeader);
+      if (existingIdempotencyRecord) {
+        throw new httpException.HTTPException(409, {
+          message: "The identical request has already been processed. The idempotency key is not unique."
+        });
+      }
+      await context.env.IDEMPOTENCY_KV.put(
+        idempotencyKeyHeader,
+        idempotencyKeyHeader,
+        {
+          expirationTtl: 60 * 60 * 24 * 3
+          // 3 days
+        }
+      );
+      context.set("idempotency", {
+        key: idempotencyKeyHeader
+      });
+    }
+    await next();
+  });
+};
+
+const jwt = () => {
+  return factory.createMiddleware(async (context, next) => {
+    if (!context.env.MIDDLEWARE_JWT_DISABLED) {
+      const authorizationHeader = context.req.header("authorization");
+      if (!authorizationHeader) {
+        throw new httpException.HTTPException(401, {
+          message: `The 'authorization' header must exist and must have a value.`
+        });
+      }
+      if (!validateBearerScheme(authorizationHeader)) {
+        throw new httpException.HTTPException(401, {
+          message: `The 'authorization' header value must use the Bearer scheme.`
+        });
+      }
+      const bearerToken = extractBearerToken(authorizationHeader);
+      if (!validateBearerToken(bearerToken)) {
+        throw new httpException.HTTPException(401, {
+          message: `The Bearer token in the 'authorization' header value must be a JWT.`
+        });
+      }
+      const { data, error } = await context.env.AUTH_SERVICE.verifyAccessToken({
+        accessToken: bearerToken
+      });
+      if (!data || error) {
+        throw new httpException.HTTPException(401, {
+          message: "The JWT must contain valid user information."
+        });
+      }
+      const rawUserMetaDataString = data.payload.user.rawUserMetaData;
+      const rawUserMetaData = rawUserMetaDataString ? JSON.parse(rawUserMetaDataString) : null;
+      const identityId = rawUserMetaData.organizationId ?? rawUserMetaData.exchangeOfficeId;
+      if (!identityId) {
+        throw new httpException.HTTPException(422, {
+          message: "User data integrity check failed."
+        });
+      }
+      context.set("identity", {
+        ...data.payload,
+        user: {
+          ...data.payload.user,
+          organizationId: rawUserMetaData.organizationId,
+          exchangeOfficeId: rawUserMetaData.exchangeOfficeId
+        }
+      });
+    }
+    await next();
+  });
+};
+
+const signature = () => {
+  return factory.createMiddleware(async (context, next) => {
+    if (!context.env.MIDDLEWARE_SIGNATURE_DISABLED) {
+      const signatureHeader = context.req.header("x-signature");
+      if (!signatureHeader) {
+        throw new httpException.HTTPException(401, {
+          message: `The 'x-signature' header must exist and must have a value.`
+        });
+      }
+      const signatureKeyHeader = context.req.header("X-Signature-Key");
+      if (!signatureKeyHeader) {
+        throw new httpException.HTTPException(401, {
+          message: `The 'x-signature-key' header must exist and must have a value.`
+        });
+      }
+      const payload = JSON.stringify(await context.req.json().catch(() => null));
+      const identityContext = context.get("identity");
+      const organizationId = identityContext.user.organizationId;
+      const exchangeOfficeId = identityContext.user.exchangeOfficeId;
+      const identityId = organizationId ?? exchangeOfficeId;
+      if (!identityId) {
+        throw new httpException.HTTPException(401, {
+          message: "Failed to retrieve request identity ID."
+        });
+      }
+      const { data: organization, error } = await context.env.ORGANIZATION_SERVICE.getOrganization({
+        organizationId: identityId
+      });
+      if (!organization || error) {
+        throw new httpException.HTTPException(404, {
+          message: "Failed to retrieve organization."
+        });
+      }
+      const signatureKey = organization.signatureKeys.filter(
+        (signatureKey2) => signatureKey2.name === signatureKeyHeader
+      )[0];
+      if (!signatureKey) {
+        throw new httpException.HTTPException(404, {
+          message: "Signature key not found."
+        });
+      }
+      const isVerified = await verifyPayloadSignature({
+        signature: signatureHeader,
+        publicKey: signatureKey.publicKey,
+        data: payload
+      });
+      if (!isVerified) {
+        throw new httpException.HTTPException(401, {
+          message: "Invalid signature key or signature."
+        });
+      }
+    }
+    await next();
+  });
+};
+
+const paramsSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid()
 });
 const idDocumentUpdateInputSchema = zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid().optional(),
@@ -12189,30 +14465,108 @@ const idDocumentUpdateInputSchema = zodOpenapi.z.object({
   backImageUri: zodOpenapi.z.string().optional(),
   idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).optional()
 });
-const idDocumentMultipartSchema = zodOpenapi.z.object({
-  idDocument: zodOpenapi.z.string(),
-  documentSide: zodOpenapi.z.enum(DOCUMENT_SIDE),
-  file: zodOpenapi.z.any()
+const responseBodySchema = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  idDocument: idDocumentOutputSchema
+});
+const updateIdDocumentRoute = zodOpenapi.createRoute({
+  method: "put",
+  path: "/{partyId}/id-documents/{id}",
+  summary: "Update party document",
+  tags: ["Documents"],
+  middleware: [jwt, signature(), idempotency()],
+  security: [{ JwtAuth: [] }],
+  request: {
+    headers: zodOpenapi.z.object({
+      "X-Idempotency-Key": XIdempotencyKeyHeaderSchema,
+      "X-Signature": XSignatureHeaderSchema,
+      "X-Signature-Key": XSignatureKeyHeaderSchema
+    }),
+    params: paramsSchema,
+    body: {
+      content: {
+        "application/json": {
+          schema: idDocumentUpdateInputSchema
+        }
+      },
+      required: true
+    }
+  },
+  responses: {
+    200: {
+      description: "ID document updated successfully",
+      content: {
+        "application/json": {
+          schema: responseBodySchema
+        }
+      }
+    },
+    404: {
+      description: "ID document not found",
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({ message: zodOpenapi.z.string() })
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: zodOpenapi.z.object({ message: zodOpenapi.z.string() })
+        }
+      }
+    }
+  }
 });
+new zodOpenapi.OpenAPIHono().openapi(
+  updateIdDocumentRoute,
+  async (context) => {
+    const { id } = context.req.valid("param");
+    const patch = context.req.valid("json");
+    const { data: existingDocument, error: fetchError } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.getIdDocument({ id });
+    if (!existingDocument || fetchError) {
+      return context.json({ message: "ID document not found" }, 404);
+    }
+    const fullIdDocument = {
+      ...existingDocument,
+      ...patch,
+      id
+    };
+    const { data: updatedIdDocument, error: updateError } = await context.env.MASTER_DATA_MANAGEMENT_SERVICE.updateIdDocument({
+      idDocument: fullIdDocument
+    });
+    if (!updatedIdDocument || updateError) {
+      return context.json({ message: "Could not update ID document" }, 500);
+    }
+    return context.json(
+      {
+        message: "ID document updated successfully",
+        idDocument: updatedIdDocument
+      },
+      200
+    );
+  }
+);
 
 const messageResponseSchema = zodOpenapi.z.object({
   message: zodOpenapi.z.string()
 });
 
 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;
@@ -12224,6 +14578,6 @@ exports.messageResponseSchema = messageResponseSchema;
 exports.partiesOutputDataSchema = partiesOutputDataSchema;
 exports.partyCreateOutputSchema = partyCreateOutputSchema;
 exports.partyOutputSchema = partyOutputSchema;
-exports.partySchema = partySchema;
+exports.partySchema = partySchema$1;
 exports.partyUpdateInputSchema = partyUpdateInputSchema;
 exports.updatePartyOuputSchema = updatePartyOuputSchema;