@nexeraid/identity-schemas 1.12.22-dev → 1.12.24-dev

package/dist/chainalysis.schema-9e5926b9.esm.js

@@ -0,0 +1,2316 @@
+import { z } from 'zod';
+import { a2 as BlockchainAddress, z as AddressSchema, ak as Alpha2Country, ae as UuidString, dZ as _toConsumableArray, ai as ISO3CountryCode, a5 as BlockchainNamespace, br as SdkVerificationOutput, aA as CustomerStatus, d$ as _defineProperty, dQ as ProofOfResidenceCredentialSubjectSchema, ch as QrCodeLinkWithSchemaType, aB as BasicCustomerContactInformation, dW as CredentialType } from './identity-api.schema-2df73bbd.esm.js';
+
+// based on https://tech-doc.api.scorechain.com/
+var ANALYSIS_TYPES = ["ASSIGNED", "INCOMING", "OUTGOING", "FULL"];
+var AnalysisType = z["enum"](ANALYSIS_TYPES);
+var OBJECT_TYPES = ["TRANSACTION", "ADDRESS", "WALLET"];
+var ObjectType = z["enum"](OBJECT_TYPES);
+var BLOCKCHAIN_TYPES = ["BITCOIN", "BITCOINCASH", "LITECOIN", "DASH", "ETHEREUM", "RIPPLE", "TEZOS", "TRON", "BSC", "POLYGON", "AVALANCHE", "BASE", "SOLANA"];
+var Blockchain = z["enum"](BLOCKCHAIN_TYPES);
+var Coin = z.union([z.string(), z.literal("MAIN"), z.literal("ALL")]).describe("Coin (Use MAIN according to the docs)");
+var RiskSeverity = z["enum"](["CRITICAL_RISK", "HIGH_RISK", "MEDIUM_RISK", "LOW_RISK", "NO_RISK", "UNDEFINED_RISK"]);
+var EntityType = z["enum"](["Airdrop", "Bank", "Child abuse", "Closed exchange", "Cloud mining", "Community reported scam", "Cross-chain Bridge Protocol", "Custom group", "Darkweb", "Decentralized service", "Dex", "Donations", "Exchange", "Gambling", "Hack", "ICO", "Large unnamed entity", "Mining pool", "Mixing service", "NFT Marketplace", "OFAC sanction list", "Ongoing legal action", "Phishing", "Ransomware", "Sanction list", "Scam", "Service", "Suspicious", "Terrorism", "Token", "Wallet", "Staking pool"]);
+var AiItemResult = z.object({
+  type: EntityType.optional(),
+  percent: z.number()
+});
+var nullishAiDetails = z.object({
+  entityTypeClassifier: z.array(AiItemResult)
+}).nullish();
+var EntityMinimal = z.object({
+  id: z.number()["int"]().nullish(),
+  name: z.string(),
+  type: EntityType.optional(),
+  referenceAddress: BlockchainAddress,
+  aiDetails: nullishAiDetails.nullish()
+});
+var LinkedEntity = EntityMinimal;
+var RiskAssessment = z.object({
+  score: z.number()["int"]().gte(1).lte(100),
+  severity: RiskSeverity
+});
+var CustomRiskAssessment = RiskAssessment;
+var RiskIndicatorType = z["enum"](["ENTITY_TYPE", "ENTITY_COUNTRY", "BEHAVIOR"]);
+var BehavioralType = z["enum"](["Unspent output", "Block reward", "Peeling chain of unknown origin", "Payment channel", "Large unnamed entity", "Ignored small amounts", "Maximum exploration depth", "Large transaction", "Mixing pattern", "Secondary coin creation", "Secondary coin removal"]);
+var Countries = z.string();
+var RiskIndicatorReference = z.union([EntityType.optional(), BehavioralType.optional(), Countries]);
+var RiskIndicatorThresholdParameters = z.object({
+  referenceId: z.number()["int"](),
+  referenceName: RiskIndicatorReference.optional(),
+  threshold: z.number()["int"]()
+});
+var RiskIndicatorSetting = z.object({
+  id: z.number()["int"](),
+  type: RiskIndicatorType,
+  parameters: RiskIndicatorThresholdParameters
+});
+var AssignedScore = z.object({
+  hasResult: z["boolean"](),
+  result: z.object({
+    score: z.number()["int"]().min(0).max(100),
+    severity: RiskSeverity,
+    // enum
+    details: z.object({
+      entity: LinkedEntity.nullish(),
+      transaction: z.object({
+        type: z["enum"](["MINING", "MIXING", "LIGHTNING", "CROSS_CHAIN"]),
+        riskAssessment: RiskAssessment
+      }).nullish(),
+      customRiskAssessment: CustomRiskAssessment.nullish()
+    })
+  }).nullish(),
+  risks: z.array(RiskIndicatorSetting).nullish()
+});
+var ScoringResultType = z.union([EntityType, BehavioralType]);
+var ScoringItem = z.object({
+  referenceAddress: BlockchainAddress,
+  amount: z.number(),
+  amountUsd: z.number().nullish(),
+  percentage: z.number(),
+  name: z.string(),
+  type: ScoringResultType.optional(),
+  countries: z.array(Countries),
+  score: z.number()["int"]().min(0).max(100),
+  severity: RiskSeverity,
+  aiDetails: nullishAiDetails.nullish()
+});
+var ScoringRiskItem = z.object({
+  setting: RiskIndicatorSetting,
+  causes: z.array(ScoringItem).nullish()
+});
+var DynamicScore = z.object({
+  hasResult: z["boolean"](),
+  result: z.object({
+    score: z.number()["int"]().min(0).max(100),
+    severity: RiskSeverity,
+    details: z.array(ScoringItem).nullish(),
+    risks: z.array(ScoringRiskItem).nullish()
+  }).nullish()
+});
+var WALLET_NOT_FOUND = z.object({
+  error: z.literal("NOT_FOUND_WALLET"),
+  message: z.string()
+});
+var INVALID_PARAMETER_BLOCKCHAIN = z.object({
+  error: z.literal("INVALID_PARAMETER_BLOCKCHAIN"),
+  message: z.string()
+});
+var UNAUTHORIZED = z.object({
+  error: z.literal("UNAUTHORIZED"),
+  message: z.string()
+});
+var FORBIDDEN_LICENSE_LIMIT_REACHED = z.object({
+  error: z.literal("FORBIDDEN_LICENSE_LIMIT_REACHED"),
+  message: z.string()
+});
+var NOT_FOUND_TRANSACTION = z.object({
+  error: z.literal("NOT_FOUND_TRANSACTION"),
+  message: z.string()
+});
+var UNPROCESSABLE_GLOBAL_SCORE = z.object({
+  error: z.literal("UNPROCESSABLE_GLOBAL_SCORE"),
+  message: z.string()
+});
+var SERVER_ERROR = z.object({
+  error: z.literal("SERVER_ERROR"),
+  message: z.string()
+});
+var UNKNOWN_ERROR$3 = z.object({
+  error: z.literal("UNKNOWN_ERROR"),
+  message: z.string()
+}).describe("This is a fallback error, if scorechain parser fails");
+var RESULT_PARSER_ERROR$3 = z.object({
+  error: z.literal("RESULT_PARSER_ERROR"),
+  message: z.string(),
+  data: z.string()
+}).describe("This is a fallback error, if zod parse fails on result");
+var ScorechainErrorResponse = z.union([z.discriminatedUnion("error", [WALLET_NOT_FOUND, INVALID_PARAMETER_BLOCKCHAIN, UNAUTHORIZED, FORBIDDEN_LICENSE_LIMIT_REACHED, NOT_FOUND_TRANSACTION, UNPROCESSABLE_GLOBAL_SCORE, SERVER_ERROR, UNKNOWN_ERROR$3, RESULT_PARSER_ERROR$3]), z.object({
+  error: z.string(),
+  message: z.string()
+})]);
+var ScorechainError = z.object({
+  error: ScorechainErrorResponse
+});
+var ScorechainAnalysis = z.object({
+  id: z.string().uuid(),
+  analysis: z.object({
+    assigned: AssignedScore,
+    incoming: DynamicScore.nullish(),
+    outgoing: DynamicScore.nullish()
+  }),
+  lowestScore: z.number()["int"]().min(0).max(100)
+});
+var ScoringAnalysisResponse = z.union([ScorechainAnalysis, ScorechainError]);
+var ScoringAnalysisRequest = z.object({
+  analysisType: AnalysisType.nullish(),
+  objectType: ObjectType.nullish(),
+  objectId: z.string().nullish().describe("Address or transaction hash, depending on objectType"),
+  blockchain: Blockchain.nullish(),
+  coin: Coin.nullish(),
+  depth: z.coerce.number()["int"]().gte(1).lte(100).nullish()
+});
+var WorkflowsScoringAnalysisRequest = z.object({
+  analysisType: AnalysisType.nullish(),
+  objectType: ObjectType.nullish(),
+  objectId: z.string().nullish().describe("Address or transaction hash, depending on objectType"),
+  blockchain: Blockchain.nullish(),
+  coin: Coin["default"]("MAIN"),
+  depth: z.coerce.number()["int"]().gte(1).lte(100)["default"](1)
+});
+
+var IpQualityAnalysisRequest = z.object({
+  apiKey: z.string().nullish(),
+  ipValue: z.string().nullish(),
+  userEmail: z.string().nullish(),
+  userPhoneNumber: z.string().nullish()
+});
+var IpQualityAnalysisResponse = z.object({
+  success: z["boolean"](),
+  request_id: z.string(),
+  message: z.string().nullish(),
+  fraud_score: z.number()["int"]().min(0).max(100).nullish(),
+  country_code: z.string().nullish(),
+  region: z.string().nullish(),
+  city: z.string().nullish(),
+  ISP: z.string().nullish(),
+  ASN: z.number().nullish(),
+  organization: z.string().nullish(),
+  is_crawler: z["boolean"]().nullish(),
+  timezone: z.string().nullish(),
+  mobile: z["boolean"]().nullish(),
+  host: z.string().nullish(),
+  proxy: z["boolean"]().nullish(),
+  vpn: z["boolean"]().nullish(),
+  tor: z["boolean"]().nullish(),
+  active_vpn: z["boolean"]().nullish(),
+  active_tor: z["boolean"]().nullish(),
+  recent_abuse: z["boolean"]().nullish(),
+  bot_status: z["boolean"]().nullish(),
+  connection_type: z.string().nullish(),
+  abuse_velocity: z.string().nullish(),
+  zip_code: z.string().nullish(),
+  latitude: z.number().nullish(),
+  longitude: z.number().nullish()
+});
+var EmailVerificationAnalysisResponse = z.object({
+  success: z["boolean"](),
+  request_id: z.string(),
+  message: z.string().nullish(),
+  valid: z["boolean"]().nullish(),
+  timed_out: z["boolean"]().nullish(),
+  disposable: z["boolean"]().nullish(),
+  first_name: z.string().nullish(),
+  deliverability: z.string().nullish(),
+  smtp_score: z.number().nullish(),
+  overall_score: z.number().nullish(),
+  catch_all: z["boolean"]().nullish(),
+  generic: z["boolean"]().nullish(),
+  common: z["boolean"]().nullish(),
+  dns_valid: z["boolean"]().nullish(),
+  honeypot: z["boolean"]().nullish(),
+  frequent_complainer: z["boolean"]().nullish(),
+  suspect: z["boolean"]().nullish(),
+  recent_abuse: z["boolean"]().nullish(),
+  fraud_score: z.number().min(0).max(100).nullish(),
+  leaked: z["boolean"]().nullish(),
+  suggested_domain: z.string().nullish(),
+  domain_velocity: z.string().nullish(),
+  user_activity: z.string().nullish(),
+  associated_names: z.object({
+    status: z.string().nullish(),
+    names: z.array(z.string()).nullish()
+  }).nullish(),
+  associated_phone_numbers: z.object({
+    status: z.string().nullish(),
+    phone_numbers: z.array(z.string()).nullish()
+  }).nullish(),
+  first_seen: z.object({
+    human: z.string().nullish(),
+    timestamp: z.number().nullish(),
+    iso: z.string().nullish()
+  }).nullish(),
+  domain_age: z.object({
+    human: z.string().nullish(),
+    timestamp: z.number().nullish(),
+    iso: z.string().nullish()
+  }).nullish(),
+  spam_trap_score: z.string().nullish(),
+  sanitized_email: z.string().nullish()
+});
+var PhoneVerificationAnalysisResponse = z.object({
+  success: z["boolean"](),
+  request_id: z.string(),
+  message: z.string().nullish(),
+  formatted: z.string().nullish(),
+  local_format: z.string().nullish(),
+  valid: z["boolean"]().nullish(),
+  fraud_score: z.number().min(0).max(100).nullish(),
+  recent_abuse: z["boolean"]().nullish(),
+  VOIP: z["boolean"]().nullish(),
+  prepaid: z["boolean"]().nullish(),
+  risky: z["boolean"]().nullish(),
+  active: z["boolean"]().nullish(),
+  name: z.string().nullish(),
+  carrier: z.string().nullish(),
+  line_type: z.string().nullish(),
+  country: z.string().nullish(),
+  region: z.string().nullish(),
+  city: z.string().nullish(),
+  timezone: z.string().nullish(),
+  zip_code: z.string().nullish(),
+  dialing_code: z.number().nullish(),
+  do_not_call: z["boolean"]().nullish(),
+  leaked: z["boolean"]().nullish(),
+  spammer: z["boolean"]().nullish(),
+  active_status: z.string().nullish(),
+  user_activity: z.string().nullish(),
+  associated_email_addresses: z.object({
+    status: z.string().nullish(),
+    emails: z.array(z.string()).nullish()
+  }).nullish()
+});
+var IpQualityServiceAnalysis = z.object({
+  ipVerification: IpQualityAnalysisResponse.nullish(),
+  emailVerification: EmailVerificationAnalysisResponse.nullish(),
+  phoneVerification: PhoneVerificationAnalysisResponse.nullish(),
+  error: z.string().nullish()
+});
+var UNAUTHORIZED_KEY = z.object({
+  success: z["boolean"](),
+  message: z.literal("Invalid or unauthorized key. Please check the API key and try again."),
+  request_id: z.string()
+});
+var UNKNOWN_ERROR$2 = z.object({
+  error: z.literal("UNKNOWN_ERROR"),
+  message: z.string()
+}).describe("This is a fallback error, if IPQualityScore parser fails");
+var RESULT_PARSER_ERROR$2 = z.object({
+  error: z.literal("RESULT_PARSER_ERROR"),
+  message: z.string(),
+  data: z.string()
+}).describe("This is a fallback error, if zod parse fails on result");
+var IpQualityServiceErrorResponse = z.union([UNAUTHORIZED_KEY, UNKNOWN_ERROR$2, RESULT_PARSER_ERROR$2]);
+var IpQualityServiceAnalysisResponse = z.union([z.object({
+  error: IpQualityServiceErrorResponse
+}), IpQualityServiceAnalysis]);
+
+var BigCryptoChain = z["enum"](["btc",
+// Bitcoin
+"eth",
+// Ethereum
+"ltc",
+// Litecoin
+"bch",
+// Bitcoin Cash
+"xrp",
+// Ripple
+"xlm",
+// Stellar
+"sys",
+// Syscoin
+"xdc",
+// XDC Network
+"doge",
+// Dogecoin
+"dash",
+// Dash
+"zec",
+// Zcash
+"trx",
+// Tron
+"etc",
+// Ethereum Classic
+"bsc" // Binance Smart Chain
+]);
+var BigPropertiesLiteral = [z.literal("score").describe("BitRank Verified®score for a public key hash of an address for your chosen cryptocurrency."), z.literal("entities").describe("Array of entity objects associated with the address."), z.literal("flags").describe("Array of flags associated with the address."), z.literal("currency").describe("The type of cryptocurrency being queried."), z.literal("new_address").describe("Boolean indicating if the address is new."), z.literal("flags_with_category").describe("Array of flag objects with categories associated with the address."), z.literal("cluster").describe("Object containing information about the cluster associated with the address."), z.literal("first_seen_receiving").describe("Timestamp of the first time the address received funds."), z.literal("first_seen_sending").describe("Timestamp of the first time the address sent funds."), z.literal("last_seen_receiving").describe("Timestamp of the last time the address received funds."), z.literal("last_seen_sending").describe("Timestamp of the last time the address sent funds."), z.literal("received_amount").describe("Total amount of cryptocurrency received by the address in Satoshis."), z.literal("sent_amount").describe("Total amount of cryptocurrency sent from the address in Satoshis."), z.literal("number_of_transactions").describe("Total number of transactions associated with the address."), z.literal("received_transactions").describe("Number of transactions where the address received funds."), z.literal("sent_transactions").describe("Number of transactions where the address sent funds."), z.literal("balance").describe("Balance of cryptocurrency at the address in Satoshis."), z.literal("balance_fiat").describe("Balance of cryptocurrency at the address in fiat currency (JPY, EUR, USD, CAD)."), z.literal("bitrank_counterparty_exposure").describe("Distribution of BitRank® scores by count and volume."), z.literal("entity_counterparty_exposure").describe("Distribution of entities by count and volume."), z.literal("flag_counterparty_exposure").describe("Distribution of flags by count and volume.")];
+var BigProperties = ["score", "entities", "flags", "currency", "new_address", "flags_with_category", "cluster", "first_seen_receiving", "first_seen_sending", "last_seen_receiving", "last_seen_sending", "received_amount", "sent_amount", "number_of_transactions", "received_transactions", "sent_transactions", "balance", "balance_fiat", "bitrank_counterparty_exposure", "entity_counterparty_exposure", "flag_counterparty_exposure"];
+var BigProperty = z["enum"](BigProperties);
+var RequestProperty = z.object({
+  property: BigProperty
+}).describe("A comma-separated list of properties that will determine if the property is in the response.");
+
+/**
+ * Example usage:
+ * ```
+ *  const requestObject = bitRankRequestSchema.parse({
+ *   crypto: "btc",
+ *   address: "1J3BDU4wHgxk5bHky8EiDnptX39dYgdDGj",
+ *   properties: ["score", "entities", "flags"],
+ *   label: "myLabel",
+ *   apiKey: "Your API Key Goes Here",
+ * });
+ * ```
+ *
+ */
+var BitRankRequest = z.object({
+  crypto: BigCryptoChain["default"]("eth").nullish(),
+  address: AddressSchema.nullish(),
+  properties: z.array(RequestProperty).describe("Optional query parameter to specify properties to include in the response.").nullish()["default"]([{
+    property: "score"
+  }]),
+  label: z.string().max(255).optional().describe("Optional string of up to 255 characters for labeling the search.").nullish(),
+  transactionsPerPage: z.number().optional().describe("Optional parameter to specify the number of transactions per page in the response.").nullish()
+});
+var BitRankVerified = z.object({
+  label: z.string(),
+  currency: z.string(),
+  new_address: z["boolean"](),
+  score: z.number(),
+  entities: z.array(z.object({
+    label: z.string(),
+    type: z.string()
+  })),
+  flags: z.array(z.string()),
+  flags_with_category: z.array(z.object({
+    name: z.string(),
+    category: z.string()
+  })),
+  cluster: z.object({
+    cluster_name: z.string(),
+    cluster_identifier: z.number(),
+    number_of_addresses_in_cluster: z.number()
+  }),
+  first_seen_receiving: z.number(),
+  first_seen_sending: z.number(),
+  last_seen_receiving: z.number(),
+  last_seen_sending: z.number(),
+  received_amount: z.number(),
+  sent_amount: z.number(),
+  number_of_transactions: z.number(),
+  received_transactions: z.number(),
+  sent_transactions: z.number(),
+  balance: z.number(),
+  balance_fiat: z.object({
+    jpy: z.number(),
+    eur: z.number(),
+    usd: z.number(),
+    cad: z.number()
+  }),
+  bitrank_counterparty_exposure: z.object({
+    "in": z.object({
+      updatedAt: z.number(),
+      totalVolume: z.number(),
+      exposure: z.array(z.object({
+        min: z.number(),
+        max: z.number(),
+        count: z.number(),
+        volume: z.number()
+      }))
+    }),
+    out: z.object({
+      updatedAt: z.number(),
+      totalVolume: z.number(),
+      exposure: z.array(z.object({
+        min: z.number(),
+        max: z.number(),
+        count: z.number(),
+        volume: z.number()
+      }))
+    })
+  }),
+  entity_counterparty_exposure: z.object({
+    "in": z.object({
+      updatedAt: z.number(),
+      totalVolume: z.number(),
+      exposure: z.array(z.object({
+        name: z.string(),
+        count: z.number(),
+        volume: z.number()
+      }))
+    }),
+    out: z.object({
+      updatedAt: z.number(),
+      totalVolume: z.number(),
+      exposure: z.array(z.object({
+        name: z.string(),
+        count: z.number(),
+        volume: z.number()
+      }))
+    })
+  }),
+  flag_counterparty_exposure: z.object({
+    "in": z.object({
+      updatedAt: z.number(),
+      totalVolume: z.number(),
+      exposure: z.array(z.object({
+        name: z.string(),
+        count: z.number(),
+        volume: z.number()
+      }))
+    }),
+    out: z.object({
+      updatedAt: z.number(),
+      totalVolume: z.number(),
+      exposure: z.array(z.object({
+        name: z.string(),
+        count: z.number(),
+        volume: z.number()
+      }))
+    })
+  }),
+  transactions: z.array(z.object({
+    hash: z.string(),
+    amount: z.number(),
+    fees: z.number()
+  }))
+}).partial();
+var INVALID_ADDRESS = z.object({
+  statusCode: z.literal(400),
+  errorCode: z.literal("INVALID_ADDRESS"),
+  message: z.literal("The address provided isn't a valid address.")
+});
+var API_KEY_NOT_FOUND = z.object({
+  statusCode: z.literal(401),
+  errorCode: z.literal("API_KEY_NOT_FOUND"),
+  message: z.literal("Your API key is not found.")
+});
+var API_KEY_ARCHIVED = z.object({
+  statusCode: z.literal(403),
+  errorCode: z.literal("API_KEY_ARCHIVED"),
+  message: z.literal("Your API key is archived.")
+});
+var API_KEY_DISABLED = z.object({
+  statusCode: z.literal(403),
+  errorCode: z.literal("API_KEY_DISABLED"),
+  message: z.literal("Your API key is disabled.")
+});
+var SOURCE_IP_NOT_EQ_API_KEY_IPS = z.object({
+  statusCode: z.literal(403),
+  errorCode: z.literal("SOURCE_IP_NOT_EQ_API_KEY_IPS"),
+  message: z.literal("Your source IP does not match the IPs for your API key.")
+});
+var INTERNAL_SERVER_ERROR = z.object({
+  statusCode: z.literal(500),
+  errorCode: z.literal("INTERNAL_SERVER_ERROR"),
+  message: z.literal("INTERNAL SERVER ERROR")
+});
+var UNKNOWN_ERROR$1 = z.object({
+  statusCode: z.literal(500),
+  errorCode: z.literal("UNKNOWN_ERROR"),
+  message: z.string()
+}).describe("This is a fallback error, if bit rank parser fails");
+var RESULT_PARSER_ERROR$1 = z.object({
+  statusCode: z.literal(500),
+  errorCode: z.literal("RESULT_PARSER_ERROR"),
+  message: z.string(),
+  data: z.string()
+}).describe("This is a fallback error, if zod parse fails on result");
+var BitRankVerifiedErrorResponse = z.union([INVALID_ADDRESS, API_KEY_NOT_FOUND, API_KEY_ARCHIVED, API_KEY_DISABLED, SOURCE_IP_NOT_EQ_API_KEY_IPS, INTERNAL_SERVER_ERROR, UNKNOWN_ERROR$1, RESULT_PARSER_ERROR$1]);
+var BitRankVerifiedError = z.object({
+  error: BitRankVerifiedErrorResponse
+});
+var BitRankVerifiedResponse = z.union([BitRankVerifiedError, BitRankVerified]);
+
+var Statuses = ["APPROVED", "SUBMISSION_REQUIRED", "RESUBMISSION_REQUIRED", "REJECTED", "PENDING_VERIFICATION"];
+var Status$1 = z["enum"](Statuses);
+var WebhookPayload = z.object({
+  reason: z.string(),
+  service: z.string(),
+  session_id: z.string(),
+  status: Status$1.optional().nullish(),
+  step_id: z.string()
+});
+var NestedSession = z.object({
+  alias: z.string(),
+  id: z.string(),
+  status: Status$1,
+  sandbox: z["boolean"](),
+  steps: z.array(z.object({
+    id: z.string(),
+    status: Status$1,
+    type: z.string()
+  }))
+});
+var Session = z.object({
+  app: z.object({
+    name: z.string(),
+    id: z.string()
+  }),
+  session: NestedSession
+});
+var SessionWithoutSteps = z.object({
+  app: z.object({
+    name: z.string(),
+    id: z.string()
+  }),
+  session: NestedSession.omit({
+    steps: true
+  })
+});
+var StepTypes = ["ID_DOCUMENT", "LIVENESS", "PROOF_OF_ADDRESS", "PHONE", "EMAIL"];
+var StepType = z["enum"](StepTypes);
+var ReasonCodes = ["FORGED_REJECTION", "DOCUMENT_HIDDEN", "BAD_ENVIRONMENT", "BLACK_WHITE_PICTURE", "BAD_QUALITY", "DOCUMENT_COMPLIANCE", "IDENTITY_DOCUMENT_EXPIRED", "DOCUMENT_INVALID_FRONT_SIDE", "DOCUMENT_INVALID_BACK_SIDE", "IDENTITY_DOCUMENT_DOB_DATE_MINOR", "RESTRICTED_NATIONALITY_TYPE", "DUPLICATE_USER", ""];
+var ReasonCode = z["enum"](ReasonCodes);
+var File = z.object({
+  url: z.string(),
+  type: z.string(),
+  size: z.number(),
+  base64: z.string().nullish()
+});
+var DocumentIdTypes = ["PASSPORT", "NATIONAL_ID", "DRIVER_LICENSE", "RESIDENT_PERMIT", ""];
+var DocumentIdType = z["enum"](DocumentIdTypes);
+var DocumentIdMetadata = z.object({
+  country: z.string(),
+  type: DocumentIdType,
+  fields: z.object({
+    firstname: z.string(),
+    lastname: z.string(),
+    birth_date: z.string(),
+    document_expiration: z.string(),
+    document_number: z.string(),
+    nationality: z.string()
+  }),
+  files: z.object({
+    front: File.nullish(),
+    back: File.nullish(),
+    face: File.nullish()
+  }),
+  original_files: z.object({
+    front: File.nullish(),
+    back: File.nullish()
+  })
+});
+var ProofOfAddressDocumentTypes = ["ELECTRICITY_BILL", "INTERNET_BILL", "LANDLINE_BILL", "WATER_BILL", "GAS_BILL", "BANK_STATEMENT"];
+var ProofOfAddressDocumentType = z["enum"](ProofOfAddressDocumentTypes);
+var ProofOfAddressMetadata = z.object({
+  country: z.string(),
+  type: ProofOfAddressDocumentType,
+  host_id_document: z.object({}),
+  files: z.object({
+    proof: File.nullish(),
+    accomodation: File.nullish()
+  }),
+  original_files: z.object({
+    proof: File.nullish(),
+    accomodation: File.nullish()
+  }),
+  fields: z.object({
+    address: z.string(),
+    city: z.string(),
+    zipcode: z.string(),
+    issuing_date: z.string()
+  })
+});
+var LivenessMetadata = z.object({
+  liveness: z.object({
+    file: File
+  })
+});
+var PhoneMetadata = z.object({
+  phone: z.object({
+    number: z.string(),
+    calling_code: z.string(),
+    method: z.string(),
+    country: z.string()
+  })
+});
+var EmailMetadata = z.object({
+  email: z.object({
+    value: z.string().email()
+  })
+});
+var AMLMetadata = z.object({
+  aml: z.object({
+    customer_info: z.object({
+      firstname: z.string(),
+      lastname: z.string(),
+      birth_date: z.string(),
+      nationality: z.string(),
+      country: z.string()
+    }),
+    hits: z.array(z.object({
+      fields: z.array(z.unknown()),
+      aliases: z.array(z.string()),
+      media: z.array(z.object({
+        date: z.string(),
+        snippet: z.string(),
+        title: z.string(),
+        url: z.string()
+      })),
+      info: z.object({
+        full_name: z.string(),
+        birth_date: z.string(),
+        nationality: z.string()
+      }),
+      type: z.array(z.string())
+    })),
+    total_hits: z.number(),
+    action_required: z["boolean"](),
+    monitored: z["boolean"]()
+  })
+});
+var Step = z.object({
+  id: z.string(),
+  type: StepType,
+  metadata: z.object({
+    ip: z.string(),
+    user_agent: z.string(),
+    platform: z.string(),
+    browser_name: z.string(),
+    browser_version: z.string(),
+    device: z.string(),
+    customer_language: z.string()
+  }),
+  status: Status$1,
+  reason: z.object({
+    code: ReasonCode,
+    message: z.object({
+      original: z.string(),
+      translated: z.string()
+    })
+  }).nullish(),
+  document: z.union([DocumentIdMetadata, ProofOfAddressMetadata]).nullish(),
+  verification: z.union([LivenessMetadata, PhoneMetadata, EmailMetadata, AMLMetadata]).nullish()
+});
+var SynapsSessionEvent = z.object({
+  status: Status$1,
+  alias: z.string(),
+  sandbox: z["boolean"]()
+});
+var SynapsStepEvent = z.object({
+  status: Status$1,
+  type: StepType,
+  sandbox: z["boolean"](),
+  metadata: z.object({
+    ip: z.string(),
+    user_agent: z.string(),
+    platform: z.string(),
+    browser_name: z.string(),
+    browser_version: z.string(),
+    device: z.string(),
+    customer_language: z.string()
+  })
+});
+var typeToHumanReadable = function typeToHumanReadable(type) {
+  switch (type) {
+    case "ID_DOCUMENT":
+      return "Document ID check";
+    case "LIVENESS":
+      return "Liveness check";
+    case "PROOF_OF_ADDRESS":
+      return "Proof of address check";
+    case "PHONE":
+      return "Phone verification";
+    case "EMAIL":
+      return "Email verification";
+    default:
+      return type;
+  }
+};
+var SynapsSessionRequest = z.object({
+  sessionId: z.string()
+});
+var SESSION_NOT_FOUND = z.object({
+  code: z.number(),
+  message: z.literal("This session is not found")
+});
+var UNKNOWN_ERROR = z.object({
+  code: z.literal(1),
+  message: z.literal("Synaps unknown error")
+}).describe("This is a fallback error, if synaps parser fails");
+var RESULT_PARSER_ERROR = z.object({
+  code: z.literal(2),
+  message: z.string(),
+  data: z.string()
+}).describe("This is a fallback error, if zod parse fails on result");
+var SynapsSessionErrorResponse = z.union([SESSION_NOT_FOUND, UNKNOWN_ERROR, RESULT_PARSER_ERROR]);
+var SynapsSessionResponse = z.union([z.object({
+  success: z.literal(true),
+  data: Session
+}), z.object({
+  success: z.literal(false),
+  error: SynapsSessionErrorResponse
+})]);
+var SynapsStepRequest = z.object({
+  sessionId: z.string(),
+  stepId: z.string()
+});
+var STEP_NOT_FOUND = z.object({
+  code: z.number(),
+  message: z.literal("This step ID is invalid")
+});
+var SynapsStepErrorResponse = z.union([STEP_NOT_FOUND, UNKNOWN_ERROR, RESULT_PARSER_ERROR]);
+var SynapsStepResponse = z.union([z.object({
+  success: z.literal(true),
+  data: Step
+}), z.object({
+  success: z.literal(false),
+  error: SynapsStepErrorResponse
+})]);
+
+var CoerceDateUTC = z.preprocess(function (value) {
+  if (!value) return;
+  if (value instanceof Date) {
+    return value;
+  }
+  var valueString = value;
+  var inputDate = valueString.endsWith("Z") ? valueString : valueString + "Z";
+  return new Date(inputDate);
+}, z.date());
+var SEARCH_FILTER_SANCTION_TYPE = ["sanction", "warning", "fitness-probity"];
+var SearchFilterSanctionType = z["enum"](SEARCH_FILTER_SANCTION_TYPE);
+var SEARCH_FILTER_PEP_TYPE = ["pep", "pep-class-1", "pep-class-2", "pep-class-3", "pep-class-4"];
+var SearchFilterPepType = z["enum"](SEARCH_FILTER_PEP_TYPE);
+var SEARCH_FILTER_ADVERSE_MEDIA_TYPE = ["adverse-media", "adverse-media-financial-crime", "adverse-media-violent-crime", "adverse-media-sexual-crime", "adverse-media-terrorism", "adverse-media-fraud", "adverse-media-narcotics", "adverse-media-general", "adverse-media-v2-property", "adverse-media-v2-financial-aml-cft", "adverse-media-v2-fraud-linked", "adverse-media-v2-narcotics-aml-cft", "adverse-media-v2-violence-aml-cft", "adverse-media-v2-terrorism", "adverse-media-v2-cybercrime", "adverse-media-v2-general-aml-cft", "adverse-media-v2-regulatory", "adverse-media-v2-financial-difficulty", "adverse-media-v2-violence-non-aml-cft", "adverse-media-v2-other-financial", "adverse-media-v2-other-serious", "adverse-media-v2-other-minor"];
+var SearchFilterAdverseMediaType = z["enum"](SEARCH_FILTER_ADVERSE_MEDIA_TYPE);
+var HIGH_RISK_TYPES = ["sanction", "pep", "pep-class-1", "pep-class-2", "pep-class-3", "pep-class-4"];
+var MEDIUM_RISK_TYPES = ["adverse-media-financial-crime", "adverse-media-violent-crime", "adverse-media-sexual-crime", "adverse-media-terrorism", "adverse-media-fraud", "adverse-media-narcotics", "adverse-media-general", "adverse-media-v2-financial-aml-cft", "adverse-media-v2-fraud-linked", "adverse-media-v2-narcotics-aml-cft", "adverse-media-v2-violence-aml-cft", "adverse-media-v2-terrorism", "adverse-media-v2-cybercrime", "adverse-media-v2-general-aml-cft", "adverse-media-v2-regulatory", "adverse-media-v2-other-financial", "adverse-media-v2-other-serious"];
+var COMPLY_ADVANTAGE_RESPONSE_MATCH_TYPE = ["name_exact", "aka_exact", "name_fuzzy", "aka_fuzzy", "phonetic_name", "phonetic_aka", "equivalent_name", "equivalent_aka", "unknown", "year_of_birth", "removed_personal_title", "removed_personal_suffix", "removed_organisation_prefix", "removed_organisation_suffix", "removed_clerical_mark"];
+var ComplyAdvantageResponseMatchType = z["enum"](COMPLY_ADVANTAGE_RESPONSE_MATCH_TYPE);
+var mappingMatchTypeToLabel = {
+  name_exact: "Name Exact",
+  aka_exact: "Aka Exact",
+  name_fuzzy: "Name Fuzzy",
+  aka_fuzzy: "Aka Fuzzy",
+  phonetic_name: "Phonetic Name",
+  phonetic_aka: "Phonetic Aka",
+  equivalent_name: "Equivalent Name",
+  equivalent_aka: "Equivalent Aka",
+  unknown: "Unknown",
+  year_of_birth: "Year of Birth",
+  removed_personal_title: "Removed Personal Title",
+  removed_personal_suffix: "Removed Personal Suffix",
+  removed_organisation_prefix: "Removed Organisation Prefix",
+  removed_organisation_suffix: "Removed Organisation Suffix",
+  removed_clerical_mark: "Removed Clerical Mark"
+};
+var COMPLY_ADVANTAGE_RESPONSE_MATCH_STATUS = ["no_match", "false_positive", "potential_match", "true_positive", "unknown", "true_positive_approve", "true_positive_reject"];
+var ComplyAdvantageReponseMatchStatus = z["enum"](COMPLY_ADVANTAGE_RESPONSE_MATCH_STATUS);
+var SEARCH_FILTER_TYPES = [].concat(SEARCH_FILTER_SANCTION_TYPE, SEARCH_FILTER_PEP_TYPE, SEARCH_FILTER_ADVERSE_MEDIA_TYPE);
+var SearchFilterType = z["enum"](SEARCH_FILTER_TYPES);
+var SearchEntityTypes = ["person", "company", "organisation", "vessel", "aircraft"];
+var SearchEntityType = z["enum"](SearchEntityTypes);
+var SearchFilters = z.object({
+  types: z.array(SearchFilterType).nullish(),
+  birth_year: z.number().nullish(),
+  remove_deceased: z.number().min(0).max(1).nullish(),
+  entity_type: SearchEntityType.nullish(),
+  country_codes: z.array(Alpha2Country).nullish()
+});
+var COMPLY_ADVANTAGE_NATIONALITY_FIELD_SOURCES = ["complyadvantage", "north-atlantic-treaty-organisation", "complyadvantage-adverse-media"];
+var ComplyAdvantageNationalityFieldSources = z["enum"](SearchEntityTypes);
+var COMPLY_ADVANTAGE_COUNTRY_FIELD_SOURCES = ["Belarus", "complyadvantage-adverse-media", "company-am", "complyadvantage-adverse-media", "iran-ministry-of-foreign-affairs-sanctions-list", "complyadvantage-adverse-media"];
+var ComplyAdvantageCountryFieldSources = z["enum"](COMPLY_ADVANTAGE_COUNTRY_FIELD_SOURCES);
+var COMPLY_ADVANTAGE_DATE_OF_BIRTH_FIELD_SOURCES = ["complyadvantage", "complyadvantage-adverse-media"];
+var ComplyAdvantageDateOfBirthFieldSources = z["enum"](COMPLY_ADVANTAGE_DATE_OF_BIRTH_FIELD_SOURCES);
+// https://docs.complyadvantage.com/api-docs#creating-searches
+var CreateSearchInput = z.object({
+  search_term: z.string().describe("represents name of the entity"),
+  client_ref: z.string().describe("Your reference for this person/entity for which you are searching. Used for tracking searches and auto-whitelisting recurring results"),
+  search_profile: z.string().nullish().describe("The Profile ID of a search profile that can be retrieved from the UI"),
+  fuzziness: z.number().min(0.0).max(1.0).nullish().describe("determines how closely the returned results must match the supplied name. Overridden by exact_match"),
+  offset: z.number().nullish().describe("match results from the database, starting form the offset value"),
+  limit: z.number().nullish().describe("math results from the database, taking up this many matches each search"),
+  filters: SearchFilters.optional().describe("specify filters within the search to narrow down the results"),
+  tags: z.array(z.record(z.string(), z.string())).nullish().describe("name => value pairs, to search later using defined tags here"),
+  share_url: z.number().min(0).max(1).nullish().describe("include a shareable URL to access search publicly"),
+  exact_match: z["boolean"]().nullish().describe("Exact match disables all standard and optional matching behaviours (Honorifics, affixes, initials, glued name, name variation, equivalent names, extra words in entity,...) 0% fuzziness disables 1 letter typo matching but keeps all other matching behaviours (standard and optional)")
+});
+var MatchStatuses = ["unknown", "no_match", "potential_match", "false_positive", "true_positive", "true_positive_approve", "true_positive_reject"];
+var MatchStatus = z["enum"](MatchStatuses);
+var RiskLevels = ["low", "medium", "high", "unknown"];
+var RiskLevel = z["enum"](RiskLevels);
+// https://docs.complyadvantage.com/api-docs/#updating-searches
+var UpdateSearchInput = z.object({
+  match_status: MatchStatus.optional(),
+  risk_level: RiskLevel.optional(),
+  assignee_id: z.string().optional().describe("the ID of the user to whom the case should be assigned"),
+  limit: z.number().optional().describe("the number of matches retrieved (max. 100)"),
+  tags: z.array(z.record(z.string(), z.string())).optional().describe("object of name => value pairs, must be existing tags")
+});
+var UpdateSearchEntitiesInput = z.object({
+  entities: z.array(z.string()).min(1).describe("array of entity ids to be updated"),
+  match_status: MatchStatus.optional(),
+  risk_level: RiskLevel.optional(),
+  is_whitelisted: z["boolean"]().optional()
+});
+var ComplyAdvantageUser = z.object({
+  id: z.number(),
+  email: z.string().email(),
+  name: z.string(),
+  phone: z.string(),
+  created_at: CoerceDateUTC,
+  user_is_active: z["boolean"]()
+});
+var MatchTypeDetail = z.object({
+  aml_types: z.array(z.string()),
+  matching_name: z.string(),
+  name_matches: z.array(z.object({
+    match_types: z.array(z.string()),
+    query_term: z.string()
+  })),
+  secondary_matches: z.array(z.unknown()),
+  sources: z.array(z.string())
+});
+var ComplyAdvantageMedia = z.array(z.object({
+  date: CoerceDateUTC.optional(),
+  snippet: z.string(),
+  title: z.string(),
+  url: z.string().url()
+}));
+var ComplyAdvantageSearchDataResponseHit = z.object({
+  doc: z.object({
+    id: z.string(),
+    last_updated_utc: CoerceDateUTC,
+    created_utc: CoerceDateUTC,
+    fields: z.array(z.object({
+      name: z.string(),
+      source: z.string().optional(),
+      value: z.string(),
+      locale: z.string().optional(),
+      tag: z.string().optional()
+    })).optional(),
+    types: z.array(SearchFilterType),
+    name: z.string(),
+    entity_type: SearchEntityType,
+    aka: z.array(z.object({
+      name: z.string()
+    })),
+    associates: z.array(z.object({
+      association: z.string(),
+      name: z.string()
+    })).optional(),
+    sources: z.array(z.string()),
+    keywords: z.array(z.unknown()),
+    media: ComplyAdvantageMedia.optional(),
+    source_notes: z.unknown()
+  }),
+  match_types: z.array(z.string()),
+  match_types_details: z.array(z.object({
+    aml_types: z.array(z.string()),
+    matching_name: z.string(),
+    name_matches: z.array(z.object({
+      match_types: z.array(z.string()),
+      query_term: z.string()
+    })),
+    secondary_matches: z.array(z.unknown()),
+    sources: z.array(z.string())
+  })),
+  match_status: z.string(),
+  is_whitelisted: z["boolean"](),
+  score: z.number()
+});
+var ComplyAdvantageSearchDataResponse = z.object({
+  client_ref: z.string(),
+  id: z.number(),
+  ref: z.string(),
+  searcher_id: z.number(),
+  assignee_id: z.number(),
+  filters: SearchFilters.optional(),
+  match_status: MatchStatus,
+  risk_level: RiskLevel,
+  search_term: z.string(),
+  submitted_term: z.string(),
+  total_hits: z.number(),
+  total_matches: z.number(),
+  total_blacklist_hits: z.number(),
+  created_at: CoerceDateUTC,
+  updated_at: CoerceDateUTC,
+  tags: z.array(z.record(z.string(), z.string())).optional(),
+  labels: z.array(z.unknown()),
+  limit: z.number(),
+  offset: z.number(),
+  searcher: ComplyAdvantageUser.optional(),
+  assignee: ComplyAdvantageUser.optional(),
+  hits: z.array(ComplyAdvantageSearchDataResponseHit).optional(),
+  blacklist_hits: z.array(z.unknown()).optional()
+});
+var ComplyAdvantageSearchSuccessResponse = z.object({
+  status: z.literal("success"),
+  code: z.literal(200),
+  content: z.object({
+    data: ComplyAdvantageSearchDataResponse
+  })
+});
+var ComplyAdvantageSearchErrorResponse = z.object({
+  status: z.literal("failure"),
+  code: z.number(),
+  message: z.string()
+});
+var ComplyAdvantageSearchResponse = z.union([ComplyAdvantageSearchSuccessResponse, ComplyAdvantageSearchErrorResponse]);
+var ComplyAdvantageKeyInformation = z.object({
+  name: z.string(),
+  entity_type: SearchEntityType,
+  types: z.array(SearchFilterType).nullish(),
+  grouped_types: z.array(z.object({
+    type: SearchFilterType
+  })).nullish(),
+  match_types: z.array(z.string()).nullish(),
+  sources: z.array(z.string()).nullish(),
+  source_notes: z.unknown().nullish(),
+  aka: z.array(z.object({
+    name: z.string()
+  })).nullish(),
+  date_of_birth: z.string().nullish(),
+  dates_of_birth: z.array(z.string()).nullish(),
+  match_status: MatchStatus.nullish(),
+  risk_level: RiskLevel.nullish(),
+  is_whitelisted: z["boolean"]().nullish(),
+  age: z.number().nullish(),
+  death_age: z.unknown().nullish(),
+  date_of_death: z.unknown().nullish(),
+  primary_country: z.unknown().nullish(),
+  country_names: z.string().nullish(),
+  designation: z.string().nullish(),
+  associates: z.array(z.object({
+    association: z.string(),
+    name: z.string()
+  })).nullish()
+});
+var ComplyAdvantageAmlItemSource = z.object({
+  aml_types: z.array(z.string()).nullish(),
+  count: z.number().nullish(),
+  country_codes: z.array(z.string()).nullish(),
+  data: z.array(z.object({
+    name: z.string().nullish(),
+    source: z.string().nullish(),
+    value: z.string().nullish()
+  })).nullish(),
+  disclose_sources: z["boolean"]().nullish(),
+  listing_ended_utc: z.string().nullish(),
+  listing_started_utc: z.string().nullish(),
+  name: z.string().nullish(),
+  source: z.string().nullish(),
+  url: z.string().nullish()
+});
+var ComplyAdvantageAmlFullListing = z.record(z.string().nullish(), z.record(z.string().nullish(), ComplyAdvantageAmlItemSource.nullish()).nullish());
+var ComplyAdvantageSearchEntitiesDataResponse = z.array(z.object({
+  id: z.string(),
+  last_updated_utc: CoerceDateUTC,
+  created_utc: CoerceDateUTC,
+  key_information: ComplyAdvantageKeyInformation.nullish(),
+  uncategorized: z.object({
+    keywords: z.array(z.unknown()).nullish(),
+    media: ComplyAdvantageMedia.nullish(),
+    assets: z.array(z.unknown()).nullish(),
+    match_types: z.array(z.string()).nullish(),
+    related: z.array(z.unknown()).nullish(),
+    fields: z.array(z.unknown()).nullish()
+  }).nullish(),
+  full_listing: ComplyAdvantageAmlFullListing.nullish(),
+  navigation: z.object({
+    next: z.unknown().nullish(),
+    previous: z.unknown().nullish()
+  }).nullish()
+}));
+var ComplyAdvantageSearchEntitiesSuccessResponse = z.object({
+  status: z.literal("success"),
+  code: z.literal(200),
+  content: ComplyAdvantageSearchEntitiesDataResponse.nullish()
+});
+var ComplyAdvantageSearchEntitiesResponse = z.union([ComplyAdvantageSearchEntitiesSuccessResponse, ComplyAdvantageSearchErrorResponse]);
+var ComplyAdvantageSearchRequest = z.object({
+  customerId: z.string()
+});
+var ComplyAdvantageUpdateSearchRequest = z.object({
+  searchId: z.string(),
+  matchStatus: MatchStatus.optional()
+});
+var ComplyAdvantageUpdateSearchEntitiesRequest = z.object({
+  searchId: z.string(),
+  entities: z.array(z.string()).min(1),
+  matchStatus: MatchStatus.optional(),
+  isWhitelisted: z["boolean"]().optional()
+});
+var ComplyAdvantageUpdateSearchEntitiesSuccessResponse = z.object({
+  status: z.literal("success"),
+  code: z.literal(200),
+  content: ComplyAdvantageSearchDataResponse
+});
+var ComplyAdvantageUpdateSearchEntitiesResponse = z.union([ComplyAdvantageUpdateSearchEntitiesSuccessResponse, ComplyAdvantageSearchErrorResponse]);
+var ComplyAdvantageMonitorSearchDataResponse = z.object({
+  searcher_id: z.number(),
+  ref: z.string(),
+  is_monitored: z["boolean"](),
+  monitors: z.array(z.object({
+    monitored_by: z.number(),
+    created_at: CoerceDateUTC,
+    updated_at: CoerceDateUTC
+  })).optional()
+});
+var ComplyAdvantageMonitorSearchSuccessResponse = z.object({
+  status: z.literal("success"),
+  code: z.literal(200),
+  content: ComplyAdvantageMonitorSearchDataResponse
+});
+var ComplyAdvantageMonitorSearchResponse = z.union([ComplyAdvantageMonitorSearchSuccessResponse, ComplyAdvantageSearchErrorResponse]);
+var ComplyAdvantageMonitoredSearchUpdate = z.object({
+  event: z.literal("monitored_search_updated"),
+  data: z.object({
+    search_id: z.number(),
+    updated: z.array(z.string()).nullish(),
+    "new": z.array(z.string()).nullish(),
+    removed: z.array(z.string()).nullish(),
+    is_suspended: z["boolean"]().nullish()
+  })
+});
+
+/**
+ * Merkle Science defines it own blockchain list, thus this list.
+ * See https://docs.merklescience.com/reference/currencies
+ */
+var MerkleBlockChainTypes = {
+  Bitcoin: "0",
+  Ethereum: "1",
+  Litecoin: "2",
+  BitcoinCash: "3",
+  Ripple: "4",
+  Dogecoin: "6",
+  Zilliqa: "7",
+  BinanceSmartChain: "8",
+  Polygon: "9",
+  Tron: "10",
+  Cardano: "11",
+  Polkadot: "12",
+  Stellar: "13",
+  Hedera: "14",
+  Cronos: "15",
+  Optimism: "16",
+  Arbitrum: "17",
+  Fantom: "18",
+  Monero: "19",
+  Cosmos: "20",
+  Zcash: "21",
+  EthereumClassic: "22",
+  Dash: "23",
+  Solana: "24",
+  AvalancheC_Chain: "25",
+  Verge: "26",
+  BitcoinGold: "27",
+  Algorand: "28",
+  Acala: "29",
+  Akash: "30",
+  Arweave: "31",
+  Ardor: "32",
+  Ark: "33",
+  Astar: "34",
+  Band: "35",
+  BinanceNative: "36",
+  Celo: "37",
+  Chiliz: "38",
+  Nervos: "39",
+  CronosNative: "40",
+  Digibyte: "41",
+  Multiversx: "42",
+  Enjin: "43",
+  Eos: "44",
+  EthereumPow: "45",
+  FetchAI: "46",
+  Filecoin: "47",
+  Flow: "48",
+  Flare: "49",
+  Moonbeam: "50",
+  Helium: "51",
+  ICP: "52",
+  Icon: "53",
+  Injective: "54",
+  IOTA: "55",
+  IoTex: "56",
+  Iris: "57",
+  Kava: "58",
+  Kadena: "59",
+  Klaytn: "60",
+  Komodo: "61",
+  Kusama: "62",
+  Lisk: "63",
+  Terra: "64",
+  Mina: "65",
+  Moonriver: "66",
+  Nano: "67",
+  Near: "68",
+  Neo3: "69",
+  Oasys: "70",
+  One: "71",
+  Ontology: "72",
+  Osmosis: "73",
+  Polymesh: "74",
+  QTUM: "75",
+  Oasis: "76",
+  Thorchain: "77",
+  Ravencoin: "78",
+  Siacoin: "79",
+  Shiden: "80",
+  Songbird: "81",
+  Stratis: "82",
+  Stacks: "83",
+  SUI: "84",
+  zkSync: "85",
+  Theta: "86",
+  Tomo: "87",
+  VeChain: "88",
+  Waves: "89",
+  Wax: "90",
+  WEMIX: "91",
+  WaltonChain: "92",
+  Chia: "93",
+  Tezos: "94",
+  Zcoin: "95",
+  Celestia: "96",
+  Neutron: "97",
+  Avalanche_P: "98",
+  Sei: "99",
+  Avalanche_X: "100",
+  Aztec: "101",
+  Bittensor: "102",
+  Casper: "103",
+  Deso: "104",
+  Juno: "105",
+  PocketNetwork: "106",
+  Ronin: "107",
+  Vara: "108",
+  XPLA: "109",
+  Archway: "110",
+  Axelar: "111",
+  Dymension: "112",
+  Starknet: "113",
+  Orai: "114",
+  Lukso: "115",
+  bitsCrunch: "116",
+  Reef: "117",
+  ImmutablezkEVM: "118",
+  BaseProtocol: "119",
+  ArbitrumNova: "120",
+  Canto: "121",
+  MetisDAO: "122",
+  Aptos: "123"
+};
+var BlockChainNames = ["Bitcoin", "Ethereum", "Litecoin", "BitcoinCash", "Ripple", "Dogecoin", "Zilliqa", "BinanceSmartChain", "Polygon", "Tron", "Cardano", "Polkadot", "Stellar", "Hedera", "Cronos", "Optimism", "Arbitrum", "Fantom", "Monero", "Cosmos", "Zcash", "EthereumClassic", "Dash", "Solana", "AvalancheC_Chain", "Verge", "BitcoinGold", "Algorand", "Acala", "Akash", "Arweave", "Ardor", "Ark", "Astar", "Band", "BinanceNative", "Celo", "Chiliz", "Nervos", "CronosNative", "Digibyte", "Multiversx", "Enjin", "Eos", "EthereumPow", "FetchAI", "Filecoin", "Flow", "Flare", "Moonbeam", "Helium", "ICP", "Icon", "Injective", "IOTA", "IoTex", "Iris", "Kava", "Kadena", "Klaytn", "Komodo", "Kusama", "Lisk", "Terra", "Mina", "Moonriver", "Nano", "Near", "Neo3", "Oasys", "One", "Ontology", "Osmosis", "Polymesh", "QTUM", "Oasis", "Thorchain", "Ravencoin", "Siacoin", "Shiden", "Songbird", "Stratis", "Stacks", "SUI", "zkSync", "Theta", "Tomo", "VeChain", "Waves", "Wax", "WEMIX", "WaltonChain", "Chia", "Tezos", "Zcoin", "Celestia", "Neutron", "Avalanche_P", "Sei", "Avalanche_X", "Aztec", "Bittensor", "Casper", "Deso", "Juno", "PocketNetwork", "Ronin", "Vara", "XPLA", "Archway", "Axelar", "Dymension", "Starknet", "Orai", "Lukso", "bitsCrunch", "Reef", "ImmutablezkEVM", "BaseProtocol", "ArbitrumNova", "Canto", "MetisDAO", "Aptos"];
+var MerkleBlockChainNames = z["enum"](BlockChainNames);
+var MerkleBlockChainNamesExtended = z["enum"]([].concat(BlockChainNames, ["Bitcoin Cash", "Binance Smart Chain", "Ethereum Classic", "Avalanche C-Chain", "Bitcoin Gold", "Binance Native", "Cronos Native", "Ethereum Pow", "Fetch AI", "Avalanche-P", "Avalanche-X", "Pocket Network", "Immutable zkEVM", "Base Protocol", "Arbitrum Nova"]));
+var BlockChainCodes = ["0", "1", "2", "3", "4", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123"];
+var MerkleBlockChainCodes = z["enum"](BlockChainCodes);
+// Needed as MerkleScience API response contains numerical value for blockchain
+// while the value for blockchain in request is expected to be a string...
+var BlockChainNumericalCodes = z.number()["int"]().min(0).max(123).refine(function (arg) {
+  return arg !== 5;
+});
+var transactionType = {
+  Deposit: 1,
+  // Deposit
+  Withdrawal: 2 // Withdrawal
+};
+var TransactionType = z.nativeEnum(transactionType);
+var MerkleAddressRequest = z.object({
+  identifier: z.string(),
+  blockchain: MerkleBlockChainCodes,
+  customer_id: UuidString,
+  type: TransactionType,
+  show_alerts: z["boolean"]().nullish(),
+  custom_tags: z.array(z.string()).nullish()
+});
+var RiskLevelVerbose = z["enum"](["No Risk Detected", "Info", "Caution", "Medium", "High", "Critical"]);
+var Originator = z.object({
+  tag_type_verbose: z.string(),
+  tag_subtype_verbose: z.string(),
+  tag_name_verbose: z.string(),
+  total_value_usd: z.number(),
+  exposure_type: z.string()
+});
+var User = z.object({
+  tag_type_verbose: z.string().nullish(),
+  tag_subtype_verbose: z.string().nullish(),
+  tag_name_verbose: z.string().nullish()
+});
+var DigitalAsset = z.object({
+  name: z.string().nullish(),
+  symbol: z.string().nullish()
+});
+var MerkleAddressApiResponse = z.object({
+  identifier: z.string().nullish(),
+  blockchain: BlockChainNumericalCodes.nullish(),
+  blockchain_verbose: MerkleBlockChainNamesExtended.nullish(),
+  customer_id: UuidString.nullish(),
+  type: z.number().nullish(),
+  type_verbose: z.string().nullish(),
+  total_incoming_value: z.string().nullish(),
+  total_incoming_value_usd: z.string().nullish(),
+  total_outgoing_value: z.string().nullish(),
+  total_outgoing_value_usd: z.string().nullish(),
+  balance: z.number().nullish(),
+  earliest_transaction_time: z.string().nullish(),
+  latest_transaction_time: z.string().nullish(),
+  risk_level: z.number()["int"]().min(0).max(5).nullish(),
+  risk_level_verbose: RiskLevelVerbose.nullish(),
+  created_at: z.string().nullish(),
+  updated_at: z.string().nullish(),
+  originator: z.array(Originator).nullish(),
+  beneficiary: z.array(z.object({})).nullish(),
+  tags: z.object({
+    owner: User,
+    user: User
+  }).nullish(),
+  custom_tags: z.array(z.string()).nullish(),
+  digital_assets: z.array(DigitalAsset).nullish()
+});
+var MerkleAddressApiError = z.object({
+  error: z.object({
+    error: z.string(),
+    message: z.string(),
+    data: z.string().nullish()
+  }),
+  risk_level: z.number()["int"]().min(0).max(5).nullish(),
+  risk_level_verbose: RiskLevelVerbose.nullish(),
+  identifier: z.string().nullish()
+});
+var MerkleAddressResponse = z.union([MerkleAddressApiResponse, MerkleAddressApiError]);
+
+var IdentityProviderOptions = ["nexeraIdSSID", "nexeraIdKYB", "synaps"];
+var IdentityProviders = z["enum"](IdentityProviderOptions);
+var DataProviderOptions = ["complyAdvantage", "big", "scorechain", "merkleScience", "ipQualityScore", "integratedComplyAdvantage", "integratedScorechain", "integratedIpqualityscore"];
+var DataProviders = z["enum"](DataProviderOptions);
+var MergedProviders = z["enum"]([].concat(_toConsumableArray(IdentityProviders.options), _toConsumableArray(DataProviders.options)));
+var MerkleScienceConfig = z.object({
+  blockchain: MerkleBlockChainNames
+});
+var ScorechainConfig = ScoringAnalysisRequest.omit({
+  objectId: true // objectId is removed, because it is not stored in CMS but rather provided on the fly by the client
+});
+var WorkflowsScorechainConfig = WorkflowsScoringAnalysisRequest.omit({
+  objectId: true // objectId is removed, because it is not stored in CMS but rather provided on the fly by the client
+});
+var IpQualityConfig = z.object({
+  ipVerification: z["boolean"]().nullish()["default"](false),
+  emailVerification: z["boolean"]().nullish()["default"](false),
+  phoneVerification: z["boolean"]().nullish()["default"](false)
+});
+var BigConfig = BitRankRequest.omit({
+  address: true,
+  // address is removed, because it is not stored in CMS but rather provided on the fly by the client
+  label: true,
+  // label is removed, because it is not stored in CMS but rather provided on the fly by the client
+  transactionsPerPage: true // transactionsPerPage is removed, because it is not stored in CMS but rather provided on the fly by the client
+}).partial();
+var ProviderIntegrationTypeOptions = ["integrated", "external"];
+var ProviderIntegrationType = z["enum"](ProviderIntegrationTypeOptions);
+// the following configurations are used for CMS providers
+// seems like we are migrating from these to workflow provider configs
+// which do not have enabled, apiKey and integrationType
+// as these are now found on the providers-api microservice.
+
+var BaseProvider = z.object({
+  enabled: z["boolean"]().nullish(),
+  apiKey: z.string().nullish(),
+  integrationType: ProviderIntegrationType.nullish()
+});
+var NexeraIdSSIDProvider = BaseProvider;
+var NexeraIdKYBProvider = BaseProvider;
+var BigProvider = BaseProvider.extend({
+  onRulesEngine: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: BigConfig.array().nullish()
+  }).nullish(),
+  onNewRecord: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: BigConfig.array().nullish()
+  }).nullish()
+});
+var ScorechainProvider = BaseProvider.extend({
+  onRulesEngine: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: ScorechainConfig.array().nullish()
+  }).nullish(),
+  onNewRecord: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: ScorechainConfig.array().nullish()
+  }).nullish()
+});
+var MerkleScienceProvider = BaseProvider.extend({
+  onRulesEngine: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: MerkleScienceConfig.array().nullish()
+  }).nullish(),
+  onNewRecord: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: MerkleScienceConfig.array().nullish()
+  }).nullish()
+});
+var IpqualityscoreProvider = BaseProvider.extend({
+  onRulesEngine: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: IpQualityConfig.array().nullish()
+  }).nullish(),
+  onNewRecord: z.object({
+    enabled: z["boolean"]().nullish(),
+    config: IpQualityConfig.array().nullish()
+  }).nullish()
+});
+// note this use of SearchFilterType
+// it is assuming that data coming in may not be in the correct format.
+var ComplyAdvantageProviderConfigTypes = z.array(z.preprocess(function (type) {
+  return type.replace(/_/g, "-");
+}, SearchFilterType)).nullish();
+var ComplyAdvantageProviderConfigFilters = z.object({
+  types: ComplyAdvantageProviderConfigTypes,
+  removeDeceased: z["boolean"]().nullish(),
+  countryCodes: z.array(Alpha2Country).nullish()
+});
+var ComplyAdvantageProviderConfigElement = z.object({
+  fuzziness: z.number().min(0).max(1).nullish(),
+  exactMatch: z["boolean"]().nullish(),
+  filters: ComplyAdvantageProviderConfigFilters.nullish()
+});
+var ComplyAdvantageProvider = BaseProvider.extend({
+  screenDataOnNewRecord: z["boolean"]().nullish(),
+  monitorOnTheOngoingManner: z["boolean"]().nullish(),
+  config: z.array(ComplyAdvantageProviderConfigElement).nullish()
+});
+var SynapsProvider = BaseProvider.extend({
+  webhookSecret: z.string().nullish()
+});
+
+// See comment above.  --> END CMS providers
+
+var ProviderData = z.object({
+  id: z.string(),
+  projectId: z.string(),
+  provider: z.union([IdentityProviders, DataProviders]),
+  type: z["enum"](["identity", "data"]),
+  nexeraIdSSID: NexeraIdSSIDProvider.nullish(),
+  nexeraIdKYB: NexeraIdKYBProvider.nullish(),
+  complyAdvantage: ComplyAdvantageProvider.nullish(),
+  synaps: SynapsProvider.nullish(),
+  big: BigProvider.nullish(),
+  scorechain: ScorechainProvider.nullish(),
+  ipqualityscore: IpqualityscoreProvider.nullish(),
+  merkleScience: MerkleScienceProvider.nullish(),
+  integratedComplyAdvantage: ComplyAdvantageProvider.nullish(),
+  integratedScorechain: ScorechainProvider.nullish(),
+  integratedIpqualityscore: IpqualityscoreProvider.nullish()
+});
+var ProviderDataProject = ProviderData.omit({
+  projectId: true
+}).extend({
+  project: z.object({
+    id: z.string()
+  })
+});
+var GetProvidersResponse = z.array(ProviderDataProject);
+var GetProviderResponse = ProviderData;
+var CreateProviderInput = ProviderData.omit({
+  id: true,
+  type: true,
+  projectId: true
+}).extend({
+  project: z.string()
+});
+var CreateProviderResponse = ProviderData.omit({
+  type: true,
+  synaps: true,
+  big: true,
+  scorechain: true,
+  merkleScience: true,
+  nexeraIdSSID: true,
+  nexeraIdKYB: true,
+  ipqualityscore: true,
+  integratedScorechain: true,
+  integratedIpqualityscore: true
+});
+var UpdateProviderInput = z.object({
+  providerId: z.string(),
+  input: ProviderData.omit({
+    id: true,
+    projectId: true,
+    provider: true,
+    type: true
+  })
+});
+var UpdateProviderResponse = ProviderData;
+var ToggleProviderInput = z.object({
+  providerId: z.string(),
+  enabled: z["boolean"]()
+});
+var DeleteProviderInput = z.object({
+  providerId: z.string()
+});
+var DeleteProviderResponse = z.object({
+  providerId: z.string()
+});
+
+var SUMSUB_REVIEW_REJECT_LABELS = ["FORGERY", "DOCUMENT_TEMPLATE", "LOW_QUALITY", "SPAM", "NOT_DOCUMENT", "SELFIE_MISMATCH", "ID_INVALID", "FOREIGNER", "DUPLICATE", "BAD_AVATAR", "WRONG_USER_REGION", "INCOMPLETE_DOCUMENT", "BLACKLIST", "BLOCKLIST", "UNSATISFACTORY_PHOTOS", "DOCUMENT_PAGE_MISSING", "DOCUMENT_DAMAGED", "REGULATIONS_VIOLATIONS", "INCONSISTENT_PROFILE", "PROBLEMATIC_APPLICANT_DATA", "ADDITIONAL_DOCUMENT_REQUIRED", "AGE_REQUIREMENT_MISMATCH", "EXPERIENCE_REQUIREMENT_MISMATCH", "CRIMINAL", "WRONG_ADDRESS", "GRAPHIC_EDITOR", "DOCUMENT_DEPRIVED", "COMPROMISED_PERSONS", "PEP", "ADVERSE_MEDIA", "FRAUDULENT_PATTERNS", "SANCTIONS", "NOT_ALL_CHECKS_COMPLETED", "FRONT_SIDE_MISSING", "BACK_SIDE_MISSING", "SCREENSHOTS", "BLACK_AND_WHITE", "INCOMPATIBLE_LANGUAGE", "EXPIRATION_DATE", "UNFILLED_ID", "BAD_SELFIE", "BAD_VIDEO_SELFIE", "BAD_FACE_MATCHING", "BAD_PROOF_OF_IDENTITY", "BAD_PROOF_OF_ADDRESS", "BAD_PROOF_OF_PAYMENT", "SELFIE_WITH_PAPER", "FRAUDULENT_LIVENESS", "OTHER", "REQUESTED_DATA_MISMATCH", "OK", "COMPANY_NOT_DEFINED_STRUCTURE", "COMPANY_NOT_DEFINED_BENEFICIARIES", "COMPANY_NOT_VALIDATED_BENEFICIARIES", "COMPANY_NOT_DEFINED_REPRESENTATIVES", "COMPANY_NOT_VALIDATED_REPRESENTATIVES", "APPLICANT_INTERRUPTED_INTERVIEW", "DOCUMENT_MISSING", "UNSUITABLE_ENV", "CONNECTION_INTERRUPTED", "UNSUPPORTED_LANGUAGE", "THIRD_PARTY_INVOLVED", "CHECK_UNAVAILABLE", "INCORRECT_SOCIAL_NUMBER"];
+var SumSubReviewRejectLabel = z["enum"](SUMSUB_REVIEW_REJECT_LABELS);
+var SUMSUB_REVIEW_REJECT_LABELS_DESCRIPTION = {
+  FORGERY: {
+    defaultReviewRejectType: "FINAL",
+    description: "Forgery attempt has been made"
+  },
+  DOCUMENT_TEMPLATE: {
+    defaultReviewRejectType: "FINAL",
+    description: "Documents supplied are templates, downloaded from internet"
+  },
+  LOW_QUALITY: {
+    defaultReviewRejectType: "RETRY",
+    description: "Documents have low-quality that does not allow definitive conclusions to be made"
+  },
+  SPAM: {
+    defaultReviewRejectType: "FINAL",
+    description: "An applicant has been created by mistake or is just a spam user (irrelevant images were supplied)"
+  },
+  NOT_DOCUMENT: {
+    defaultReviewRejectType: "RETRY",
+    description: "Documents supplied are not relevant for the verification procedure"
+  },
+  SELFIE_MISMATCH: {
+    defaultReviewRejectType: "FINAL",
+    description: "A user photo (profile image) does not match a photo on the provided documents"
+  },
+  ID_INVALID: {
+    defaultReviewRejectType: "RETRY",
+    description: "A document that identifies a person (like a passport or an ID card) is not valid"
+  },
+  FOREIGNER: {
+    defaultReviewRejectType: "FINAL",
+    description: "When a client does not accept applicants from a different country or e.g. without a residence permit"
+  },
+  DUPLICATE: {
+    defaultReviewRejectType: "FINAL",
+    description: "This applicant was already created for this client, and duplicates are not allowed by the regulations"
+  },
+  BAD_AVATAR: {
+    defaultReviewRejectType: "RETRY",
+    description: "When avatar does not meet the client's requirements"
+  },
+  WRONG_USER_REGION: {
+    defaultReviewRejectType: "FINAL",
+    description: "When applicants from certain regions/countries are not allowed to be registered"
+  },
+  INCOMPLETE_DOCUMENT: {
+    defaultReviewRejectType: "RETRY",
+    description: "Some information is missing from the document, or it's partially visible"
+  },
+  BLACKLIST: {
+    defaultReviewRejectType: "FINAL",
+    description: "User is blocklisted by our side"
+  },
+  BLOCKLIST: {
+    defaultReviewRejectType: "FINAL",
+    description: "User is blocklisted by your side"
+  },
+  UNSATISFACTORY_PHOTOS: {
+    defaultReviewRejectType: "RETRY",
+    description: "There were problems with the photos, like poor quality or masked information"
+  },
+  DOCUMENT_PAGE_MISSING: {
+    defaultReviewRejectType: "RETRY",
+    description: "Some pages of a document are missing (if applicable)"
+  },
+  DOCUMENT_DAMAGED: {
+    defaultReviewRejectType: "RETRY",
+    description: "Document is damaged"
+  },
+  REGULATIONS_VIOLATIONS: {
+    defaultReviewRejectType: "FINAL",
+    description: "Regulations violations"
+  },
+  INCONSISTENT_PROFILE: {
+    defaultReviewRejectType: "FINAL",
+    description: "Data or documents of different persons were uploaded to one applicant"
+  },
+  PROBLEMATIC_APPLICANT_DATA: {
+    defaultReviewRejectType: "RETRY",
+    description: "Applicant data does not match the data in the documents"
+  },
+  ADDITIONAL_DOCUMENT_REQUIRED: {
+    defaultReviewRejectType: "RETRY",
+    description: "Additional documents required to pass the check"
+  },
+  AGE_REQUIREMENT_MISMATCH: {
+    defaultReviewRejectType: "FINAL",
+    description: "Age requirement is not met (e.g. cannot rent a car to a person below 25yo)"
+  },
+  EXPERIENCE_REQUIREMENT_MISMATCH: {
+    defaultReviewRejectType: "FINAL",
+    description: "Not enough experience (e.g. driving experience is not enough)"
+  },
+  CRIMINAL: {
+    defaultReviewRejectType: "FINAL",
+    description: "The user is involved in illegal actions"
+  },
+  WRONG_ADDRESS: {
+    defaultReviewRejectType: "RETRY",
+    description: "The address from the documents doesn't match the address that the user entered"
+  },
+  GRAPHIC_EDITOR: {
+    defaultReviewRejectType: "RETRY",
+    description: "The document has been edited by a graphical editor"
+  },
+  DOCUMENT_DEPRIVED: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user has been deprived of the document"
+  },
+  COMPROMISED_PERSONS: {
+    defaultReviewRejectType: "FINAL",
+    description: "The userdoes not correspond to Compromised Person Politics"
+  },
+  PEP: {
+    defaultReviewRejectType: "FINAL",
+    description: "The user belongs to the PEP category"
+  },
+  ADVERSE_MEDIA: {
+    defaultReviewRejectType: "FINAL",
+    description: "The user was found in the adverse media"
+  },
+  FRAUDULENT_PATTERNS: {
+    defaultReviewRejectType: "FINAL",
+    description: "Fraudulent behavior was detected"
+  },
+  SANCTIONS: {
+    defaultReviewRejectType: "FINAL",
+    description: "The user was found on sanction lists"
+  },
+  NOT_ALL_CHECKS_COMPLETED: {
+    defaultReviewRejectType: "RETRY",
+    description: "All checks were not completed"
+  },
+  FRONT_SIDE_MISSING: {
+    defaultReviewRejectType: "RETRY",
+    description: "Front side of the document is missing"
+  },
+  BACK_SIDE_MISSING: {
+    defaultReviewRejectType: "RETRY",
+    description: "Back side of the document is missing"
+  },
+  SCREENSHOTS: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded screenshots"
+  },
+  BLACK_AND_WHITE: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded black and white photos of documents"
+  },
+  INCOMPATIBLE_LANGUAGE: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user should upload translation of his document"
+  },
+  EXPIRATION_DATE: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded expired document"
+  },
+  UNFILLED_ID: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded the document without signatures and stamps"
+  },
+  BAD_SELFIE: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded a bad selfie"
+  },
+  BAD_VIDEO_SELFIE: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded a bad video selfie"
+  },
+  BAD_FACE_MATCHING: {
+    defaultReviewRejectType: "RETRY",
+    description: "Face check between document and selfie failed"
+  },
+  BAD_PROOF_OF_IDENTITY: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded a bad ID document"
+  },
+  BAD_PROOF_OF_ADDRESS: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded a bad proof of address"
+  },
+  BAD_PROOF_OF_PAYMENT: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user uploaded a bad proof of payment"
+  },
+  SELFIE_WITH_PAPER: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user should upload a special selfie (e.g. selfie with paper and date on it)"
+  },
+  FRAUDULENT_LIVENESS: {
+    defaultReviewRejectType: "FINAL",
+    description: "There was an attempt to bypass liveness check"
+  },
+  OTHER: {
+    defaultReviewRejectType: "RETRY",
+    description: "Some unclassified reason"
+  },
+  REQUESTED_DATA_MISMATCH: {
+    defaultReviewRejectType: "RETRY",
+    description: "Provided info doesn't match with recognized from document data"
+  },
+  OK: {
+    defaultReviewRejectType: "RETRY",
+    description: "Custom reject label"
+  },
+  COMPANY_NOT_DEFINED_STRUCTURE: {
+    defaultReviewRejectType: "RETRY",
+    description: "Could not establish the entity's control structure"
+  },
+  COMPANY_NOT_DEFINED_BENEFICIARIES: {
+    defaultReviewRejectType: "RETRY",
+    description: "Could not identify and duly verify the entity's beneficial owners"
+  },
+  COMPANY_NOT_VALIDATED_BENEFICIARIES: {
+    defaultReviewRejectType: "RETRY",
+    description: "Beneficiaries are not validated"
+  },
+  COMPANY_NOT_DEFINED_REPRESENTATIVES: {
+    defaultReviewRejectType: "RETRY",
+    description: "Representatives are not defined"
+  },
+  COMPANY_NOT_VALIDATED_REPRESENTATIVES: {
+    defaultReviewRejectType: "RETRY",
+    description: "Representatives are not validated"
+  },
+  APPLICANT_INTERRUPTED_INTERVIEW: {
+    defaultReviewRejectType: "RETRY",
+    description: "On Video Ident call user refused to finish interview"
+  },
+  DOCUMENT_MISSING: {
+    defaultReviewRejectType: "RETRY",
+    description: "On Video Ident call user refused to show or didn't have required documents"
+  },
+  UNSUITABLE_ENV: {
+    defaultReviewRejectType: "RETRY",
+    description: "On Video Ident call user is either not alone or nor visible"
+  },
+  CONNECTION_INTERRUPTED: {
+    defaultReviewRejectType: "RETRY",
+    description: "Video Ident call connection was interrupted"
+  },
+  UNSUPPORTED_LANGUAGE: {
+    defaultReviewRejectType: "FINAL",
+    description: "Unsupported language for video identification"
+  },
+  THIRD_PARTY_INVOLVED: {
+    defaultReviewRejectType: "FINAL",
+    description: "The useris doing verification from a third party for a fee"
+  },
+  CHECK_UNAVAILABLE: {
+    defaultReviewRejectType: "RETRY",
+    description: "The database is not available"
+  },
+  INCORRECT_SOCIAL_NUMBER: {
+    defaultReviewRejectType: "RETRY",
+    description: "The user provided an incorrect social number (SSN, for example)"
+  }
+};
+
+/**
+ * In Docs this is called "idDocSetType"
+ * PHONE_VERIFICATION	Phone verification step.
+ * EMAIL_VERIFICATION	Email verification step.
+ * QUESTIONNAIRE	Questionnaire.
+ * APPLICANT_DATA	Applicant data.
+ * IDENTITY	Identity step.
+ * IDENTITY2	2nd identity step.
+ * IDENTITY3	3rd identity step.
+ * IDENTITY4	4th identity step.
+ * PROOF_OF_RESIDENCE	Proof of residence.
+ * PROOF_OF_RESIDENCE2	2nd proof of residence.
+ * SELFIE	Selfie step.
+ * SELFIE2	2nd selfie step.
+ */
+var SUMSUB_STEPS = ["PHONE_VERIFICATION", "EMAIL_VERIFICATION", "QUESTIONNAIRE", "APPLICANT_DATA", "IDENTITY", "IDENTITY2", "IDENTITY3", "IDENTITY4", "PROOF_OF_RESIDENCE", "PROOF_OF_RESIDENCE2", "SELFIE", "SELFIE2", "COMPANY"];
+var SumSubStep = z["enum"](SUMSUB_STEPS);
+var SUMSUB_APPLICANT_TYPES = ["individual", "company"];
+var SumSubApplicantType = z["enum"](SUMSUB_APPLICANT_TYPES);
+/**
+ * GREEN — check was successful.
+ * YELLOW — user is allowed to proceed, final check result will be determined later.
+ * RED — user has been decisively rejected and is not allowed to proceed.
+ */
+var SUMSUB_REVIEW_ANSWERS = ["GREEN", "RED", "YELLOW"];
+var SumSubReviewAnswer = z["enum"](SUMSUB_REVIEW_ANSWERS);
+var SUMSUB_REVIEW_REJECT_TYPES = ["FINAL", "RETRY"];
+var SumSubReviewRejectType = z["enum"](SUMSUB_REVIEW_REJECT_TYPES);
+/**
+ * Type	Optional	Description
+ * country	String	Yes	Alpha-3 country code.
+ * postCode	String	Yes	Postal code.
+ * town	String	Yes	Town or city name.
+ * street	String	Yes	Street name.
+ * subStreet	String	Yes	Additional street information.
+ * state	String	Yes	State name if applicable.
+ * #
+ */
+var SumSubAddress = z.object({
+  country: ISO3CountryCode.optional(),
+  postCode: z.string().optional(),
+  town: z.string().optional(),
+  street: z.string().optional(),
+  subStreet: z.string().optional(),
+  state: z.string().optional()
+});
+var SumSubApplicantInfo = z.object({
+  firstName: z.string().optional().describe("First name."),
+  lastName: z.string().optional().describe("Last name."),
+  middleName: z.string().optional().describe("Middle name."),
+  firstNameEn: z.string().optional().describe("Automatic transliteration of the first name."),
+  lastNameEn: z.string().optional().describe("Automatic transliteration of the last name."),
+  middleNameEn: z.string().optional().describe("Automatic transliteration of the middle name."),
+  legalName: z.string().optional().describe("Legal name of the applicant."),
+  gender: z.string().optional().describe("Male or Female"),
+  dob: z.string().optional().describe("Date of birth (format YYYY-mm-dd, e.g. 2001-09-25)."),
+  placeOfBirth: z.string().optional().describe("Place of birth."),
+  country: ISO3CountryCode.optional(),
+  nationality: ISO3CountryCode.optional(),
+  addresses: z.array(SumSubAddress).optional().describe("List of addresses."),
+  idDocs: z.array(z.record(z.string().nullish())).optional().describe("Represents the set of data recognized from uploaded documents."),
+  tin: z.string().optional().describe("Tax Identification Number.")
+});
+var INDIVIDUAL_BENEFICIARY_RELATIONS = ["director", "shareholder", "other"];
+var IndividualBeneficiaryRelation = z.union([z["enum"](INDIVIDUAL_BENEFICIARY_RELATIONS), z.string()]);
+var BENEFICIARY_TYPES = ["ubo", "shareholder", "representative"];
+var BeneficiaryType = z["enum"](BENEFICIARY_TYPES);
+var BeneficiaryCompanyCustomerClaims = z.object({
+  applicantId: z.string(),
+  type: BeneficiaryType,
+  positions: z.array(z.string()).nullish(),
+  inRegistry: z["boolean"]().nullish(),
+  imageIds: z.array(z.string()).nullish()
+});
+var BeneficiaryCompanyCustomerClaimsArray = z.array(BeneficiaryCompanyCustomerClaims);
+var SumSubCompanyApplicantInfo = z.object({
+  companyName: z.string(),
+  registrationNumber: z.string(),
+  country: ISO3CountryCode,
+  legalAddress: z.string().nullish(),
+  incorporatedOn: z.coerce.date().nullish(),
+  type: z.string().nullish(),
+  email: z.string().nullish(),
+  phone: z.string().nullish(),
+  controlScheme: z.string().nullish(),
+  taxId: z.string().nullish(),
+  registrationLocation: z.string().nullish(),
+  postalAddress: z.string().nullish(),
+  addresses: z.array(z.string()).nullish(),
+  website: z.string().nullish(),
+  noUBOs: z["boolean"]().nullish(),
+  beneficiaries: BeneficiaryCompanyCustomerClaimsArray.nullish()
+});
+var SUMSUB_WEBHOOK_INTERNAL_STATUS = ["started", "handled"];
+var SumsubWebhookInternalStatus = z["enum"](SUMSUB_WEBHOOK_INTERNAL_STATUS);
+var SUMSUB_REVIEW_STATUSES = ["init", "pending", "prechecked", "queued", "completed", "onHold"];
+var SumSubReviewStatus = z["enum"](SUMSUB_REVIEW_STATUSES);
+/**
+ * Value	Description
+ * ID_CARD	An ID card
+ * PASSPORT	A passport
+ * DRIVERS	A driving license
+ * RESIDENCE_PERMIT	Residence permit or registration document in the foreign city/country
+ * UTILITY_BILL	Proof of address document. Check here for the full list of acceptable docs as UTILITY_BILL
+ * SELFIE	A selfie with a document
+ * VIDEO_SELFIE	A selfie video (can be used in webSDK or mobileSDK)
+ * PROFILE_IMAGE	A profile image, i.e. avatar (in this case no additional metadata should be sent)
+ * ID_DOC_PHOTO	Photo from an ID doc (like a photo from a passport) (No additional metadata should be sent)
+ * AGREEMENT	Agreement of some sort, e.g. for processing personal info
+ * CONTRACT	Some sort of contract
+ * DRIVERS_TRANSLATION	Translation of the driving license required in the target country
+ * INVESTOR_DOC	A document from an investor, e.g. documents which disclose assets of the investor
+ * VEHICLE_REGISTRATION_CERTIFICATE	Certificate of vehicle registration
+ * INCOME_SOURCE	A proof of income
+ * PAYMENT_METHOD	Entity confirming payment (like bank card, crypto wallet, etc)
+ * BANK_CARD	A bank card, like Visa or Maestro
+ * COVID_VACCINATION_FORM	COVID vaccination document (may contain the QR code)
+ * OTHER	Should be used only when nothing else applies
+ * #
+ */
+
+var SUMSUB_DOC_TYPES = ["ID_CARD", "PASSPORT", "DRIVERS", "RESIDENCE_PERMIT", "UTILITY_BILL", "SELFIE", "VIDEO_SELFIE", "PROFILE_IMAGE", "ID_DOC_PHOTO", "AGREEMENT", "CONTRACT", "DRIVERS_TRANSLATION", "INVESTOR_DOC", "VEHICLE_REGISTRATION_CERTIFICATE", "INCOME_SOURCE", "PAYMENT_METHOD", "BANK_CARD", "COVID_VACCINATION_FORM", "OTHER"];
+var SumSubDocType = z["enum"](SUMSUB_DOC_TYPES);
+var SUMSUB_FLOW_LEVEL = ["basic-kyc-level", "basic-kyc-level+aml", "liveness-level", "id+liveness", "kyc", "phone-level", "kyc_video", "nid-idscan-selfie-por", "NID - ID Scan + Selfie + POR", "nid-idscan-selfie", "NIDKYB", "selfie", "ID Scan", "kyc-video-id+selfie", "kyc-video-id+selfie+por"];
+var SumSubFlowLevel = z["enum"](SUMSUB_FLOW_LEVEL);
+
+var SumSubReviewResultSchema = z.object({
+  reviewAnswer: SumSubReviewAnswer.optional(),
+  rejectLabels: z.array(SumSubReviewRejectLabel).optional(),
+  reviewRejectType: SumSubReviewRejectType.optional(),
+  clientComment: z.string().optional(),
+  moderationComment: z.string().optional(),
+  buttonIds: z.array(z.string()).optional(),
+  reviewDate: z.coerce.date().optional()
+});
+var SumSubImageReviewResultSchema = z.object({
+  reviewAnswer: SumSubReviewAnswer.optional(),
+  moderationComment: z.string().optional(),
+  clientComment: z.string().optional(),
+  rejectLabels: z.array(SumSubReviewRejectLabel).optional(),
+  reviewRejectType: SumSubReviewRejectType.optional()
+});
+var SumsubApplicantTypes = ["individual", "company"];
+var SumsubApplicantType = z["enum"](SumsubApplicantTypes);
+var SumSubIndividualApplicantSchema = z.object({
+  id: z.string().describe("An applicantId."),
+  createdAt: z.string().describe("Date of creation of the applicant."),
+  sourceKey: z.string().describe("If you want to separate your clients that send applicants, provide this field to distinguish between them. It also shows up at the webhook payloads.").optional(),
+  email: z.string().optional(),
+  phone: z.string().optional(),
+  lang: z.string().optional().describe("The language in which the applicant should see the result of verification in ISO 639-1 format."),
+  metadata: z.array(z.record(z.string())).optional().describe("Additional information that is not displayed to the end user"),
+  key: z.string(),
+  clientId: z.string(),
+  inspectionId: z.string(),
+  externalUserId: z.string(),
+  info: SumSubApplicantInfo.nullish(),
+  fixedInfo: SumSubApplicantInfo.nullish(),
+  applicantPlatform: z.string(),
+  ipCountry: z.string().optional(),
+  agreement: z.object({
+    createdAt: z.string(),
+    source: z.string(),
+    targets: z.array(z.string()).optional(),
+    privacyNoticeUrl: z.string().nullish()
+  }).nullish(),
+  review: z.object({
+    reviewId: z.string(),
+    attemptId: z.string(),
+    attemptCnt: z.number(),
+    elapsedSincePendingMs: z.number().optional(),
+    elapsedSinceQueuedMs: z.number().optional(),
+    reprocessing: z["boolean"]().optional(),
+    levelName: z.string(),
+    levelAutoCheckMode: z["null"](),
+    createDate: z.string(),
+    reviewDate: z.coerce.date().optional(),
+    reviewResult: SumSubReviewResultSchema.optional(),
+    reviewStatus: SumSubReviewStatus.optional(),
+    confirmed: z["boolean"]().optional(),
+    priority: z.number()
+  }),
+  type: SumsubApplicantType
+});
+var SumSubCompanyApplicantSchema = z.object({
+  id: z.string(),
+  createdAt: z.string(),
+  // key: z.string(),
+  // clientId: z.string(),
+  inspectionId: z.string(),
+  externalUserId: z.string(),
+  info: z.object({
+    idDocs: z.array(z.object({
+      idDocType: z.string(),
+      country: z.string()
+      // documentId: z.string(), //Id from document table
+    })),
+    companyInfo: SumSubCompanyApplicantInfo.nullish()
+  }).nullish(),
+  applicantPlatform: z.string(),
+  ipCountry: z.string().nullish(),
+  agreement: z.object({
+    createdAt: z.string().optional(),
+    acceptedAt: z.string().optional(),
+    source: z.string().optional(),
+    targets: z.array(z.string()).optional(),
+    privacyNoticeUrl: z.string().optional()
+  }).nullish(),
+  review: z.object({
+    reviewId: z.string(),
+    attemptId: z.string(),
+    attemptCnt: z.number(),
+    elapsedSincePendingMs: z.number(),
+    elapsedSinceQueuedMs: z.number(),
+    reprocessing: z["boolean"](),
+    levelName: z.string(),
+    levelAutoCheckMode: z["null"](),
+    createDate: z.string(),
+    reviewDate: z.coerce.date().optional(),
+    reviewResult: z.object({
+      reviewAnswer: z.string()
+    }),
+    reviewStatus: z.string(),
+    confirmed: z["boolean"](),
+    priority: z.number()
+  }).partial(),
+  lang: z.string().nullish(),
+  type: SumsubApplicantType
+});
+var SumSubImageId = z.coerce.number();
+var SUMSUB_COMPANY_BENEFICIARY_GROUP = ["company", "ubos", "shareholders", "representatives", "directors"];
+var SumsubCompanyBeneficiaryGroup = z["enum"](SUMSUB_COMPANY_BENEFICIARY_GROUP);
+var SumsubStepStatus = z.object({
+  name: SumsubCompanyBeneficiaryGroup,
+  reviewStatus: SumSubReviewStatus.nullish(),
+  reviewResult: SumSubReviewResultSchema.nullish(),
+  images: z.array(z.object({
+    imageId: SumSubImageId,
+    idDocType: z.string(),
+    idDocSubType: z.string()
+  })).nullish()
+});
+var SumSubVerificationStepSchema = z.object({
+  reviewResult: SumSubReviewResultSchema.optional(),
+  country: z.string().nullish(),
+  idDocType: z.string().nullish(),
+  imageIds: z.array(SumSubImageId).nullish(),
+  imageReviewResults: z.record(SumSubImageId, SumSubImageReviewResultSchema).nullish(),
+  stepStatuses: z.array(SumsubStepStatus).nullish()
+});
+var SumSubApplicantVerificationStepSchema = z.record(SumSubStep, SumSubVerificationStepSchema.nullish()).nullish();
+var SumSubApplicantModerationStatusSchema = z.object({
+  list: z.object({
+    totalItems: z.number(),
+    items: z.array(z.object({
+      id: z.string(),
+      applicantId: z.string(),
+      key: z.string(),
+      imagesStates: z.record(z.string(), z.object({
+        state: z.record(z.string(), z.object({
+          value: z["boolean"]().optional()
+        }))
+      })).nullish().describe("Structure contains imageId and buttonId which indicate rejection reason"),
+      applicantState: z.record(z.string(), z.object({
+        value: z["boolean"]().optional()
+      })).nullish().describe("Structure contains buttonId which indicate rejection reason of applicant data or applicant itself")
+    }))
+  })
+});
+var SUMSUB_MEDIA_CONTENT_TYPES = ["image/jpeg", "image/png", "application/pdf", "video/mp4", "video/webm", "video/quicktime"];
+var SumSubMediaContentType = z["enum"](SUMSUB_MEDIA_CONTENT_TYPES);
+var DocumentMetadataSchema = z.object({
+  country: z.string(),
+  idDocType: z.string(),
+  idDocSubType: z.string().nullish(),
+  firstName: z.string().nullish(),
+  lastName: z.string().nullish(),
+  dob: z.string().nullish(),
+  placeOfBirth: z.string().nullish(),
+  issuedDate: z.string().nullish(),
+  validUntil: z.string().nullish(),
+  number: z.string().nullish()
+});
+var SumSubApplicantReviewStatusSchema = z.object({
+  createDate: z.string().optional(),
+  reviewDate: z.string().optional(),
+  startDate: z.string().optional(),
+  reviewResult: SumSubReviewResultSchema.optional(),
+  reviewStatus: SumSubReviewStatus.optional(),
+  levelName: z.string().optional(),
+  attemptCnt: z.number().optional()
+});
+var SumSubApplicantResetSchema = z.object({
+  ok: z.literal(1)
+});
+var SumSubGenerateExternalWebSdkLinkSchema = z.object({
+  url: z.string()
+});
+var SumsubVideoCallData = z.object({
+  id: z.string(),
+  videoIdentData: z.object({
+    reviewStatus: z.string().nullish(),
+    roomId: z.string().nullish(),
+    modifiedAt: z.string().nullish(),
+    moderatorDisplayName: z.string().nullish(),
+    compositions: z.array(z.object({
+      compositionSid: z.string(),
+      roomSid: z.string(),
+      roomDuration: z.number(),
+      compositionDuration: z.number(),
+      compositionMediaId: z.string()
+    }).nullish()).nullish()
+  }).nullish()
+});
+var SumsubKycDataSchema = z.object({
+  id: z.string(),
+  sumsubApplicantId: z.string(),
+  kycSessionId: z.string(),
+  applicantData: SumSubIndividualApplicantSchema,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date()
+});
+var SumsubKybDataSchema = z.object({
+  id: z.string(),
+  sumsubApplicantId: z.string(),
+  kybSessionId: z.string(),
+  applicantData: SumSubCompanyApplicantSchema,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date()
+});
+var SumSubApplicantSchema = z.union([SumSubIndividualApplicantSchema, SumSubCompanyApplicantSchema]);
+var SUMSUB_KYB_SESSION_FLOW_SECTION_STATUS = ["pending", "success", "failed"];
+var SumsubKybSessionFlowSectionStatus = z["enum"](SUMSUB_KYB_SESSION_FLOW_SECTION_STATUS);
+var SumsubKybSessionFlowSectionItem = z.object({
+  name: z.string(),
+  detail: z.string(),
+  status: SumsubKybSessionFlowSectionStatus
+});
+var SumsubKybSessionFlowSection = z.array(SumsubKybSessionFlowSectionItem);
+var SumSubSimilarApplicantSchema = z.object({
+  applicant: SumSubApplicantSchema.optional(),
+  matchedFields: z.array(z.string().optional()).optional(),
+  exactMatch: z["boolean"]().optional(),
+  blacklisted: z["boolean"]().optional(),
+  sameSource: z["boolean"]().optional(),
+  types: z.array(z.any()).optional(),
+  originalImageId: z.number().optional(),
+  similaritySource: z.any().optional(),
+  similarityConfidence: z.any().optional()
+});
+var SumSubSimilarApplicantsSchema = z.object({
+  similarApplicants: z.array(SumSubSimilarApplicantSchema).optional()
+});
+
+var WEBHOOK_TYPES = ["applicantReviewed", "applicantCreated", "applicantPending", "applicantOnHold", "applicantPersonalInfoChanged", "applicantPrechecked", "applicantDeleted", "applicantLevelChanged", "videoIdentStatusChanged", "applicantReset", "applicantActionPending", "applicantActionReviewed", "applicantActionOnHold", "applicantTravelRuleStatusChanged", "applicantWorkflowCompleted", "applicantTagsChanged"];
+var WebhookType = z["enum"](WEBHOOK_TYPES);
+var ApplicantMemberOfSchema = z.array(z.object({
+  applicantId: z.string()
+}));
+var SumSubWebhookSchema = z.object({
+  applicantId: z.string(),
+  inspectionId: z.string(),
+  applicantType: SumSubApplicantType,
+  // when type is "applicantOnHold" | "applicantPersonalInfoChanged"
+  correlationId: z.string(),
+  levelName: SumSubFlowLevel,
+  sandboxMode: z.coerce["boolean"](),
+  externalUserId: z.string(),
+  // should be UUID String because this is our internal user id
+  type: WebhookType,
+  reviewResult: SumSubReviewResultSchema.nullish(),
+  // when type is "applicantReviewed"  | "applicantPersonalInfoChanged"
+  reviewStatus: SumSubReviewStatus,
+  createdAtMs: z.string().nullish(),
+  clientId: z.string(),
+  videoIdentReviewStatus: z.string().nullish(),
+  // when type is "videoIdentStatusChanged"
+  applicantMemberOf: ApplicantMemberOfSchema.nullish() // for beneficiaries related to companies
+});
+var BaseApplicantActionSchema = z.object({
+  applicantId: z.string(),
+  applicantActionId: z.string(),
+  inspectionId: z.string(),
+  correlationId: z.string(),
+  externalUserId: z.string(),
+  // should be UUID String because this is our internal user id
+  type: WebhookType,
+  reviewStatus: SumSubReviewStatus,
+  createdAtMs: z.string(),
+  externalApplicantActionId: z.string(),
+  applicantType: SumSubApplicantType,
+  reviewResult: SumSubReviewResultSchema
+});
+
+var KYC_STEP_TYPES = ["Started", "TermsAndConditionsAccepted", "Identity", "Liveness", "ProofOfResidence", "ContactInfo"];
+var KycStep = z["enum"](KYC_STEP_TYPES);
+var KYC_RESULTS = ["Passed", "ToBeManuallyChecked",
+// use in case applicantReviewed event comes without reviewResult.reviewAnswer
+"Rejected", "Retry"];
+var KycResult = z["enum"](KYC_RESULTS);
+var KYC_SESSION_STATUSES = ["NotStarted",
+// when we ask for current session and it does not exists
+"Started",
+// when we receive applicantCreated event
+"UserDataSubmitted",
+// when we receive applicantPending event
+"VerificationChecked",
+// when we receive applicantReviewed event
+"CredentialsClaimed",
+// once verifiable credentials were claimed
+"Closed" // when we reset the applicant ???
+];
+var KycSessionStatus = z["enum"](KYC_SESSION_STATUSES);
+var SelectKycSession = z.object({
+  id: UuidString,
+  customerId: UuidString,
+  address: BlockchainAddress.nullish(),
+  blockchainNamespace: BlockchainNamespace.nullish(),
+  sandboxSimulated: z.coerce["boolean"]().nullish(),
+  cmsProjectId: z.string(),
+  result: KycResult.nullish(),
+  reviewAnswer: SumSubReviewAnswer.nullish(),
+  reviewRejectType: SumSubReviewRejectType.nullish(),
+  sandboxMode: z.coerce["boolean"]().nullish(),
+  status: KycSessionStatus.nullish(),
+  ip: z.string().nullish(),
+  notificationEmail: z.string().nullish(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  scenarioExecutions: SdkVerificationOutput.nullish(),
+  workflowId: z.string().nullable()
+});
+var SelectKycSessionStep = z.object({
+  id: UuidString,
+  type: KycStep,
+  customerId: UuidString,
+  kycSessionId: UuidString,
+  createdAt: z.coerce.date()
+});
+var GetKycSessionInput = z.object({
+  projectId: z.string()
+});
+var GetKycSessionResponse = SelectKycSession.extend({
+  stepsCompleted: z.array(SelectKycSessionStep),
+  customerStatus: CustomerStatus.nullish(),
+  sumSubReviewResult: z.object(_defineProperty(_defineProperty({}, SumSubStep["enum"].IDENTITY, z.array(SumSubReviewRejectLabel)), SumSubStep["enum"].SELFIE, z.array(SumSubReviewRejectLabel))).nullish()
+});
+var UpdateKycSessionOutput = z.string();
+var VideoKycMetaData = z.object({
+  id: z.string(),
+  journeyId: z.string(),
+  reviewStatus: z.string(),
+  roomId: z.string(),
+  moderatorDisplayName: z.string()
+});
+var ProofOfResidenceMetaData = ProofOfResidenceCredentialSubjectSchema.omit({
+  base64: true,
+  id: true
+});
+var ProofOfResidenceDocumentType = ProofOfResidenceMetaData.shape.documentType;
+var GetCredentialsOutput = z.object({
+  IDInformation: QrCodeLinkWithSchemaType.optional(),
+  SelfieImage: QrCodeLinkWithSchemaType.optional(),
+  IDImage: QrCodeLinkWithSchemaType.optional(),
+  ProofOfResidence: QrCodeLinkWithSchemaType.optional()
+});
+var CustomerContactInformationOutput = z.object({
+  id: z.string(),
+  customerId: z.string(),
+  information: BasicCustomerContactInformation,
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CredentialMetadata = z.object({
+  type: CredentialType,
+  imageId: z.number().nullish()
+});
+var GetKycSessionResponseWithCredentialsMetadata = GetKycSessionResponse.extend({
+  credentialsMetadata: z.array(CredentialMetadata),
+  applicantName: z.string().nullish(),
+  applicationDate: z.string().nullish()
+});
+
+var KYB_STEP_TYPES = ["Started"];
+var KybStep = z["enum"](KYB_STEP_TYPES);
+var KYB_RESULTS = ["Passed", "ToBeManuallyChecked",
+// use in case applicantReviewed event comes without reviewResult.reviewAnswer
+"Rejected", "Retry"];
+var KybResult = z["enum"](KYB_RESULTS);
+var KYB_SESSION_STATUSES = ["NotStarted", "Started", "Closed"];
+var KybSessionStatus = z["enum"](KYB_SESSION_STATUSES);
+// TODO: @MrRaccxxn - This types now will be duplicated in sub steps workflow
+
+var COMPANY_ID_DOC_SUBTYPES = ["INCORPORATION_CERT", "INCORPORATION_ARTICLES", "SHAREHOLDER_REGISTRY"];
+var CompanyIdDocSubType = z["enum"](COMPANY_ID_DOC_SUBTYPES);
+var CompanyDocumentMetaData = z.object({
+  sumsubImageId: z.number(),
+  mediaType: z["enum"](["image/jpeg", "image/jpg", "image/png"]),
+  journeyId: z.string(),
+  documentType: CompanyIdDocSubType,
+  name: z.string().optional(),
+  entryDate: z.number()["int"](),
+  entryTime: z.string(),
+  isSandbox: z["boolean"]()
+});
+var BeneficiaryVerificationStatus = z.object({
+  name: z.string(),
+  customerId: z.string().uuid(),
+  applicantId: z.string(),
+  externalUserId: z.string(),
+  levelName: z.string(),
+  calculatedResult: KybResult.nullish(),
+  reviewAnswer: SumSubReviewAnswer.nullish(),
+  reviewRejectType: SumSubReviewRejectType.nullish(),
+  type: BeneficiaryType.nullish()
+});
+var BeneficiaryVerificationStatusArray = z.array(BeneficiaryVerificationStatus);
+var SelectKybSession = z.object({
+  id: UuidString,
+  customerId: UuidString,
+  address: BlockchainAddress.nullish(),
+  cmsProjectId: z.string(),
+  result: KybResult.nullish(),
+  reviewAnswer: SumSubReviewAnswer.nullish(),
+  reviewRejectType: SumSubReviewRejectType.nullish(),
+  sandboxMode: z.coerce["boolean"]().nullish(),
+  status: KybSessionStatus.nullish(),
+  ip: z.string().nullish(),
+  sandboxSimulated: z.coerce["boolean"]().nullish(),
+  beneficiaries: BeneficiaryVerificationStatusArray.nullish(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date()
+  //   notificationEmail: z.string().nullish(),
+  //   scenarioExecutions: SdkVerificationOutput.nullish(),
+});
+var GetKybSessionInput = z.object({
+  projectId: z.string()
+});
+// export const GetKybSessionResponse = SelectKybSession.extend({
+//   sumSubReviewResult: z
+//     .object({
+//       [SumSubStep.enum.IDENTITY]: z.array(SumSubReviewRejectLabel),
+//       [SumSubStep.enum.SELFIE]: z.array(SumSubReviewRejectLabel),
+//     })
+//     .nullish(),
+// });
+var GetKybSessionResponse = SelectKybSession;
+var UpdateKybSessionOutput = z.string();
+
+var CustomerDocumentMetaData = z.union([CompanyDocumentMetaData, ProofOfResidenceMetaData, VideoKycMetaData]);
+var CustomerStatusResults = z.union([KybResult, KycResult]);
+
+var ChainalysisRequest = z.object({
+  address: z.string()
+});
+var EnhancedChainalysisRequest = z.object({
+  request: ChainalysisRequest,
+  customerId: UuidString
+});
+var ChainalysisRegisterApiResponse = z.object({
+  address: z.string()
+});
+var Risk = z["enum"](["Severe", "High", "Medium", "Low"]);
+var AddressType = z["enum"](["PRIVATE_WALLET", "LIQUIDITY_POOL", "SERVICE_PROVIDER"]);
+var ExposureType = z["enum"](["direct", "indirect"]);
+var Direction = z.literal("both_directions");
+var Status = z.literal("COMPLETE");
+var Cluster = z.object({
+  name: z.string(),
+  category: z.string()
+});
+var AddressIdentification = z.object({
+  name: z.string(),
+  address: z.string(),
+  category: z.string(),
+  description: z.string(),
+  url: z.string().nullish(),
+  createdAt: z.number()
+});
+var Exposure = z.object({
+  category: z.string(),
+  value: z.number(),
+  exposureType: ExposureType,
+  direction: Direction
+});
+var RuleTriggered = z.object({
+  risk: z.string(),
+  minThreshold: z.number(),
+  maxThreshold: z.number(),
+  exposureType: ExposureType,
+  direction: Direction
+});
+var Trigger = z.object({
+  category: z.string(),
+  percentage: z.number(),
+  message: z.string(),
+  ruleTriggered: RuleTriggered.nullish()
+});
+var PoolMetadata = z.object({
+  fees: z.number().nullish(),
+  tokens: z.array(z.string())
+});
+var ChainalysisRiskAssessmentApiResponse = z.object({
+  address: z.string(),
+  risk: Risk,
+  riskReason: z.string().nullish(),
+  cluster: Cluster.nullish(),
+  addressType: AddressType,
+  addressIdentifications: z.array(AddressIdentification),
+  exposures: z.array(Exposure).nullish(),
+  triggers: z.array(Trigger).nullish(),
+  status: Status,
+  poolMetadata: PoolMetadata.nullish()
+});
+var ChainalysisApiError = z.object({
+  error: z.object({
+    error: z.string(),
+    message: z.string(),
+    data: z.string().nullish()
+  })
+});
+var ChainalysisRegisterResponse = z.union([ChainalysisRegisterApiResponse, ChainalysisApiError]);
+var ChainalysisRiskAssessmentResponse = z.union([ChainalysisRiskAssessmentApiResponse, ChainalysisApiError]);
+var ChainalysisResponse = z.union([ChainalysisRegisterResponse, ChainalysisRiskAssessmentResponse]);
+
+export { EmailMetadata as $, ANALYSIS_TYPES as A, BitRankVerifiedResponse as B, ComplyAdvantageSearchResponse as C, Session as D, EmailVerificationAnalysisResponse as E, SessionWithoutSteps as F, StepTypes as G, StepType as H, IpQualityServiceAnalysisResponse as I, ReasonCodes as J, ReasonCode as K, File as L, MergedProviders as M, NestedSession as N, OBJECT_TYPES as O, PhoneVerificationAnalysisResponse as P, DocumentIdTypes as Q, RiskSeverity as R, ScoringAnalysisResponse as S, DocumentIdType as T, DocumentIdMetadata as U, ProofOfAddressDocumentTypes as V, WorkflowsScoringAnalysisRequest as W, ProofOfAddressDocumentType as X, ProofOfAddressMetadata as Y, LivenessMetadata as Z, PhoneMetadata as _, MerkleAddressResponse as a, ComplyAdvantageUpdateSearchEntitiesSuccessResponse as a$, AMLMetadata as a0, Step as a1, SynapsSessionEvent as a2, SynapsStepEvent as a3, typeToHumanReadable as a4, SynapsSessionRequest as a5, SESSION_NOT_FOUND as a6, UNKNOWN_ERROR as a7, RESULT_PARSER_ERROR as a8, SynapsSessionErrorResponse as a9, COMPLY_ADVANTAGE_COUNTRY_FIELD_SOURCES as aA, ComplyAdvantageCountryFieldSources as aB, COMPLY_ADVANTAGE_DATE_OF_BIRTH_FIELD_SOURCES as aC, ComplyAdvantageDateOfBirthFieldSources as aD, CreateSearchInput as aE, MatchStatuses as aF, MatchStatus as aG, RiskLevels as aH, RiskLevel as aI, UpdateSearchInput as aJ, UpdateSearchEntitiesInput as aK, ComplyAdvantageUser as aL, MatchTypeDetail as aM, ComplyAdvantageMedia as aN, ComplyAdvantageSearchDataResponseHit as aO, ComplyAdvantageSearchDataResponse as aP, ComplyAdvantageSearchSuccessResponse as aQ, ComplyAdvantageSearchErrorResponse as aR, ComplyAdvantageKeyInformation as aS, ComplyAdvantageAmlItemSource as aT, ComplyAdvantageAmlFullListing as aU, ComplyAdvantageSearchEntitiesDataResponse as aV, ComplyAdvantageSearchEntitiesSuccessResponse as aW, ComplyAdvantageSearchEntitiesResponse as aX, ComplyAdvantageSearchRequest as aY, ComplyAdvantageUpdateSearchRequest as aZ, ComplyAdvantageUpdateSearchEntitiesRequest as a_, SynapsSessionResponse as aa, SynapsStepRequest as ab, STEP_NOT_FOUND as ac, SynapsStepErrorResponse as ad, SynapsStepResponse as ae, CoerceDateUTC as af, SEARCH_FILTER_SANCTION_TYPE as ag, SearchFilterSanctionType as ah, SEARCH_FILTER_PEP_TYPE as ai, SearchFilterPepType as aj, SEARCH_FILTER_ADVERSE_MEDIA_TYPE as ak, SearchFilterAdverseMediaType as al, HIGH_RISK_TYPES as am, MEDIUM_RISK_TYPES as an, COMPLY_ADVANTAGE_RESPONSE_MATCH_TYPE as ao, ComplyAdvantageResponseMatchType as ap, mappingMatchTypeToLabel as aq, COMPLY_ADVANTAGE_RESPONSE_MATCH_STATUS as ar, ComplyAdvantageReponseMatchStatus as as, SEARCH_FILTER_TYPES as at, SearchFilterType as au, SearchEntityTypes as av, SearchEntityType as aw, SearchFilters as ax, COMPLY_ADVANTAGE_NATIONALITY_FIELD_SOURCES as ay, ComplyAdvantageNationalityFieldSources as az, AnalysisType as b, SUMSUB_REVIEW_STATUSES as b$, ComplyAdvantageUpdateSearchEntitiesResponse as b0, ComplyAdvantageMonitorSearchDataResponse as b1, ComplyAdvantageMonitorSearchSuccessResponse as b2, ComplyAdvantageMonitorSearchResponse as b3, ComplyAdvantageMonitoredSearchUpdate as b4, IdentityProviderOptions as b5, IdentityProviders as b6, DataProviderOptions as b7, DataProviders as b8, MerkleScienceConfig as b9, ToggleProviderInput as bA, DeleteProviderInput as bB, DeleteProviderResponse as bC, WEBHOOK_TYPES as bD, WebhookType as bE, ApplicantMemberOfSchema as bF, SumSubWebhookSchema as bG, BaseApplicantActionSchema as bH, SUMSUB_STEPS as bI, SumSubStep as bJ, SUMSUB_APPLICANT_TYPES as bK, SumSubApplicantType as bL, SUMSUB_REVIEW_ANSWERS as bM, SumSubReviewAnswer as bN, SUMSUB_REVIEW_REJECT_TYPES as bO, SumSubReviewRejectType as bP, SumSubAddress as bQ, SumSubApplicantInfo as bR, INDIVIDUAL_BENEFICIARY_RELATIONS as bS, IndividualBeneficiaryRelation as bT, BENEFICIARY_TYPES as bU, BeneficiaryType as bV, BeneficiaryCompanyCustomerClaims as bW, BeneficiaryCompanyCustomerClaimsArray as bX, SumSubCompanyApplicantInfo as bY, SUMSUB_WEBHOOK_INTERNAL_STATUS as bZ, SumsubWebhookInternalStatus as b_, ScorechainConfig as ba, WorkflowsScorechainConfig as bb, IpQualityConfig as bc, BigConfig as bd, ProviderIntegrationTypeOptions as be, ProviderIntegrationType as bf, BaseProvider as bg, NexeraIdSSIDProvider as bh, NexeraIdKYBProvider as bi, BigProvider as bj, ScorechainProvider as bk, MerkleScienceProvider as bl, IpqualityscoreProvider as bm, ComplyAdvantageProviderConfigTypes as bn, ComplyAdvantageProviderConfigFilters as bo, ComplyAdvantageProviderConfigElement as bp, ComplyAdvantageProvider as bq, SynapsProvider as br, ProviderData as bs, ProviderDataProject as bt, GetProvidersResponse as bu, GetProviderResponse as bv, CreateProviderInput as bw, CreateProviderResponse as bx, UpdateProviderInput as by, UpdateProviderResponse as bz, ObjectType as c, SelectKybSession as c$, SumSubReviewStatus as c0, SUMSUB_DOC_TYPES as c1, SumSubDocType as c2, SUMSUB_FLOW_LEVEL as c3, SumSubFlowLevel as c4, SumSubReviewResultSchema as c5, SumSubImageReviewResultSchema as c6, SumsubApplicantTypes as c7, SumsubApplicantType as c8, SumSubIndividualApplicantSchema as c9, KYC_STEP_TYPES as cA, KycStep as cB, KYC_RESULTS as cC, KycResult as cD, KYC_SESSION_STATUSES as cE, KycSessionStatus as cF, SelectKycSession as cG, SelectKycSessionStep as cH, GetKycSessionInput as cI, GetKycSessionResponse as cJ, UpdateKycSessionOutput as cK, VideoKycMetaData as cL, ProofOfResidenceMetaData as cM, ProofOfResidenceDocumentType as cN, GetCredentialsOutput as cO, CustomerContactInformationOutput as cP, CredentialMetadata as cQ, GetKycSessionResponseWithCredentialsMetadata as cR, KYB_STEP_TYPES as cS, KybStep as cT, KYB_RESULTS as cU, KybResult as cV, KYB_SESSION_STATUSES as cW, KybSessionStatus as cX, CompanyDocumentMetaData as cY, BeneficiaryVerificationStatus as cZ, BeneficiaryVerificationStatusArray as c_, SumSubCompanyApplicantSchema as ca, SumSubImageId as cb, SUMSUB_COMPANY_BENEFICIARY_GROUP as cc, SumsubCompanyBeneficiaryGroup as cd, SumsubStepStatus as ce, SumSubVerificationStepSchema as cf, SumSubApplicantVerificationStepSchema as cg, SumSubApplicantModerationStatusSchema as ch, SUMSUB_MEDIA_CONTENT_TYPES as ci, SumSubMediaContentType as cj, DocumentMetadataSchema as ck, SumSubApplicantReviewStatusSchema as cl, SumSubApplicantResetSchema as cm, SumSubGenerateExternalWebSdkLinkSchema as cn, SumsubVideoCallData as co, SumsubKycDataSchema as cp, SumsubKybDataSchema as cq, SumSubApplicantSchema as cr, SUMSUB_KYB_SESSION_FLOW_SECTION_STATUS as cs, SumsubKybSessionFlowSectionStatus as ct, SumsubKybSessionFlowSectionItem as cu, SumsubKybSessionFlowSection as cv, SumSubSimilarApplicantsSchema as cw, SUMSUB_REVIEW_REJECT_LABELS as cx, SumSubReviewRejectLabel as cy, SUMSUB_REVIEW_REJECT_LABELS_DESCRIPTION as cz, BLOCKCHAIN_TYPES as d, GetKybSessionInput as d0, GetKybSessionResponse as d1, UpdateKybSessionOutput as d2, CustomerDocumentMetaData as d3, CustomerStatusResults as d4, MerkleBlockChainTypes as d5, MerkleBlockChainNames as d6, MerkleBlockChainCodes as d7, MerkleAddressRequest as d8, MerkleAddressApiResponse as d9, MerkleAddressApiError as da, ChainalysisRequest as db, EnhancedChainalysisRequest as dc, ChainalysisRegisterApiResponse as dd, ChainalysisRiskAssessmentApiResponse as de, ChainalysisApiError as df, ChainalysisRegisterResponse as dg, ChainalysisRiskAssessmentResponse as dh, ChainalysisResponse as di, Blockchain as e, Coin as f, ScorechainErrorResponse as g, ScorechainError as h, ScorechainAnalysis as i, ScoringAnalysisRequest as j, IpQualityAnalysisRequest as k, IpQualityAnalysisResponse as l, IpQualityServiceAnalysis as m, IpQualityServiceErrorResponse as n, BigCryptoChain as o, BigPropertiesLiteral as p, BigProperties as q, BigProperty as r, RequestProperty as s, BitRankRequest as t, BitRankVerified as u, BitRankVerifiedErrorResponse as v, BitRankVerifiedError as w, Statuses as x, Status$1 as y, WebhookPayload as z };