@devizovaburza/mdm-sdk 0.0.12 → 0.0.14

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;
@@ -28,31 +30,31 @@ const createMdmClient = (baseUrl, options) => {
   return client.hc(baseUrl, options);
 };
 
-const AddressTypeZod$1 = [
+const ADDRESS_TYPE$1 = [
   "PERMANENT_ADDRESS",
   "REGISTERED_OFFICE",
   "CONTACT_ADDRESS"
 ];
-const ContactTypeZod$1 = [
+const CONTACT_TYPE$1 = [
   "EMAIL",
   "PHONE_AUTH",
   "PHONE_CONTACT",
   "PHONE_WORK"
 ];
-const IdDocTypeZod$1 = ["PASSPORT", "ID", "DRIVING_LICENSE"];
-const IdDocStatusZod$1 = [
+const ID_DOC_TYPE$1 = ["PASSPORT", "ID", "DRIVING_LICENSE"];
+const ID_DOC_STATUS$1 = [
   "ACTIVE",
   "EXPIRED",
   "EXPIRE_SOON",
   "REVOKED"
 ];
-const PartyRelationshipTypeZod$1 = [
+const PARTY_RELATIONSHIP_TYPE$1 = [
   "AUTHORIZED_SIGNATORY",
   "POA_HOLDER",
   "BOARD_MEMBER",
   "UBO"
 ];
-const CustomerStatusZod$1 = [
+const CUSTOMER_STATUS$1 = [
   // 'LEAD',
   "NEW",
   "ACTIVE",
@@ -61,7 +63,7 @@ const CustomerStatusZod$1 = [
   // 'FORMER',
   // 'DECEASED',
 ];
-const ClientStatusActionZod = [
+const CLIENT_STATUS_ACTION = [
   "ON_CUSTOMER_FORM_COMPLETED",
   "ON_MANUAL_KYC_VERIFICATION_COMPLETED",
   "ON_MANUAL_RISK_ASSESSMENT_COMPLETED",
@@ -69,12 +71,12 @@ const ClientStatusActionZod = [
   "ON_CLOSE_CLIENT",
   "ON_UNBLOCK_CLIENT"
 ];
-const PartyTypeZod$1 = [
+const PARTY_TYPE$1 = [
   "INDIVIDUAL",
   "SELF_EMPLOYED",
   "ORGANIZATION"
 ];
-const AmlScoreTypeZod$1 = [
+const AML_SCORE_TYPE$1 = [
   "LOW",
   "MEDIUM",
   "HIGH",
@@ -82,44 +84,46 @@ const AmlScoreTypeZod$1 = [
   "UNVERIFIED",
   "UNCLASSIFIED"
 ];
-const IdentificationTypeZod = [
+const IDENTIFICATION_TYPE = [
   "FACE_TO_FACE",
   "REMOTE_IDENTIFICATION"
 ];
-const GenderZod$1 = ["M", "F", "OTHER"];
-const KycStatusZod$1 = [
+const GENDER$1 = ["M", "F", "OTHER"];
+const KYC_STATUS$1 = [
   "NOT_APPROVED",
   "VERIFIED",
   "UNVERIFIED",
   "REJECTED"
 ];
 const TRADER_TYPE$1 = ["PERSON", "COMPANY", "OSVC"];
+const PRODUCT_TYPE$1 = ["TXS", "CBS"];
+const TXS_CLIENT_TYPE$1 = ["CLIENT", "PROVIDER"];
 
-const AddressTypeZod = [
+const ADDRESS_TYPE = [
   "PERMANENT_ADDRESS",
   "REGISTERED_OFFICE",
   "CONTACT_ADDRESS"
 ];
-const ContactTypeZod = [
+const CONTACT_TYPE = [
   "EMAIL",
   "PHONE_AUTH",
   "PHONE_CONTACT",
   "PHONE_WORK"
 ];
-const IdDocTypeZod = ["PASSPORT", "ID", "DRIVING_LICENSE"];
-const IdDocStatusZod = [
+const ID_DOC_TYPE = ["PASSPORT", "ID", "DRIVING_LICENSE"];
+const ID_DOC_STATUS = [
   "ACTIVE",
   "EXPIRED",
   "EXPIRE_SOON",
   "REVOKED"
 ];
-const PartyRelationshipTypeZod = [
+const PARTY_RELATIONSHIP_TYPE = [
   "AUTHORIZED_SIGNATORY",
   "POA_HOLDER",
   "BOARD_MEMBER",
   "UBO"
 ];
-const CustomerStatusZod = [
+const CUSTOMER_STATUS = [
   // 'LEAD',
   "NEW",
   "ACTIVE",
@@ -128,12 +132,12 @@ const CustomerStatusZod = [
   // 'FORMER',
   // 'DECEASED',
 ];
-const PartyTypeZod = [
+const PARTY_TYPE = [
   "INDIVIDUAL",
   "SELF_EMPLOYED",
   "ORGANIZATION"
 ];
-const AmlScoreTypeZod = [
+const AML_SCORE_TYPE = [
   "LOW",
   "MEDIUM",
   "HIGH",
@@ -141,14 +145,15 @@ const AmlScoreTypeZod = [
   "UNVERIFIED",
   "UNCLASSIFIED"
 ];
-const GenderZod = ["M", "F", "OTHER"];
-const KycStatusZod = [
+const GENDER = ["M", "F", "OTHER"];
+const KYC_STATUS = [
   "NOT_APPROVED",
   "VERIFIED",
   "UNVERIFIED",
   "REJECTED"
 ];
 const TRADER_TYPE = ["PERSON", "COMPANY", "OSVC"];
+const PRODUCT_TYPE = ["TXS", "CBS"];
 
 const entityKind = Symbol.for("drizzle:entityKind");
 function is(value, type) {
@@ -1352,12 +1357,60 @@ function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
   const table = Object.assign(rawTable, builtColumns);
   table[Table.Symbol.Columns] = builtColumns;
   table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) {
+    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
   return table;
 }
 const sqliteTable = (name, columns, extraConfig) => {
-  return sqliteTableBase(name, columns);
+  return sqliteTableBase(name, columns, extraConfig);
 };
 
+class IndexBuilderOn {
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+}
+class IndexBuilder {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name, columns, unique) {
+    this.config = {
+      name,
+      columns,
+      unique,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+}
+class Index {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(name, true);
+}
+
 const CONSTANTS = {
     INT8_MIN: -128,
     INT8_MAX: 127,
@@ -1654,15 +1707,15 @@ const createSelectSchema = (entity, refine) => {
         return handleEnum(entity);
     }
     const columns = getColumns(entity);
-    return handleColumns(columns, {}, selectConditions);
+    return handleColumns(columns, refine ?? {}, selectConditions);
 };
 const createInsertSchema = (entity, refine) => {
     const columns = getColumns(entity);
-    return handleColumns(columns, {}, insertConditions);
+    return handleColumns(columns, refine ?? {}, insertConditions);
 };
 const createUpdateSchema = (entity, refine) => {
     const columns = getColumns(entity);
-    return handleColumns(columns, {}, updateConditions);
+    return handleColumns(columns, refine ?? {}, updateConditions);
 };
 
 var esprima$1 = {exports: {}};
@@ -12281,9 +12334,9 @@ const party = sqliteTable("party", {
   internalId: text("internal_id"),
   note: text("note"),
   customerStatus: text("customer_status", {
-    enum: CustomerStatusZod
+    enum: CUSTOMER_STATUS
   }).notNull(),
-  partyType: text("party_type", { enum: PartyTypeZod }).notNull(),
+  partyType: text("party_type", { enum: PARTY_TYPE }).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),
@@ -12295,7 +12348,7 @@ const address = sqliteTable("address", {
   internalId: text("internal_id"),
   partyId: text("party_id").notNull().references(() => party.id),
   ruianCode: text("ruian_code"),
-  addressType: text("address_type", { enum: AddressTypeZod }).notNull(),
+  addressType: text("address_type", { enum: ADDRESS_TYPE }).notNull(),
   street: text("street"),
   orientationNumber: text("orientation_number"),
   descriptiveNumber: text("descriptive_number"),
@@ -12311,7 +12364,7 @@ const contact = sqliteTable("contact", {
   ...base,
   internalId: text("internal_id"),
   partyId: text("party_id").notNull().references(() => party.id),
-  contactType: text("contact_type", { enum: ContactTypeZod }),
+  contactType: text("contact_type", { enum: CONTACT_TYPE }),
   email: text("email").notNull(),
   phoneNumber: text("phone_number").notNull()
 });
@@ -12320,7 +12373,7 @@ 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(),
+  idDocType: text("id_doc_type", { enum: ID_DOC_TYPE }).notNull(),
   idDocNumber: text("id_doc_number").notNull(),
   idDocHolderName: text("id_doc_holder_name").notNull(),
   issueDate: integer("issue_date", { mode: "timestamp_ms" }),
@@ -12329,7 +12382,7 @@ const idDocument = sqliteTable("id_document", {
   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 })
+  idDocStatus: text("id_doc_status", { enum: ID_DOC_STATUS })
 });
 
 const individual = sqliteTable("individual", {
@@ -12344,7 +12397,7 @@ const individual = sqliteTable("individual", {
   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(),
+  gender: text("gender", { enum: GENDER }).notNull(),
   citizenship: text("citizenship", { enum: generalCodes.COUNTRY_CODES_2 }).notNull(),
   citizenshipOther: text("citizenship_other", { enum: generalCodes.COUNTRY_CODES_2 }),
   employer: text("employer"),
@@ -12405,7 +12458,7 @@ const partyRelationship = sqliteTable("party_relationship", {
   ...base,
   internalId: text("internal_id"),
   relationshipType: text("relationship_type", {
-    enum: PartyRelationshipTypeZod
+    enum: PARTY_RELATIONSHIP_TYPE
   }),
   fromPartyId: text("from_party_id").references(() => party.id),
   toPartyId: text("to_party_id").references(() => party.id),
@@ -12469,8 +12522,8 @@ const aml = sqliteTable("aml", {
   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 })
+  riskLevel: text("risk_level", { enum: AML_SCORE_TYPE }).notNull(),
+  kycStatus: text("kyc_status", { enum: KYC_STATUS })
 });
 
 const recipient = sqliteTable("recipient", {
@@ -12501,8 +12554,26 @@ sqliteTable("trader_client", {
   legacyId: text("legacy_id")
 });
 
+const partyProduct = sqliteTable(
+  "party_product",
+  {
+    ...base,
+    partyId: text("party_id").notNull().references(() => party.id),
+    product: text("product", { enum: PRODUCT_TYPE }).notNull(),
+    config: text("config", { mode: "json" }).$type()
+  },
+  (table) => [
+    uniqueIndex("party_product_party_id_product_unique").on(
+      table.partyId,
+      table.product
+    )
+  ]
+);
+
 sqliteTable("base", baseMdmSqlite);
 
+const TXS_CLIENT_TYPE = ["CLIENT", "PROVIDER"];
+
 createInsertSchema(address);
 createUpdateSchema(address);
 createSelectSchema(address);
@@ -12511,7 +12582,7 @@ const addressInsertSchema = zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().optional().nullable(),
   ruianCode: zodOpenapi.z.string().optional().nullable(),
-  addressType: zodOpenapi.z.enum(AddressTypeZod),
+  addressType: zodOpenapi.z.enum(ADDRESS_TYPE),
   street: zodOpenapi.z.string().optional().nullable(),
   orientationNumber: zodOpenapi.z.string().optional().nullable(),
   descriptiveNumber: zodOpenapi.z.string().optional().nullable(),
@@ -12527,7 +12598,7 @@ const addressUpdateSchema = zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid().optional(),
   internalId: zodOpenapi.z.string().optional().nullable(),
   ruianCode: zodOpenapi.z.string().optional().nullable(),
-  addressType: zodOpenapi.z.enum(AddressTypeZod).optional(),
+  addressType: zodOpenapi.z.enum(ADDRESS_TYPE).optional(),
   street: zodOpenapi.z.string().optional().nullable(),
   orientationNumber: zodOpenapi.z.string().optional().nullable(),
   descriptiveNumber: zodOpenapi.z.string().optional().nullable(),
@@ -12544,7 +12615,7 @@ const addressSelectSchema = zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().nullable(),
   ruianCode: zodOpenapi.z.string().nullable(),
-  addressType: zodOpenapi.z.enum(AddressTypeZod),
+  addressType: zodOpenapi.z.enum(ADDRESS_TYPE),
   street: zodOpenapi.z.string().nullable(),
   orientationNumber: zodOpenapi.z.string().nullable(),
   descriptiveNumber: zodOpenapi.z.string().nullable(),
@@ -12579,8 +12650,8 @@ const amlInsertSchema = zodOpenapi.z.object({
   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()
+  riskLevel: zodOpenapi.z.enum(AML_SCORE_TYPE).nullable().optional(),
+  kycStatus: zodOpenapi.z.enum(KYC_STATUS).nullable().optional()
 });
 const amlUpdateSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
@@ -12601,8 +12672,8 @@ const amlUpdateSchema = zodOpenapi.z.object({
   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()
+  riskLevel: zodOpenapi.z.enum(AML_SCORE_TYPE).nullable().optional(),
+  kycStatus: zodOpenapi.z.enum(KYC_STATUS).nullable().optional()
 });
 const amlSelectSchema = amlBaseSelectSchema;
 
@@ -12625,7 +12696,7 @@ createSelectSchema(contact);
 const contactInsertSchema = zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().optional().nullable(),
-  contactType: zodOpenapi.z.enum(ContactTypeZod).optional(),
+  contactType: zodOpenapi.z.enum(CONTACT_TYPE).optional(),
   email: zodOpenapi.z.email("Invalid email format"),
   phoneNumber: zodOpenapi.z.string()
 });
@@ -12633,7 +12704,7 @@ const contactUpdateSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
   partyId: zodOpenapi.z.uuid().optional(),
   internalId: zodOpenapi.z.string().optional().nullable(),
-  contactType: zodOpenapi.z.enum(ContactTypeZod).optional(),
+  contactType: zodOpenapi.z.enum(CONTACT_TYPE).optional(),
   email: zodOpenapi.z.email("Invalid email format").optional(),
   phoneNumber: zodOpenapi.z.string().optional()
 });
@@ -12651,7 +12722,7 @@ const individualInsertSchema$1 = zodOpenapi.z.object({
   birthPlace: zodOpenapi.z.string(),
   countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
   personalId: zodOpenapi.z.string(),
-  gender: zodOpenapi.z.enum(GenderZod),
+  gender: zodOpenapi.z.enum(GENDER),
   citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
   citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional().nullable(),
   employer: zodOpenapi.z.string().optional().nullable(),
@@ -12679,7 +12750,7 @@ const individualUpdateSchema$1 = zodOpenapi.z.object({
   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(),
+  gender: zodOpenapi.z.enum(GENDER).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(),
@@ -12708,7 +12779,7 @@ const individualSelectSchema = zodOpenapi.z.object({
   birthPlace: zodOpenapi.z.string(),
   countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
   personalId: zodOpenapi.z.string(),
-  gender: zodOpenapi.z.enum(GenderZod),
+  gender: zodOpenapi.z.enum(GENDER),
   citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
   citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
   employer: zodOpenapi.z.string().nullable(),
@@ -12865,7 +12936,7 @@ createSelectSchema(idDocument);
 const idDocumentInsertSchema = zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().optional().nullable(),
-  idDocType: zodOpenapi.z.enum(IdDocTypeZod),
+  idDocType: zodOpenapi.z.enum(ID_DOC_TYPE),
   idDocNumber: zodOpenapi.z.string(),
   idDocHolderName: zodOpenapi.z.string(),
   issueDate: zodOpenapi.z.date().optional().nullable(),
@@ -12874,13 +12945,13 @@ const idDocumentInsertSchema = zodOpenapi.z.object({
   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()
+  idDocStatus: zodOpenapi.z.enum(ID_DOC_STATUS).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(),
+  idDocType: zodOpenapi.z.enum(ID_DOC_TYPE).optional(),
   idDocNumber: zodOpenapi.z.string().optional(),
   idDocHolderName: zodOpenapi.z.string().optional(),
   issueDate: zodOpenapi.z.date().optional().nullable(),
@@ -12889,7 +12960,7 @@ const idDocumentUpdateSchema = zodOpenapi.z.object({
   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()
+  idDocStatus: zodOpenapi.z.enum(ID_DOC_STATUS).optional().nullable()
 });
 
 const recipientBaseInsertSchema = createInsertSchema(recipient);
@@ -12902,21 +12973,64 @@ const recipientInsertSchema = bankAccountInsertSchema;
 const recipientUpdateSchema = bankAccountUpdateSchema;
 const recipientSelectSchema = bankAccountSelectSchema;
 
+const productTxsConfigSchema = zodOpenapi.z.object({
+  fee: zodOpenapi.z.number(),
+  margin: zodOpenapi.z.number(),
+  reportingEmail: zodOpenapi.z.string().optional(),
+  clientType: zodOpenapi.z.enum(TXS_CLIENT_TYPE).optional()
+});
+const productCbsConfigSchema = zodOpenapi.z.object({});
+const productConfigSchema = zodOpenapi.z.union([
+  productTxsConfigSchema,
+  productCbsConfigSchema
+]);
+const partyProductBaseInsertSchema = createInsertSchema(partyProduct, {
+  config: () => productConfigSchema.nullable()
+});
+createUpdateSchema(partyProduct, {
+  config: () => productConfigSchema.nullable()
+});
+createSelectSchema(partyProduct, {
+  config: () => productConfigSchema.nullable()
+});
+const partyProductUpdateSchema = partyProductBaseInsertSchema.extend({
+  partyId: zodOpenapi.z.uuid()
+});
+partyProductUpdateSchema.omit({
+  id: true
+});
+const partyProductSelectSchema = partyProductUpdateSchema.required();
+zodOpenapi.z.array(partyProductSelectSchema);
+const productsInputSchema$2 = zodOpenapi.z.object({
+  txs: productTxsConfigSchema.optional(),
+  cbs: productCbsConfigSchema.optional()
+});
+const productTxsConfigOutputSchema = zodOpenapi.z.object({
+  fee: zodOpenapi.z.number(),
+  margin: zodOpenapi.z.number(),
+  reportingEmail: zodOpenapi.z.string().nullable(),
+  clientType: zodOpenapi.z.enum(TXS_CLIENT_TYPE).nullable()
+});
+const productsOutputSchema$1 = zodOpenapi.z.object({
+  txs: productTxsConfigOutputSchema.nullable(),
+  cbs: productCbsConfigSchema.nullable()
+});
+
 createInsertSchema(party);
 createUpdateSchema(party);
-const partySchema$1 = zodOpenapi.z.object({
-  partyType: zodOpenapi.z.enum(PartyTypeZod),
+const partySchema$2 = zodOpenapi.z.object({
+  partyType: zodOpenapi.z.enum(PARTY_TYPE),
   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(),
+  customerStatus: zodOpenapi.z.enum(CUSTOMER_STATUS).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),
+  customerStatus: zodOpenapi.z.enum(CUSTOMER_STATUS),
+  partyType: zodOpenapi.z.enum(PARTY_TYPE),
   language: zodOpenapi.z.enum(generalCodes.LANGUAGE_CODES),
   id: zodOpenapi.z.uuid(),
   note: zodOpenapi.z.string().nullable(),
@@ -12925,7 +13039,7 @@ const partyOutputSchema$1 = zodOpenapi.z.object({
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
 });
-const createPartySchema = partySchema$1.omit({ id: true });
+const createPartySchema = partySchema$2.omit({ id: true });
 zodOpenapi.z.object({
   party: createPartySchema,
   personalData: individualInsertSchema$1.omit({ partyId: true }).nullable(),
@@ -12934,18 +13048,20 @@ zodOpenapi.z.object({
   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 })
+  aml: amlInsertSchema.omit({ partyId: true }),
+  products: productsInputSchema$2.optional()
 });
 zodOpenapi.z.object({
   partyId: zodOpenapi.z.uuid(),
-  party: partySchema$1,
+  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()
+  aml: amlUpdateSchema.optional(),
+  products: productsInputSchema$2.optional()
 });
 const partySelectOutputSchema = zodOpenapi.z.object({
   party: partyOutputSchema$1.nullable(),
@@ -12955,7 +13071,8 @@ const partySelectOutputSchema = zodOpenapi.z.object({
   bankAccounts: zodOpenapi.z.array(bankAccountSelectSchema).nullable(),
   disponents: zodOpenapi.z.array(disponentSelectSchema).nullable(),
   addresses: zodOpenapi.z.array(addressSelectSchema).nullable(),
-  recipients: zodOpenapi.z.array(recipientSelectSchema).nullable()
+  recipients: zodOpenapi.z.array(recipientSelectSchema).nullable(),
+  products: productsOutputSchema$1.nullable()
 });
 zodOpenapi.z.array(partySelectOutputSchema);
 const partySelectDataSchema = zodOpenapi.z.object({
@@ -12972,7 +13089,8 @@ const partySelectArrayDataSchema = zodOpenapi.z.object({
 });
 zodOpenapi.z.object({
   ...partySelectDataSchema.shape,
-  ...partySelectArrayDataSchema.shape
+  ...partySelectArrayDataSchema.shape,
+  products: productsOutputSchema$1.nullable()
 });
 
 createInsertSchema(partyChange);
@@ -13000,7 +13118,7 @@ createInsertSchema(partyRelationship);
 createUpdateSchema(partyRelationship);
 createSelectSchema(partyRelationship);
 zodOpenapi.z.object({
-  relationshipType: zodOpenapi.z.enum(PartyRelationshipTypeZod).optional(),
+  relationshipType: zodOpenapi.z.enum(PARTY_RELATIONSHIP_TYPE).optional(),
   frompartyId: zodOpenapi.z.uuid().optional().nullable(),
   internalId: zodOpenapi.z.string().optional().nullable(),
   topartyId: zodOpenapi.z.uuid().optional().nullable(),
@@ -13009,7 +13127,7 @@ zodOpenapi.z.object({
 });
 zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
-  relationshipType: zodOpenapi.z.enum(PartyRelationshipTypeZod).optional(),
+  relationshipType: zodOpenapi.z.enum(PARTY_RELATIONSHIP_TYPE).optional(),
   frompartyId: zodOpenapi.z.uuid().optional().nullable(),
   internalId: zodOpenapi.z.string().optional().nullable(),
   topartyId: zodOpenapi.z.uuid().optional().nullable(),
@@ -13199,7 +13317,7 @@ zod.z.object({
   id: zod.z.uuid()
 });
 
-const ALLOWED_ID_DOCUMENTS_FILTERS = {
+const ALLOWED_ID_DOCUMENTS_FILTERS$1 = {
   PARTY_ID: "filterIdDocumentPartyId",
   ISSUER: "filterIdDocumentIssuer"
 };
@@ -13211,8 +13329,8 @@ zod.z.object({
       column: zod.z.string(),
       direction: zod.z.enum(["asc", "desc"])
     }),
-    [ALLOWED_ID_DOCUMENTS_FILTERS.PARTY_ID]: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
-    [ALLOWED_ID_DOCUMENTS_FILTERS.ISSUER]: zod.z.union([zod.z.string(), zod.z.string().array()]).optional(),
+    [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()
   })
 });
@@ -13269,8 +13387,49 @@ 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(PARTY_TYPE),
+  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({
-  partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().optional(),
   name: zodOpenapi.z.string(),
   surname: zodOpenapi.z.string(),
@@ -13280,7 +13439,7 @@ const individualInsertSchema = zodOpenapi.z.object({
   birthPlace: zodOpenapi.z.string(),
   countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
   personalId: zodOpenapi.z.string(),
-  gender: zodOpenapi.z.enum(GenderZod),
+  gender: zodOpenapi.z.enum(GENDER),
   citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
   citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
   employer: zodOpenapi.z.string().optional(),
@@ -13297,6 +13456,183 @@ const individualInsertSchema = zodOpenapi.z.object({
   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(ADDRESS_TYPE),
+  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()
+});
+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(AML_SCORE_TYPE).optional(),
+  kycStatus: zodOpenapi.z.enum(KYC_STATUS).optional()
+});
+const productsInputSchema$1 = zodOpenapi.z.object({
+  txs: zodOpenapi.z.object({
+    fee: zodOpenapi.z.number(),
+    margin: zodOpenapi.z.number(),
+    reportingEmail: zodOpenapi.z.string().optional(),
+    clientType: zodOpenapi.z.enum(TXS_CLIENT_TYPE).optional()
+  }).optional(),
+  cbs: zodOpenapi.z.object({}).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),
+  products: productsInputSchema$1.optional()
+});
+const partyCreateOutputSchema = zodOpenapi.z.object({
+  customerStatus: zodOpenapi.z.enum(CUSTOMER_STATUS),
+  partyType: zodOpenapi.z.enum(PARTY_TYPE),
+  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(PARTY_TYPE),
+  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(),
@@ -13309,7 +13645,7 @@ const individualUpdateSchema = zodOpenapi.z.object({
   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(),
+  gender: zodOpenapi.z.enum(GENDER).optional(),
   citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
   citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
   employer: zodOpenapi.z.string().optional(),
@@ -13326,64 +13662,6 @@ const individualUpdateSchema = zodOpenapi.z.object({
   stayAbroad: zodOpenapi.z.boolean().optional(),
   stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional()
 });
-const individualOutputSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().nullable(),
-  name: zodOpenapi.z.string(),
-  surname: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().nullable(),
-  phone: zodOpenapi.z.string().nullable(),
-  birthDate: zodOpenapi.z.string().nullable(),
-  birthPlace: zodOpenapi.z.string(),
-  countryOfBirth: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  personalId: zodOpenapi.z.string(),
-  gender: zodOpenapi.z.enum(GenderZod),
-  citizenship: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  citizenshipOther: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  employer: zodOpenapi.z.string().nullable(),
-  employerCountry: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  registeredNumber: zodOpenapi.z.string(),
-  isPep: zodOpenapi.z.boolean(),
-  titleBefore: zodOpenapi.z.string().nullable(),
-  titleAfter: zodOpenapi.z.string().nullable(),
-  birthSurname: zodOpenapi.z.string().nullable(),
-  vocativeTitle: zodOpenapi.z.string().nullable(),
-  deathDate: zodOpenapi.z.coerce.date().nullable(),
-  deathNotification: zodOpenapi.z.coerce.date().nullable(),
-  pin: zodOpenapi.z.string().nullable(),
-  stayAbroad: zodOpenapi.z.boolean().nullable(),
-  stayAbroadCountries: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
-  createdAt: zodOpenapi.z.coerce.date().nullable(),
-  updatedAt: zodOpenapi.z.coerce.date().nullable()
-});
-
-zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().optional(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.email("Invalid email format").optional(),
-  phone: zodOpenapi.z.string().optional(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number().optional(),
-  prosecuted: zodOpenapi.z.string().optional(),
-  location: zodOpenapi.z.string().optional(),
-  fileNumber: zodOpenapi.z.string().optional(),
-  websiteUrl: zodOpenapi.z.url("Invalid website URL").optional(),
-  vatPayer: zodOpenapi.z.boolean(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessType: zodOpenapi.z.string().optional()
-});
 const organizationUpdateSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
   partyId: zodOpenapi.z.uuid().optional(),
@@ -13411,60 +13689,201 @@ const organizationUpdateSchema = zodOpenapi.z.object({
   operationCountries: zodOpenapi.z.string(),
   riskyBusinessType: zodOpenapi.z.string().optional()
 });
-zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().nullable(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().nullable(),
-  phone: zodOpenapi.z.string().nullable(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number().nullable(),
-  prosecuted: zodOpenapi.z.string().nullable(),
-  location: zodOpenapi.z.string().nullable(),
-  fileNumber: zodOpenapi.z.string().nullable(),
-  websiteUrl: zodOpenapi.z.string().nullable(),
-  vatPayer: zodOpenapi.z.boolean(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessType: zodOpenapi.z.string().nullable(),
-  createdAt: zodOpenapi.z.coerce.date().nullable(),
-  updatedAt: zodOpenapi.z.coerce.date().nullable()
-});
-const createOrganizationInputSchema = zodOpenapi.z.object({
+const updateBankAccountSchema = zodOpenapi.z.object({
+  ...bankAccountMetadataSchema.shape,
   partyId: zodOpenapi.z.uuid(),
   internalId: zodOpenapi.z.string().optional(),
-  businessName: zodOpenapi.z.string(),
-  email: zodOpenapi.z.string().optional(),
-  phone: zodOpenapi.z.string().optional(),
-  registeredNumber: zodOpenapi.z.string(),
-  registeredIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  operatesIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  presentIn: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2),
-  monthlyVolumeIn: zodOpenapi.z.number(),
-  monthlyVolumeOut: zodOpenapi.z.number(),
-  ownedBy: zodOpenapi.z.string(),
-  companyObjects: zodOpenapi.z.string(),
-  annualTurnover: zodOpenapi.z.number(),
-  numberOfEmployees: zodOpenapi.z.number(),
-  prosecuted: zodOpenapi.z.string().optional(),
-  location: zodOpenapi.z.string().optional(),
-  fileNumber: zodOpenapi.z.string().optional(),
-  websiteUrl: zodOpenapi.z.string().optional(),
-  vatPayer: zodOpenapi.z.boolean(),
-  companyObjectsDescription: zodOpenapi.z.string(),
-  turnover3years: zodOpenapi.z.number(),
-  operationCountries: zodOpenapi.z.string(),
-  riskyBusinessType: zodOpenapi.z.string().optional()
+  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(),
+  internalId: zodOpenapi.z.string().optional(),
+  addressType: zodOpenapi.z.enum(ADDRESS_TYPE),
+  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()
+});
+const updateAmlInputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  partyId: zodOpenapi.z.uuid().optional(),
+  internalId: zodOpenapi.z.string().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(AML_SCORE_TYPE).optional(),
+  kycStatus: zodOpenapi.z.enum(KYC_STATUS).optional()
+});
+const productsInputSchema = zodOpenapi.z.object({
+  txs: zodOpenapi.z.object({
+    fee: zodOpenapi.z.number(),
+    margin: zodOpenapi.z.number(),
+    reportingEmail: zodOpenapi.z.string().optional(),
+    clientType: zodOpenapi.z.enum(TXS_CLIENT_TYPE).optional()
+  }).optional(),
+  cbs: zodOpenapi.z.object({}).optional()
+});
+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(),
+  products: productsInputSchema.optional()
+});
+const updatePartyOuputSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.uuid(),
+  customerStatus: zodOpenapi.z.enum(CUSTOMER_STATUS),
+  partyType: zodOpenapi.z.enum(PARTY_TYPE),
+  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,
+      products: party.products ?? 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(CUSTOMER_STATUS),
+  partyType: zodOpenapi.z.enum(PARTY_TYPE),
+  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(),
+  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(GENDER),
+  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(),
@@ -13492,53 +13911,6 @@ const createOrganizationOutputSchema = zodOpenapi.z.object({
   operationCountries: zodOpenapi.z.string(),
   riskyBusinessType: zodOpenapi.z.string().nullable()
 });
-
-const disponentSchema = zodOpenapi.z.discriminatedUnion("partyType", [
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
-    data: individualInsertSchema.omit({ partyId: true })
-  }),
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("ORGANIZATION"),
-    data: createOrganizationInputSchema.omit({ partyId: true })
-  })
-]);
-const disponentUpdateSchema = zodOpenapi.z.discriminatedUnion("partyType", [
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
-    data: individualUpdateSchema
-  }),
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("ORGANIZATION"),
-    data: organizationUpdateSchema
-  })
-]);
-const disponentOutputSchema = zodOpenapi.z.discriminatedUnion("partyType", [
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("INDIVIDUAL"),
-    data: individualOutputSchema.nullable()
-  }),
-  zodOpenapi.z.object({
-    partyType: zodOpenapi.z.literal("ORGANIZATION"),
-    data: createOrganizationOutputSchema.nullable()
-  })
-]);
-
-const updateBankAccountSchema = zodOpenapi.z.object({
-  ...bankAccountMetadataSchema.shape,
-  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.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(),
@@ -13559,49 +13931,33 @@ const bankAccountOutputSchema = zodOpenapi.z.object({
   brBankNumber: zodOpenapi.z.string().nullable(),
   updatedAt: zodOpenapi.z.coerce.date().nullable()
 });
-
-const createAmlInputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid(),
-  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$1).optional(),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod$1).optional()
-});
-const updateAmlInputSchema = zodOpenapi.z.object({
+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().optional(),
-  internalId: zodOpenapi.z.string().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$1).optional(),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod$1).optional()
+  partyId: zodOpenapi.z.uuid(),
+  internalId: zodOpenapi.z.string().nullable(),
+  addressType: zodOpenapi.z.enum(ADDRESS_TYPE),
+  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()
 });
 const createAmlOutputSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.uuid(),
@@ -13622,142 +13978,200 @@ const createAmlOutputSchema = zodOpenapi.z.object({
   signatureMethod: zodOpenapi.z.string().nullable(),
   existencePeriod: zodOpenapi.z.string().nullable(),
   reputation: zodOpenapi.z.string().nullable(),
-  riskLevel: zodOpenapi.z.enum(AmlScoreTypeZod$1),
-  kycStatus: zodOpenapi.z.enum(KycStatusZod$1).nullable(),
-  createdAt: zodOpenapi.z.date().nullable(),
-  updatedAt: zodOpenapi.z.date().nullable()
-});
-
-const createAddressInputSchema = zodOpenapi.z.object({
-  partyId: zodOpenapi.z.uuid(),
-  addressType: zodOpenapi.z.enum(AddressTypeZod),
-  internalId: zodOpenapi.z.string().optional(),
-  street: zodOpenapi.z.string(),
-  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()
-});
-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()
-});
-const updateAddressInputSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.uuid(),
-  partyId: zodOpenapi.z.uuid(),
-  internalId: zodOpenapi.z.string().optional(),
-  addressType: zodOpenapi.z.enum(AddressTypeZod),
-  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()
-});
-
-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 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()
-});
-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(),
+  riskLevel: zodOpenapi.z.enum(AML_SCORE_TYPE),
+  kycStatus: zodOpenapi.z.enum(KYC_STATUS).nullable(),
   createdAt: zodOpenapi.z.date().nullable(),
   updatedAt: zodOpenapi.z.date().nullable()
 });
-const createPartyInputSchema = zodOpenapi.z.object({
-  party: partySchema.omit({ id: true }),
-  personalData: individualInsertSchema.omit({ partyId: true }).nullable(),
-  organizationData: createOrganizationInputSchema.omit({ partyId: true }).nullable(),
-  bankAccounts: zodOpenapi.z.array(bankAccountInputSchema),
-  disponents: zodOpenapi.z.array(disponentSchema),
-  addresses: zodOpenapi.z.array(createAddressInputSchema.omit({ partyId: true })),
-  aml: createAmlInputSchema.omit({ partyId: true }),
-  recipients: zodOpenapi.z.array(bankAccountInputSchema)
+const productsOutputSchema = zodOpenapi.z.object({
+  txs: zodOpenapi.z.object({
+    fee: zodOpenapi.z.number(),
+    margin: zodOpenapi.z.number(),
+    reportingEmail: zodOpenapi.z.string().nullable(),
+    clientType: zodOpenapi.z.enum(TXS_CLIENT_TYPE).nullable()
+  }).nullable(),
+  cbs: zodOpenapi.z.object({}).nullable()
 });
 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(),
   disponents: zodOpenapi.z.array(disponentOutputSchema).nullable(),
   addresses: zodOpenapi.z.array(createAddressOutputSchema).nullable(),
   aml: createAmlOutputSchema.nullable(),
-  recipients: zodOpenapi.z.array(bankAccountOutputSchema).nullable()
+  recipients: zodOpenapi.z.array(bankAccountOutputSchema).nullable(),
+  products: productsOutputSchema.nullable()
+});
+const responseBodySchema$3 = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  party: partyOutputSchema
+});
+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")
+  }
 });
-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()
+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 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 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(ID_DOC_TYPE),
+  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(ID_DOC_STATUS).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(),
-  idDocType: zodOpenapi.z.enum(IdDocTypeZod),
+  idDocType: zodOpenapi.z.enum(ID_DOC_TYPE),
   idDocNumber: zodOpenapi.z.string(),
   idDocHolderName: zodOpenapi.z.string(),
   issueDate: zodOpenapi.z.iso.datetime().nullable(),
@@ -13766,27 +14180,428 @@ const idDocumentOutputSchema = zodOpenapi.z.object({
   countryOfIssue: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).nullable(),
   frontImageUri: zodOpenapi.z.string().nullable(),
   backImageUri: zodOpenapi.z.string().nullable(),
-  idDocStatus: zodOpenapi.z.enum(IdDocStatusZod).nullable()
+  idDocStatus: zodOpenapi.z.enum(ID_DOC_STATUS).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(),
-  idDocType: zodOpenapi.z.enum(IdDocTypeZod).optional(),
+  idDocType: zodOpenapi.z.enum(ID_DOC_TYPE).optional(),
   idDocNumber: zodOpenapi.z.string().optional(),
   idDocHolderName: zodOpenapi.z.string().optional(),
   issueDate: zodOpenapi.z.coerce.date().optional(),
@@ -13795,32 +14610,112 @@ const idDocumentUpdateInputSchema = zodOpenapi.z.object({
   countryOfIssue: zodOpenapi.z.enum(generalCodes.COUNTRY_CODES_2).optional(),
   frontImageUri: zodOpenapi.z.string().optional(),
   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()
+  idDocStatus: zodOpenapi.z.enum(ID_DOC_STATUS).optional()
+});
+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$1;
-exports.ClientStatusActionZod = ClientStatusActionZod;
-exports.ContactTypeZod = ContactTypeZod$1;
-exports.CustomerStatusZod = CustomerStatusZod$1;
+exports.ADDRESS_TYPE = ADDRESS_TYPE$1;
+exports.AML_SCORE_TYPE = AML_SCORE_TYPE$1;
+exports.CLIENT_STATUS_ACTION = CLIENT_STATUS_ACTION;
+exports.CONTACT_TYPE = CONTACT_TYPE$1;
+exports.CUSTOMER_STATUS = CUSTOMER_STATUS$1;
 exports.DOCUMENT_SIDE = DOCUMENT_SIDE;
-exports.GenderZod = GenderZod$1;
-exports.IdDocStatusZod = IdDocStatusZod$1;
-exports.IdDocTypeZod = IdDocTypeZod$1;
-exports.IdentificationTypeZod = IdentificationTypeZod;
-exports.KycStatusZod = KycStatusZod$1;
-exports.PartyRelationshipTypeZod = PartyRelationshipTypeZod$1;
-exports.PartyTypeZod = PartyTypeZod$1;
+exports.GENDER = GENDER$1;
+exports.IDENTIFICATION_TYPE = IDENTIFICATION_TYPE;
+exports.ID_DOC_STATUS = ID_DOC_STATUS$1;
+exports.ID_DOC_TYPE = ID_DOC_TYPE$1;
+exports.KYC_STATUS = KYC_STATUS$1;
+exports.PARTY_RELATIONSHIP_TYPE = PARTY_RELATIONSHIP_TYPE$1;
+exports.PARTY_TYPE = PARTY_TYPE$1;
+exports.PRODUCT_TYPE = PRODUCT_TYPE$1;
 exports.TRADER_TYPE = TRADER_TYPE$1;
+exports.TXS_CLIENT_TYPE = TXS_CLIENT_TYPE$1;
 exports.createMdmClient = createMdmClient;
 exports.createPartyInputSchema = createPartyInputSchema;
 exports.idDocumentCreateInputSchema = idDocumentCreateInputSchema;
@@ -13832,6 +14727,8 @@ exports.messageResponseSchema = messageResponseSchema;
 exports.partiesOutputDataSchema = partiesOutputDataSchema;
 exports.partyCreateOutputSchema = partyCreateOutputSchema;
 exports.partyOutputSchema = partyOutputSchema;
-exports.partySchema = partySchema;
+exports.partySchema = partySchema$1;
 exports.partyUpdateInputSchema = partyUpdateInputSchema;
+exports.productsInputSchema = productsInputSchema$1;
+exports.productsOutputSchema = productsOutputSchema;
 exports.updatePartyOuputSchema = updatePartyOuputSchema;