@nexeraid/identity-schemas 2.37.0 → 2.38.0-dev

package/dist/identity-api.schema-774e69d4.cjs.prod.cjs

@@ -0,0 +1,2012 @@
+'use strict';
+
+var zod = require('zod');
+var vault_schema = require('./vault.schema-d868aba3.cjs.prod.cjs');
+var nanoid = require('nanoid');
+
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+
+/////////////////////////////////////////
+//          APTOS                      //
+/////////////////////////////////////////
+
+var NEXERA_APTOS_CHAINS = /*#__PURE__*/function (NEXERA_APTOS_CHAINS) {
+  NEXERA_APTOS_CHAINS["MAINNET"] = "mainnet-aptos";
+  NEXERA_APTOS_CHAINS["TESTNET"] = "testnet-aptos";
+  return NEXERA_APTOS_CHAINS;
+}({});
+var APTOS_CHAIN_NAMES = _defineProperty(_defineProperty({}, NEXERA_APTOS_CHAINS.MAINNET, "Aptos Mainnet"), NEXERA_APTOS_CHAINS.TESTNET, "Aptos Testnet");
+var APTOS_CHAIN_NAMES_LIST = Object.values(APTOS_CHAIN_NAMES);
+var APTOS_CHAIN_IDS = _defineProperty(_defineProperty({}, NEXERA_APTOS_CHAINS.MAINNET, "mainnet-aptos"), NEXERA_APTOS_CHAINS.TESTNET, "testnet-aptos");
+var ACTIVE_APTOS_CHAIN_IDS = [NEXERA_APTOS_CHAINS.MAINNET, NEXERA_APTOS_CHAINS.TESTNET];
+var AptosChainId = zod.z["enum"](ACTIVE_APTOS_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+/////////////////////////////////////////
+//          BITCOIN                    //
+/////////////////////////////////////////
+
+var NEXERA_BITCOIN_CHAINS = /*#__PURE__*/function (NEXERA_BITCOIN_CHAINS) {
+  NEXERA_BITCOIN_CHAINS["MAINNET"] = "mainnet-bitcoin";
+  NEXERA_BITCOIN_CHAINS["TESTNET"] = "testnet-bitcoin";
+  return NEXERA_BITCOIN_CHAINS;
+}({});
+var BITCOIN_CHAIN_NAMES = _defineProperty(_defineProperty({}, NEXERA_BITCOIN_CHAINS.MAINNET, "Bitcoin Mainnet"), NEXERA_BITCOIN_CHAINS.TESTNET, "Bitcoin Testnet");
+var BITCOIN_CHAIN_NAMES_LIST = Object.values(BITCOIN_CHAIN_NAMES);
+var BITCOIN_CHAIN_IDS = _defineProperty(_defineProperty({}, NEXERA_BITCOIN_CHAINS.MAINNET, "mainnet-bitcoin"), NEXERA_BITCOIN_CHAINS.TESTNET, "testnet-bitcoin");
+var ACTIVE_BITCOIN_CHAIN_IDS = [NEXERA_BITCOIN_CHAINS.MAINNET, NEXERA_BITCOIN_CHAINS.TESTNET];
+var BitcoinChainId = zod.z["enum"](ACTIVE_BITCOIN_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+/////////////////////////////////////////
+//          CARDANO                    //
+/////////////////////////////////////////
+
+var NEXERA_CARDANO_CHAINS = /*#__PURE__*/function (NEXERA_CARDANO_CHAINS) {
+  NEXERA_CARDANO_CHAINS["MAINNET"] = "cardano-mainnet";
+  NEXERA_CARDANO_CHAINS["TESTNET"] = "cardano-testnet";
+  return NEXERA_CARDANO_CHAINS;
+}({});
+var CARDANO_CHAIN_NAMES = _defineProperty(_defineProperty({}, NEXERA_CARDANO_CHAINS.MAINNET, "Cardano Mainnet"), NEXERA_CARDANO_CHAINS.TESTNET, "Cardano Testnet");
+var CARDANO_CHAIN_NAMES_LIST = Object.values(CARDANO_CHAIN_NAMES);
+var CARDANO_CHAIN_IDS = _defineProperty(_defineProperty({}, NEXERA_CARDANO_CHAINS.MAINNET, "cardano-mainnet"), NEXERA_CARDANO_CHAINS.TESTNET, "cardano-testnet");
+var ACTIVE_CARDANO_CHAIN_IDS = [NEXERA_CARDANO_CHAINS.MAINNET, NEXERA_CARDANO_CHAINS.TESTNET];
+var CardanoChainId = zod.z["enum"](ACTIVE_CARDANO_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+/////////////////////////////////////////
+//          COSMOS                     //
+/////////////////////////////////////////
+
+var NEXERA_COSMOS_CHAINS = /*#__PURE__*/function (NEXERA_COSMOS_CHAINS) {
+  NEXERA_COSMOS_CHAINS["COSMOS"] = "cosmoshub-4";
+  NEXERA_COSMOS_CHAINS["COSMOS_TESTNET"] = "theta-testnet-001";
+  return NEXERA_COSMOS_CHAINS;
+}({});
+var COSMOS_CHAIN_NAMES = _defineProperty(_defineProperty({}, NEXERA_COSMOS_CHAINS.COSMOS, "Cosmos Mainnet"), NEXERA_COSMOS_CHAINS.COSMOS_TESTNET, "Cosmos Testnet");
+var COSMOS_CHAIN_NAMES_LIST = Object.values(COSMOS_CHAIN_NAMES);
+var COSMOS_CHAIN_IDS = _defineProperty(_defineProperty({}, NEXERA_COSMOS_CHAINS.COSMOS, "cosmoshub-4"), NEXERA_COSMOS_CHAINS.COSMOS_TESTNET, "theta-testnet-001");
+var ACTIVE_COSMOS_CHAIN_IDS = [NEXERA_COSMOS_CHAINS.COSMOS, NEXERA_COSMOS_CHAINS.COSMOS_TESTNET];
+var CosmosChainId = zod.z["enum"](ACTIVE_COSMOS_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+var _NEXERA_EVM_CHAIN_NAM, _EVM_BLOCK_TIME;
+var NEXERA_EVM_CHAINS = /*#__PURE__*/function (NEXERA_EVM_CHAINS) {
+  NEXERA_EVM_CHAINS["ETHEREUM"] = "1";
+  NEXERA_EVM_CHAINS["GOERLI"] = "5";
+  NEXERA_EVM_CHAINS["ARBITRUM"] = "42161";
+  NEXERA_EVM_CHAINS["ARBITRUM_GOERLI"] = "421613";
+  NEXERA_EVM_CHAINS["ARBITRUM_SEPOLIA"] = "421614";
+  NEXERA_EVM_CHAINS["OPTIMISM"] = "10";
+  NEXERA_EVM_CHAINS["OPTIMISM_GOERLI"] = "420";
+  NEXERA_EVM_CHAINS["OPTIMISM_SEPOLIA"] = "11155420";
+  NEXERA_EVM_CHAINS["AVALANCHE"] = "43114";
+  NEXERA_EVM_CHAINS["AVALANCHE_FUJI"] = "43113";
+  NEXERA_EVM_CHAINS["POLYGON"] = "137";
+  NEXERA_EVM_CHAINS["POLYGON_AMOY"] = "80002";
+  NEXERA_EVM_CHAINS["SEPOLIA"] = "11155111";
+  NEXERA_EVM_CHAINS["BASE"] = "8453";
+  NEXERA_EVM_CHAINS["BASE_GOERLI"] = "84531";
+  NEXERA_EVM_CHAINS["BASE_SEPOLIA"] = "84532";
+  NEXERA_EVM_CHAINS["MOONBEAM"] = "1284";
+  NEXERA_EVM_CHAINS["MOONRIVER"] = "1285";
+  NEXERA_EVM_CHAINS["BNB"] = "56";
+  NEXERA_EVM_CHAINS["BNB_TESTNET"] = "97";
+  NEXERA_EVM_CHAINS["SWISSTRONIK_TESTNET"] = "1291";
+  return NEXERA_EVM_CHAINS;
+}({});
+var NEXERA_EVM_CHAIN_NAMES = (_NEXERA_EVM_CHAIN_NAM = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_NEXERA_EVM_CHAIN_NAM, NEXERA_EVM_CHAINS.ETHEREUM, "Ethereum Mainnet"), NEXERA_EVM_CHAINS.SEPOLIA, "Sepolia Testnet"), NEXERA_EVM_CHAINS.POLYGON, "Polygon Mainnet"), NEXERA_EVM_CHAINS.POLYGON_AMOY, "Polygon Amoy Testnet"), NEXERA_EVM_CHAINS.AVALANCHE, "Avalanche Mainnet"), NEXERA_EVM_CHAINS.AVALANCHE_FUJI, "Avalanche Fuji Testnet"), NEXERA_EVM_CHAINS.ARBITRUM, "Arbitrum Mainnet"), NEXERA_EVM_CHAINS.ARBITRUM_SEPOLIA, "Arbitrum Sepolia Testnet"), NEXERA_EVM_CHAINS.BASE, "Base Mainnet"), NEXERA_EVM_CHAINS.BASE_SEPOLIA, "Base Sepolia Testnet"), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_NEXERA_EVM_CHAIN_NAM, NEXERA_EVM_CHAINS.BNB, "Binance Smart Chain Mainnet"), NEXERA_EVM_CHAINS.BNB_TESTNET, "Binance Smart Chain Testnet"), NEXERA_EVM_CHAINS.OPTIMISM, "Optimism Mainnet"), NEXERA_EVM_CHAINS.OPTIMISM_SEPOLIA, "Optimism Sepolia Testnet"), NEXERA_EVM_CHAINS.MOONBEAM, "Moonbeam Mainnet"), NEXERA_EVM_CHAINS.MOONRIVER, "Moonriver Mainnet"), NEXERA_EVM_CHAINS.SWISSTRONIK_TESTNET, "Swisstronik Testnet"));
+var NEXERA_EVM_CHAIN_NAMES_LIST = Object.values(NEXERA_EVM_CHAIN_NAMES);
+var NEXERA_EVM_CHAINS_ID = [NEXERA_EVM_CHAINS.ETHEREUM, NEXERA_EVM_CHAINS.GOERLI, NEXERA_EVM_CHAINS.ARBITRUM, NEXERA_EVM_CHAINS.ARBITRUM_GOERLI, NEXERA_EVM_CHAINS.ARBITRUM_SEPOLIA, NEXERA_EVM_CHAINS.OPTIMISM, NEXERA_EVM_CHAINS.OPTIMISM_GOERLI, NEXERA_EVM_CHAINS.OPTIMISM_SEPOLIA, NEXERA_EVM_CHAINS.AVALANCHE, NEXERA_EVM_CHAINS.AVALANCHE_FUJI, NEXERA_EVM_CHAINS.POLYGON, NEXERA_EVM_CHAINS.POLYGON_AMOY, NEXERA_EVM_CHAINS.SEPOLIA, NEXERA_EVM_CHAINS.BASE, NEXERA_EVM_CHAINS.BASE_GOERLI, NEXERA_EVM_CHAINS.BASE_SEPOLIA, NEXERA_EVM_CHAINS.MOONBEAM, NEXERA_EVM_CHAINS.MOONRIVER, NEXERA_EVM_CHAINS.BNB, NEXERA_EVM_CHAINS.BNB_TESTNET, NEXERA_EVM_CHAINS.SWISSTRONIK_TESTNET];
+var NexeraEvmChains = zod.z["enum"](NEXERA_EVM_CHAINS_ID);
+var EVM_BLOCK_TIME = (_EVM_BLOCK_TIME = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_EVM_BLOCK_TIME, NEXERA_EVM_CHAINS.ETHEREUM, 12), NEXERA_EVM_CHAINS.GOERLI, 12), NEXERA_EVM_CHAINS.SEPOLIA, 12), NEXERA_EVM_CHAINS.ARBITRUM, 0.26), NEXERA_EVM_CHAINS.ARBITRUM_GOERLI, 0.26), NEXERA_EVM_CHAINS.ARBITRUM_SEPOLIA, 0.26), NEXERA_EVM_CHAINS.OPTIMISM, 2), NEXERA_EVM_CHAINS.OPTIMISM_GOERLI, 2), NEXERA_EVM_CHAINS.OPTIMISM_SEPOLIA, 2), NEXERA_EVM_CHAINS.AVALANCHE, 3), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_EVM_BLOCK_TIME, NEXERA_EVM_CHAINS.AVALANCHE_FUJI, 3), NEXERA_EVM_CHAINS.POLYGON, 2), NEXERA_EVM_CHAINS.POLYGON_AMOY, 2), NEXERA_EVM_CHAINS.BASE, 2), NEXERA_EVM_CHAINS.BASE_GOERLI, 2), NEXERA_EVM_CHAINS.BASE_SEPOLIA, 2), NEXERA_EVM_CHAINS.BNB, 3), NEXERA_EVM_CHAINS.BNB_TESTNET, 3), NEXERA_EVM_CHAINS.MOONBEAM, 12), NEXERA_EVM_CHAINS.MOONRIVER, 12), _defineProperty(_EVM_BLOCK_TIME, NEXERA_EVM_CHAINS.SWISSTRONIK_TESTNET, 4));
+var EVM_CHAINS_WITHOUT_DEDICATED_NODE_RPC = [NEXERA_EVM_CHAINS.MOONBEAM, NEXERA_EVM_CHAINS.MOONRIVER, NEXERA_EVM_CHAINS.AVALANCHE_FUJI, NEXERA_EVM_CHAINS.BASE_SEPOLIA, NEXERA_EVM_CHAINS.BNB_TESTNET, NEXERA_EVM_CHAINS.OPTIMISM_SEPOLIA, NEXERA_EVM_CHAINS.ARBITRUM_SEPOLIA, NEXERA_EVM_CHAINS.SWISSTRONIK_TESTNET];
+var ACTIVE_EVM_CHAIN_VALUES = [NEXERA_EVM_CHAINS.ETHEREUM, NEXERA_EVM_CHAINS.POLYGON, NEXERA_EVM_CHAINS.POLYGON_AMOY, NEXERA_EVM_CHAINS.AVALANCHE, NEXERA_EVM_CHAINS.AVALANCHE_FUJI, NEXERA_EVM_CHAINS.ARBITRUM, NEXERA_EVM_CHAINS.ARBITRUM_SEPOLIA, NEXERA_EVM_CHAINS.SEPOLIA, NEXERA_EVM_CHAINS.BASE, NEXERA_EVM_CHAINS.BASE_SEPOLIA, NEXERA_EVM_CHAINS.BNB,
+// for Bsc
+NEXERA_EVM_CHAINS.BNB_TESTNET, NEXERA_EVM_CHAINS.MOONBEAM, NEXERA_EVM_CHAINS.MOONRIVER, NEXERA_EVM_CHAINS.OPTIMISM, NEXERA_EVM_CHAINS.OPTIMISM_SEPOLIA, NEXERA_EVM_CHAINS.SWISSTRONIK_TESTNET];
+var EvmChainId = zod.z["enum"](ACTIVE_EVM_CHAIN_VALUES).describe("a numeric value that identifies the chain of the address. There are many sites that retrieve information on chainIDs such as <a href='https://chainlist.org/'>https://chainlist.org</a>.");
+
+/////////////////////////////////////////
+//          POLKADOT                   //
+/////////////////////////////////////////
+
+var NEXERA_POLKADOT_CHAINS = /*#__PURE__*/function (NEXERA_POLKADOT_CHAINS) {
+  NEXERA_POLKADOT_CHAINS["POLKADOT_RELAY_CHAIN"] = "polkadot-relay-chain";
+  NEXERA_POLKADOT_CHAINS["KUSAMA_RELAY_CHAIN"] = "kusama-relay-chain";
+  NEXERA_POLKADOT_CHAINS["POLKADOT_TESTNET"] = "polkadot-testnet";
+  return NEXERA_POLKADOT_CHAINS;
+}({});
+var POLKADOT_CHAIN_NAMES = _defineProperty(_defineProperty(_defineProperty({}, NEXERA_POLKADOT_CHAINS.POLKADOT_RELAY_CHAIN, "Polkadot Mainnet"), NEXERA_POLKADOT_CHAINS.KUSAMA_RELAY_CHAIN, "Kusama Testnet"), NEXERA_POLKADOT_CHAINS.POLKADOT_TESTNET, "Polkadot Testnet");
+var POLKADOT_CHAIN_NAMES_LIST = Object.values(POLKADOT_CHAIN_NAMES);
+var POLKADOT_CHAIN_IDS = _defineProperty(_defineProperty(_defineProperty({}, NEXERA_POLKADOT_CHAINS.POLKADOT_RELAY_CHAIN, "polkadot-relay-chain"), NEXERA_POLKADOT_CHAINS.KUSAMA_RELAY_CHAIN, "kusama-relay-chain"), NEXERA_POLKADOT_CHAINS.POLKADOT_TESTNET, "polkadot-testnet");
+var ACTIVE_POLKADOT_CHAIN_IDS = [NEXERA_POLKADOT_CHAINS.POLKADOT_RELAY_CHAIN, NEXERA_POLKADOT_CHAINS.KUSAMA_RELAY_CHAIN, NEXERA_POLKADOT_CHAINS.POLKADOT_TESTNET];
+var PolkadotChainId = zod.z["enum"](ACTIVE_POLKADOT_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+/////////////////////////////////////////
+//          SOLANA                     //
+/////////////////////////////////////////
+
+var NEXERA_SOLANA_CHAINS = /*#__PURE__*/function (NEXERA_SOLANA_CHAINS) {
+  NEXERA_SOLANA_CHAINS["MAINNET"] = "solana-mainnet";
+  NEXERA_SOLANA_CHAINS["TESTNET"] = "solana-testnet";
+  NEXERA_SOLANA_CHAINS["DEVNET"] = "solana-devnet";
+  return NEXERA_SOLANA_CHAINS;
+}({});
+var SOLANA_CHAIN_NAMES = _defineProperty(_defineProperty(_defineProperty({}, NEXERA_SOLANA_CHAINS.MAINNET, "Solana Mainnet"), NEXERA_SOLANA_CHAINS.TESTNET, "Solana Testnet"), NEXERA_SOLANA_CHAINS.DEVNET, "Solana Devnet");
+var SOLANA_CHAIN_NAMES_LIST = Object.values(SOLANA_CHAIN_NAMES);
+var SOLANA_CHAIN_IDS = _defineProperty(_defineProperty(_defineProperty({}, NEXERA_SOLANA_CHAINS.MAINNET, "solana-mainnet"), NEXERA_SOLANA_CHAINS.TESTNET, "solana-testnet"), NEXERA_SOLANA_CHAINS.DEVNET, "solana-devnet");
+var ACTIVE_SOLANA_CHAIN_IDS = [NEXERA_SOLANA_CHAINS.MAINNET, NEXERA_SOLANA_CHAINS.TESTNET, NEXERA_SOLANA_CHAINS.DEVNET];
+var SolanaChainId = zod.z["enum"](ACTIVE_SOLANA_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+/////////////////////////////////////////
+//          STARKNET                   //
+/////////////////////////////////////////
+
+var NEXERA_STARKNET_CHAINS = /*#__PURE__*/function (NEXERA_STARKNET_CHAINS) {
+  NEXERA_STARKNET_CHAINS["STARKNET_MAIN"] = "0x534e5f4d41494e";
+  NEXERA_STARKNET_CHAINS["STARKNET_SEPOLIA"] = "0x534e5f5345504f4c4941";
+  return NEXERA_STARKNET_CHAINS;
+}({});
+var NEXERA_STARKNET_CHAIN_NAMES = {
+  STARKNET_MAIN: "Starknet Mainnet",
+  STARKNET_SEPOLIA: "Starknet Sepolia"
+};
+var NEXERA_STARKNET_CHAIN_IDS = {
+  STARKNET_MAIN: "0x534e5f4d41494e",
+  STARKNET_SEPOLIA: "0x534e5f5345504f4c4941"
+};
+var NEXERA_ACTIVE_STARKNET_CHAIN_IDS = [NEXERA_STARKNET_CHAIN_IDS.STARKNET_MAIN, NEXERA_STARKNET_CHAIN_IDS.STARKNET_SEPOLIA];
+var StarknetChainId = zod.z["enum"](NEXERA_ACTIVE_STARKNET_CHAIN_IDS).describe("a value that identifies the chain of the address.");
+
+var NEXERA_TEZOS_CHAINS = /*#__PURE__*/function (NEXERA_TEZOS_CHAINS) {
+  NEXERA_TEZOS_CHAINS["TEZOS"] = "NetXdQprcVkpaWU";
+  NEXERA_TEZOS_CHAINS["TEZOS_GHOSTNET"] = "NetXnHfVqm9iesp";
+  return NEXERA_TEZOS_CHAINS;
+}({});
+/////////////////////////////////////////
+//          TEZOS                      //
+/////////////////////////////////////////
+
+var NEXERA_TEZOS_CHAIN_NAMES = _defineProperty(_defineProperty({}, NEXERA_TEZOS_CHAINS.TEZOS, "Tezos Mainnet"), NEXERA_TEZOS_CHAINS.TEZOS_GHOSTNET, "Tezos Ghostnet");
+var NEXERA_TEZOS_CHAIN_NAMES_LIST = Object.values(NEXERA_TEZOS_CHAIN_NAMES);
+var NEXERA_TEZOS_CHAIN_IDS = _defineProperty(_defineProperty({}, NEXERA_TEZOS_CHAINS.TEZOS, "NetXdQprcVkpaWU"), NEXERA_TEZOS_CHAINS.TEZOS_GHOSTNET, "NetXnHfVqm9iesp");
+var ACTIVE_TEZOS_CHAIN_IDS = [NEXERA_TEZOS_CHAINS.TEZOS, NEXERA_TEZOS_CHAINS.TEZOS_GHOSTNET];
+var TezosChainId = zod.z["enum"](ACTIVE_TEZOS_CHAIN_IDS).describe("a numeric value that identifies the chain of the address. There are many sites that retrieve information on chainIDs such as <a href='https://chainlist.org/'>https://chainlist.org</a>.");
+
+/////////////////////////////////////////
+//          MERGED                     //
+/////////////////////////////////////////
+
+var BlockchainId = zod.z.union([EvmChainId, TezosChainId, CosmosChainId, StarknetChainId, BitcoinChainId, AptosChainId, PolkadotChainId, SolanaChainId, CardanoChainId]);
+var NonTestnetBlockchainId = zod.z.union([zod.z.literal(NEXERA_EVM_CHAINS.ETHEREUM), zod.z.literal(NEXERA_EVM_CHAINS.POLYGON), zod.z.literal(NEXERA_EVM_CHAINS.AVALANCHE), zod.z.literal(NEXERA_EVM_CHAINS.ARBITRUM), zod.z.literal(NEXERA_EVM_CHAINS.BASE), zod.z.literal(NEXERA_EVM_CHAINS.BNB), zod.z.literal(NEXERA_EVM_CHAINS.OPTIMISM), zod.z.literal(NEXERA_EVM_CHAINS.MOONBEAM), zod.z.literal(NEXERA_EVM_CHAINS.MOONRIVER), zod.z.literal(NEXERA_TEZOS_CHAINS.TEZOS), zod.z.literal(NEXERA_COSMOS_CHAINS.COSMOS), zod.z.literal(NEXERA_STARKNET_CHAINS.STARKNET_MAIN), zod.z.literal(NEXERA_BITCOIN_CHAINS.MAINNET), zod.z.literal(NEXERA_APTOS_CHAINS.MAINNET), zod.z.literal(NEXERA_POLKADOT_CHAINS.POLKADOT_RELAY_CHAIN), zod.z.literal(NEXERA_POLKADOT_CHAINS.KUSAMA_RELAY_CHAIN), zod.z.literal(NEXERA_SOLANA_CHAINS.MAINNET), zod.z.literal(NEXERA_CARDANO_CHAINS.MAINNET)]);
+
+/////////////////////////////////////////
+//          Polygon                      //
+/////////////////////////////////////////
+
+var POLYGON_NETWORK_NAMES = ["main", "amoy"];
+var PolygonNetworkNames = zod.z["enum"](POLYGON_NETWORK_NAMES);
+
+/**
+ * EIP155
+ */
+var String0x = zod.z.string().refine(function (value) {
+  return value.startsWith("0x");
+}, {
+  message: "0x string must start with '0x'"
+}).describe("0x string");
+var HexadecimalSchema = zod.z.string().refine(function (value) {
+  return /^[0-9a-fA-F]+$/.test(value);
+}, {
+  message: "Input must be a hexadecimal string"
+});
+
+/**
+ * EIP155
+ */
+var isValidAddress = function isValidAddress(address) {
+  var regex = /^0x[a-fA-F0-9]{40}$/;
+  return regex.test(address);
+};
+var PrivateKey = String0x;
+var PublicKey = zod.z.string();
+/**
+ * Note: it might be nice to use String0x as the base object instead of z.string(),
+ * but this causes update-api to fail with the following error:
+ * TRPCError: [query.kyc.sumsub.getJourneyData] -
+ * Input parser key: "userAddress" must be ZodString, ZodNumber, ZodBoolean, ZodBigInt or ZodDate
+ */
+var AddressSchema = zod.z.string().refine(function (value) {
+  // Check if the string starts with '0x' and the rest is a valid hexadecimal string
+  return /^0x[0-9A-Fa-f]*$/.test(value);
+}, {
+  message: "Value must be a valid hexadecimal string prefixed with 0x"
+}).transform(function (value) {
+  return value;
+}).describe("String value that identifies the address of a specific user. Normally tied to an EOA that includes the Smart Wallet.");
+var TxHash = zod.z.string().refine(function (value) {
+  // Check if the string starts with '0x' and the rest is a valid hexadecimal string
+  return /^0x[0-9A-Fa-f]*$/.test(value);
+}, {
+  message: "Value must be a valid hexadecimal string prefixed with 0x"
+}).transform(function (value) {
+  return value;
+}).describe("Transaction hash");
+var shortBlockchainAddress = function shortBlockchainAddress(address) {
+  return "".concat(address.substring(0, 6), "...").concat(address.substring(address.length - 4));
+};
+
+/**
+ * Aptos
+ */
+var AptosAddress = String0x;
+/**
+ * Starknet
+ */
+var StarknetAddress = String0x;
+/**
+ * Polkadot
+ */
+var PolkadotAddress = zod.z.string();
+/**
+ * Cosmos
+ */
+var CosmosAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("cosmos");
+}, {
+  message: "Cosmos address must start with 'cosmos'"
+}).transform(function (value) {
+  return value;
+}).describe("Cosmos address");
+/**
+ * Tezos
+ */
+
+var TezosImplicitAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("tz");
+}, {
+  message: "Tezos address (implicit account) must start with 'tz'"
+}).describe("Tezos address (implicit account)");
+var TezosContractAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("KT1");
+}, {
+  message: "Tezos contract address must start with 'KT1'"
+}).describe("Tezos contract address");
+var TezosAddress = zod.z.union([TezosImplicitAddress, TezosContractAddress]);
+/**
+ * Cardano
+ */
+var CardanoAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("addr");
+}, {
+  message: "Cardano address must start with 'addr'"
+}).transform(function (value) {
+  return value;
+}).describe("Cosmos address");
+/**
+ * Bitcoin
+ */
+var BitcoinP2PKHAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("1");
+}, {
+  message: "Bitcoin P2PKH Address must start with '1'"
+}).describe("Bitcoin P2PKH Address");
+var BitcoinP2SHAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("3");
+}, {
+  message: "Bitcoin P2SH Address must start with '3'"
+}).describe("Bitcoin P2SH Address");
+var BitcoinBech32Address = zod.z.string().refine(function (value) {
+  return value.startsWith("bc1");
+}, {
+  message: "Bitcoin Bech32 Address must start with 'bc1'"
+}).describe("Bitcoin Bech32 Address");
+var BitcoinTestnetP2PKHAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("m") || value.startsWith("n");
+}, {
+  message: "Bitcoin Testnet P2PKH Address must start with 'm' or 'n'"
+}).describe("Bitcoin Testnet P2PKH Address");
+var BitcoinTestnetP2SHAddress = zod.z.string().refine(function (value) {
+  return value.startsWith("2");
+}, {
+  message: "Bitcoin Testnet P2SH Address must start with '2'"
+}).describe("Bitcoin Testnet P2SH Address");
+var BitcoinTestnetBech32Address = zod.z.string().refine(function (value) {
+  return value.startsWith("tb1");
+}, {
+  message: "Bitcoin Testnet Bech32 Address must start with 'tb1'"
+}).describe("Bitcoin Testnet Bech32 Address");
+var BitcoinAddress = zod.z.union([BitcoinP2PKHAddress, BitcoinP2SHAddress, BitcoinBech32Address, BitcoinTestnetP2PKHAddress, BitcoinTestnetP2SHAddress, BitcoinTestnetBech32Address]);
+/**
+ * Chain agnostic schemas
+ */
+var BlockchainAddress = zod.z.union([AddressSchema, TezosAddress, AptosAddress, PolkadotAddress, StarknetAddress, CosmosAddress, CardanoAddress, BitcoinAddress]);
+
+var BLOCKCHAIN_NAMESPACES = ["tezos", "eip155", "aptos", "polkadot", "starknet", "cosmos", "solana", "cardano", "bitcoin"];
+var BlockchainNamespace = zod.z["enum"](BLOCKCHAIN_NAMESPACES);
+var SUPPORTED_BLOCKCHAIN_NAMESPACES_FOR_SIGNATURE_AUTH = ["tezos", "eip155", "aptos", "polkadot", "starknet", "cosmos", "solana", "cardano"];
+var SupportedBlockchainNamespaceForSignatureAuth = zod.z["enum"](SUPPORTED_BLOCKCHAIN_NAMESPACES_FOR_SIGNATURE_AUTH);
+// Nicer names
+var BLOCKCHAIN_NAMESPACES_NAMES = {
+  tezos: "Tezos",
+  eip155: "EVM",
+  aptos: "Aptos",
+  polkadot: "Polkadot",
+  starknet: "Starknet",
+  cosmos: "Cosmos",
+  solana: "Solana",
+  cardano: "Cardano",
+  bitcoin: "Bitcoin"
+};
+var DISPLAYED_BLOCKCHAIN_NAMESPACES = ["Tezos", "EVM", "Aptos", "Polkadot", "Starknet", "Cosmos", "Solana", "Cardano", "Bitcoin"];
+var DisplayedBlockchainNamespace = zod.z["enum"](DISPLAYED_BLOCKCHAIN_NAMESPACES);
+var BLOCKCHAIN_NAME_TO_NAMESPACE = {
+  Tezos: "tezos",
+  EVM: "eip155",
+  Aptos: "aptos",
+  Polkadot: "polkadot",
+  Starknet: "starknet",
+  Cosmos: "cosmos",
+  Solana: "solana",
+  Cardano: "cardano",
+  Bitcoin: "bitcoin"
+};
+var BLOCKCHAIN_NAMESPACE_TO_NAME = {
+  tezos: "Tezos",
+  eip155: "EVM",
+  aptos: "Aptos",
+  polkadot: "Polkadot",
+  starknet: "Starknet",
+  cosmos: "Cosmos",
+  solana: "Solana",
+  cardano: "Cardano",
+  bitcoin: "Bitcoin"
+};
+
+/**
+ * EIP155
+ */
+
+var EIP155Signature = String0x;
+/**
+ * Aptos
+ */
+var AptosSignature = zod.z.string();
+/**
+ * Starknet
+ */
+
+var StarknetSignature = String0x;
+/**
+ * Polkadot
+ */
+
+var PolkadotSignature = String0x;
+/**
+ * Cosmos
+ */
+
+var CosmosSignature = HexadecimalSchema;
+/**
+ * Tezos
+ */
+
+var EdSignature = zod.z.string().refine(function (value) {
+  return value.startsWith("edsig");
+}, {
+  message: "EdSignature must start with 'edsig'"
+});
+var SpSignature = zod.z.string().refine(function (value) {
+  return value.startsWith("spsig");
+}, {
+  message: "SpSignature must start with 'spsig'"
+});
+var P2Signature = zod.z.string().refine(function (value) {
+  return value.startsWith("p2sig");
+}, {
+  message: "P2Signature must start with 'p2sig'"
+});
+var TezosSignature = zod.z.union([EdSignature, SpSignature, P2Signature]);
+/**
+ * Cardano
+ */
+
+var CardanoSignature = HexadecimalSchema;
+/**
+ * Chain agnostic schemas
+ */
+
+var BlockchainSignature = zod.z.union([EIP155Signature, TezosSignature, AptosSignature, PolkadotSignature, StarknetSignature, CosmosSignature, CardanoSignature]);
+
+/**
+ * EIP155
+ */
+
+var FunctionCallData = String0x;
+/**
+ * Tezos
+ */
+
+var TezosEntrypointName = zod.z.string().refine(function (value) {
+  return value.startsWith("%");
+}, {
+  message: "Tezos entrypoint name must start with '%'"
+}).describe("Tezos entrypoint name");
+
+var ENVS = ["cicd", "local", "test-dev-1", "test-dev-2", "test-dev-3", "dev", "stage", "prod"];
+var EnvironmentSchema = zod.z["enum"](ENVS);
+var UuidString = zod.z.string().uuid();
+var OtpCode = zod.z.string().regex(/^\d{6}$/, "OtpCode must be a 6-digit number");
+/**
+ * All public services
+ */
+var PUBLIC_SERVICES_SCHEMA_MAP = {
+  api: {
+    cicd: "http://localhost:3001",
+    local: "http://localhost:3001",
+    "test-dev-1": "https://api-test-dev-1.bjrcom.xyz",
+    "test-dev-2": "https://api-test-dev-2.bjrcom.xyz",
+    "test-dev-3": "https://api-test-dev-3.bjrcom.xyz",
+    dev: "https://api.bjrcom.xyz",
+    stage: "https://api.bjrpilot.xyz",
+    prod: "https://api.compilot.ai"
+  },
+  identity_api: {
+    cicd: "http://localhost:3015",
+    local: "http://localhost:3015",
+    "test-dev-1": "https://identity-api-test-dev-1.bjrcom.xyz",
+    "test-dev-2": "https://identity-api-test-dev-2.bjrcom.xyz",
+    "test-dev-3": "https://identity-api-test-dev-3.bjrcom.xyz",
+    dev: "https://identity-api.bjrcom.xyz",
+    stage: "https://identity-api.bjrpilot.xyz",
+    prod: "https://identity-api.compilot.ai"
+  },
+  identityV2: {
+    cicd: "http://localhost:3009",
+    local: "http://localhost:3009",
+    "test-dev-1": "https://identity-v2-test-dev-1.bjrcom.xyz",
+    "test-dev-2": "https://identity-v2-test-dev-2.bjrcom.xyz",
+    "test-dev-3": "https://identity-v2-test-dev-3.bjrcom.xyz",
+    dev: "https://identity-v2.bjrcom.xyz",
+    stage: "https://identity-v2.bjrpilot.xyz",
+    prod: "https://identity-v2.compilot.ai"
+  }
+};
+var IpAddress = zod.z.string().optional().refine(function (val) {
+  return val === undefined || zod.z.string().ip().safeParse(val).success;
+}, {
+  message: "Invalid IP address"
+});
+
+var CredentialSchemas = {
+  ProofOfResidence: vault_schema.ProofOfResidenceCredentialSubjectSchema,
+  SelfieImage: vault_schema.SelfieImageCredentialSubjectSchema,
+  IDImage: vault_schema.IDImageCredentialSubjectSchema,
+  IDInformation: vault_schema.IDInformationCredentialSubjectSchema,
+  AMLScreeningsResults: vault_schema.OLD_AMLScreeningsResultsCredentialSubjectSchema,
+  ID3: vault_schema.ID3CredentialSubjectSchema,
+  IDScan: vault_schema.IDScanCredentialSubjectSchema,
+  IDScanSelfie: vault_schema.IDScanSelfieCredentialSubjectSchema,
+  IDScanPassport: vault_schema.IDScanPassportCredentialSubjectSchema
+};
+var CredentialNames = [{
+  value: "AMLScreeningsResults",
+  label: "AML screening results"
+}, {
+  value: "ProofOfResidence",
+  label: "Proof of residence"
+}, {
+  value: "SelfieImage",
+  label: "Selfie image"
+}, {
+  value: "IDImage",
+  label: "ID image"
+}, {
+  value: "IDInformation",
+  label: "ID information"
+}];
+var CredentialTypes = ["AMLScreeningsResults", "ProofOfResidence", "SelfieImage", "IDImage", "IDInformation", "ID3",
+// this is for backwards compatibility
+"IDScan",
+// this is for backwards compatibility
+"IDScanSelfie",
+// this is for backwards compatibility
+"IDScanPassport" // this is for backwards compatibility
+];
+var NexeraCredentialType = zod.z["enum"](CredentialTypes);
+var getCredentialName = function getCredentialName(value) {
+  var _CredentialNames$find;
+  return (_CredentialNames$find = CredentialNames.find(function (obj) {
+    return obj.value === value;
+  })) === null || _CredentialNames$find === void 0 ? void 0 : _CredentialNames$find.label;
+};
+var CredentialType = zod.z.string().transform(function (x) {
+  return x.replace("_", "-");
+}) // TODO determine why this is needed
+.pipe(zod.z["enum"](CredentialTypes));
+// Should this be replaced by GenericVerifiableCredentialSchema?
+
+var VerifiableCredential = zod.z.object({
+  issuer: zod.z.string(),
+  type: zod.z.array(zod.z.union([zod.z.string(), CredentialType])),
+  credentialSubject: zod.z.record(zod.z.unknown())
+}).catchall(zod.z.any());
+var CredentialMediaType = vault_schema.IDImageCredentialSubjectSchema.shape.mediaType_front;
+
+// Request
+
+var MediaType = /*#__PURE__*/function (MediaType) {
+  MediaType["ZKPMessage"] = "application/iden3-zkp-json";
+  MediaType["PlainMessage"] = "application/iden3comm-plain-json";
+  MediaType["SignedMessage"] = "application/iden3comm-signed-json";
+  return MediaType;
+}({});
+var MediaTypePID = zod.z.nativeEnum(MediaType);
+var CIRCUIT_IDS = ["authV2", "stateTransition", "credentialAtomicQueryMTPV2", "credentialAtomicQueryMTPV2OnChain", "credentialAtomicQuerySigV2", "credentialAtomicQuerySigV2OnChain", "credentialAtomicQueryV3-beta.1", "credentialAtomicQueryV3OnChain-beta.1", "linkedMultiQuery10-beta.1"];
+var CircuitId = zod.z["enum"](CIRCUIT_IDS);
+var ZeroKnowledgeProofRequest = zod.z.object({
+  id: zod.z.number(),
+  circuitId: zod.z.string(),
+  optional: zod.z["boolean"]().optional(),
+  query: zod.z.record(zod.z.string(), zod.z.any())
+});
+var AUTHORIZATION_REQUEST_MESSAGE_TYPES = {
+  AUTHORIZATION_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/authorization/1.0/request",
+  AUTHORIZATION_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/authorization/1.0/response",
+  CREDENTIAL_ISSUANCE_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/issuance-request",
+  CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/fetch-request",
+  CREDENTIAL_OFFER_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/offer",
+  CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/issuance-response",
+  CREDENTIAL_REFRESH_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/refresh",
+  DEVICE_REGISTRATION_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/devices/1.0/registration",
+  MESSAGE_FETCH_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/messages/1.0/fetch",
+  PROOF_GENERATION_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/proofs/1.0/request",
+  PROOF_GENERATION_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/proofs/1.0/response",
+  REVOCATION_STATUS_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/revocation/1.0/request-status",
+  REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/revocation/1.0/status",
+  CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/proofs/1.0/contract-invoke-request",
+  CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/proofs/1.0/contract-invoke-response",
+  CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/onchain-offer",
+  PROPOSAL_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/proposal-request",
+  PROPOSAL_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/proposal",
+  PAYMENT_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/payment-request",
+  PAYMENT_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/payment"
+};
+var AuthorizationRequestMessageTypes = ["https://iden3-communication.io/authorization/1.0/request", "https://iden3-communication.io/authorization/1.0/response", "https://iden3-communication.io/credentials/1.0/issuance-request", "https://iden3-communication.io/credentials/1.0/fetch-request", "https://iden3-communication.io/credentials/1.0/offer", "https://iden3-communication.io/credentials/1.0/issuance-response", "https://iden3-communication.io/credentials/1.0/refresh", "https://iden3-communication.io/devices/1.0/registration", "https://iden3-communication.io/messages/1.0/fetch", "https://iden3-communication.io/proofs/1.0/request", "https://iden3-communication.io/proofs/1.0/response", "https://iden3-communication.io/revocation/1.0/request-status", "https://iden3-communication.io/revocation/1.0/status", "https://iden3-communication.io/proofs/1.0/contract-invoke-request", "https://iden3-communication.io/proofs/1.0/contract-invoke-response", "https://iden3-communication.io/credentials/1.0/onchain-offer", "https://iden3-communication.io/credentials/0.1/proposal-request", "https://iden3-communication.io/credentials/0.1/proposal", "https://iden3-communication.io/credentials/0.1/payment-request", "https://iden3-communication.io/credentials/0.1/payment"];
+var AuthorizationRequestMessageType = zod.z["enum"](AuthorizationRequestMessageTypes);
+var AuthorizationRequestMessage = zod.z.object({
+  id: zod.z.string(),
+  typ: MediaTypePID.optional(),
+  type: AuthorizationRequestMessageType,
+  thid: zod.z.string().optional(),
+  body: zod.z.object({
+    callbackUrl: zod.z.string(),
+    reason: zod.z.string().optional(),
+    did_doc: zod.z.any().optional(),
+    message: zod.z.string().optional(),
+    scope: zod.z.array(ZeroKnowledgeProofRequest)
+  }),
+  from: zod.z.string(),
+  to: zod.z.string().optional()
+});
+// Response
+var ProofData = zod.z.object({
+  pi_a: zod.z.array(zod.z.string()),
+  pi_b: zod.z.array(zod.z.array(zod.z.string())),
+  pi_c: zod.z.array(zod.z.string()),
+  protocol: zod.z.string(),
+  curve: zod.z.string().optional()
+});
+var ZeroKnowledgeProofResponse = zod.z.object({
+  id: zod.z.number(),
+  circuitId: zod.z.string(),
+  vp: zod.z.any().optional(),
+  proof: ProofData,
+  pub_signals: zod.z.array(zod.z.string())
+});
+var AuthorizationResponseMessage = zod.z.object({
+  id: zod.z.string(),
+  typ: MediaTypePID.optional(),
+  type: zod.z.string(),
+  thid: zod.z.string().optional(),
+  body: zod.z.object({
+    did_doc: zod.z.any().optional(),
+    message: zod.z.string().optional(),
+    scope: zod.z.array(ZeroKnowledgeProofResponse)
+  }),
+  from: zod.z.string().optional(),
+  to: zod.z.string().optional()
+});
+// Polygon Wallet
+var CredentialQrCodeData = zod.z.object({
+  id: zod.z.string(),
+  typ: zod.z.string(),
+  type: zod.z.string(),
+  thid: zod.z.string(),
+  body: zod.z.object({
+    url: zod.z.string(),
+    credentials: zod.z.unknown()
+  }),
+  from: zod.z.string(),
+  to: zod.z.string()
+});
+var AuthQrCodeData = zod.z.object({
+  id: zod.z.string(),
+  typ: zod.z.string(),
+  type: zod.z.string(),
+  thid: zod.z.string(),
+  body: zod.z.object({
+    callbackUrl: zod.z.string(),
+    reason: zod.z.string(),
+    scope: zod.z.unknown()
+  }),
+  from: zod.z.string()
+});
+var QrCodeLinkWithSchemaType = zod.z.object({
+  qrCodeLink: zod.z.string().nullish(),
+  schemaType: zod.z.string().nullish()
+}).describe("Polygon ID Verifiable Credential Offer, to be consumed by the Polygon ID Wallet");
+function parseIden3Message(input) {
+  var prefix = "request_uri=";
+  var startIndex = input.indexOf(prefix);
+  if (startIndex === -1) {
+    throw new Error("Wrong request - request doesn't start with request_uri=");
+  }
+  return zod.z.string().url().parse(input.substring(startIndex + prefix.length));
+}
+function parseSessionIdFromUrl(urlString) {
+  var url = new URL(urlString);
+  var params = new URLSearchParams(url.search);
+  var sessionId = params.get("sessionID");
+  if (!sessionId) {
+    throw new Error("No Session Id found in callback url");
+  }
+  return sessionId;
+}
+
+var StoragePrefix = "storage";
+var IdentityPrefix = "identity";
+var EmailPrefix = "email";
+var WalletPrefix = "wallet";
+var AppPrefix = "app";
+var ChallengePrefix = "challenge";
+var TestPrefix = "test";
+var CustomerScreeningPrefix = "cstscr";
+var TagPrefix = "tag";
+
+// TMS
+var TagsToTransactionReviewsPrefix = "ttxr";
+var TransactionAddressesPrefix = "txa";
+var TransactionPrefix = "tx";
+var TransactionFeesPrefix = "txf";
+var TransactionReviewPrefix = "txrev";
+var TransactionPartiesPrefix = "txpar";
+var TransactionInfosPrefix = "txi";
+var TransactionExtractedInfosPrefix = "txei";
+var TransactionMethodsPrefix = "txm";
+var TransactionMethodExtractedInfosPrefix = "txmei";
+var InstitutionPrefix = "ins";
+var InstitutionExtractedInfosPrefix = "insei";
+var TransactionAmountPrefix = "txam";
+
+// Add these lines near the top of the file with other prefix definitions
+var ScenarioPrefix = "scenario";
+var ListPrefix = "list";
+var QueryPrefix = "query";
+var ActionPrefix = "action";
+
+// workflows-api
+var WorkflowSessionAttributePrefix = "wsatr";
+
+// ---
+
+// Add these lines in the type definitions section
+
+// TMS
+
+// workflows-api
+
+// ---
+
+// TMS
+
+// Scenarios service
+
+// Workflows-API
+
+var createBrandedSchemaId = function createBrandedSchemaId(brand) {
+  return zod.z.custom(function (val) {
+    if (typeof val !== "string") return false;
+    return val.startsWith(brand);
+  }, {
+    message: "Invalid ".concat(brand, " id")
+  });
+};
+
+// ---
+
+var StorageId = createBrandedSchemaId("".concat(StoragePrefix, "_"));
+var IdentityId = createBrandedSchemaId("".concat(IdentityPrefix, "_"));
+var EmailId = createBrandedSchemaId("".concat(EmailPrefix, "_"));
+var WalletId = createBrandedSchemaId("".concat(WalletPrefix, "_"));
+var AppId = createBrandedSchemaId("".concat(AppPrefix, "_"));
+var ChallengeId = createBrandedSchemaId("".concat(ChallengePrefix, "_"));
+var TestId = createBrandedSchemaId("".concat(TestPrefix, "_"));
+var CustomerScreeningId = createBrandedSchemaId("".concat(CustomerScreeningPrefix, "_"));
+var TagId = createBrandedSchemaId("".concat(TagPrefix, "_"));
+var ActionId = createBrandedSchemaId("".concat(ActionPrefix, "_"));
+
+// TMS
+var TagsToTransactionReviewsId = createBrandedSchemaId("".concat(TagsToTransactionReviewsPrefix, "_"));
+var TransactionAddressesId = createBrandedSchemaId("".concat(TransactionAddressesPrefix, "_"));
+var TransactionId = createBrandedSchemaId("".concat(TransactionPrefix, "_"));
+var TransactionFeesId = createBrandedSchemaId("".concat(TransactionFeesPrefix, "_"));
+var TransactionReviewId = createBrandedSchemaId("".concat(TransactionReviewPrefix, "_"));
+var TransactionPartiesId = createBrandedSchemaId("".concat(TransactionPartiesPrefix, "_"));
+var TransactionInfosId = createBrandedSchemaId("".concat(TransactionInfosPrefix, "_"));
+var TransactionExtractedInfosId = createBrandedSchemaId("".concat(TransactionExtractedInfosPrefix, "_"));
+var TransactionMethodsId = createBrandedSchemaId("".concat(TransactionMethodsPrefix, "_"));
+var TransactionMethodExtractedInfosId = createBrandedSchemaId("".concat(TransactionMethodExtractedInfosPrefix, "_"));
+var InstitutionId = createBrandedSchemaId("".concat(InstitutionPrefix, "_"));
+var InstitutionExtractedInfosId = createBrandedSchemaId("".concat(InstitutionExtractedInfosPrefix, "_"));
+var TransactionAmountId = createBrandedSchemaId("".concat(TransactionAmountPrefix, "_"));
+var ScenarioId = createBrandedSchemaId("".concat(ScenarioPrefix, "_"));
+var ListId = createBrandedSchemaId("".concat(ListPrefix, "_"));
+var QueryId = createBrandedSchemaId("".concat(QueryPrefix, "_"));
+
+// Workflows api
+var WorkflowSessionId = UuidString;
+var WorkflowSessionAttributeId = createBrandedSchemaId("".concat(WorkflowSessionAttributePrefix, "_"));
+var generateId = function generateId(type) {
+  return "".concat(type, "_").concat(nanoid.nanoid(12));
+};
+var MemberId = zod.z.string();
+
+var QUERY_LOGIC_OPERATOR = ["AND", "OR"];
+var QueryLogicOperator = zod.z["enum"](QUERY_LOGIC_OPERATOR);
+var OPERATORS = ["$noop",
+// noop can be used in zkps as proof of credential issuance https://docs.privado.id/docs/verifier/verification-library/zk-query-language#exists---operator-11
+"$eq",
+// equal to
+"$lt",
+// less than
+"$lte",
+// less than or equal to
+"$gt",
+// greater than
+"$gte",
+// greater than or equal to
+"$in",
+// in
+"$nin",
+// not in
+"$ne",
+// not equal to
+//"$between", // between
+//"$nonbetween", // contains
+"$exists" // exists
+];
+var Operator = zod.z["enum"](OPERATORS);
+var ZKPOperator = zod.z["enum"](OPERATORS).exclude(["$lte", "$gte"]);
+var operatorDisplayMap = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, Operator["enum"].$eq, "="), Operator["enum"].$gt, ">"), Operator["enum"].$lt, "<"), Operator["enum"].$gte, ">="), Operator["enum"].$lte, "<="), Operator["enum"].$ne, "!="), Operator["enum"].$in, "in"), Operator["enum"].$nin, "not in"), Operator["enum"].$noop, "noop"), Operator["enum"].$exists, "exists");
+var ARRAY_OPERATORS = [Operator["enum"].$in, Operator["enum"].$nin, Operator["enum"].$eq, Operator["enum"].$ne
+//Operator.enum.$between,
+//Operator.enum.$nonbetween,
+];
+var ArrayOperator = zod.z["enum"](ARRAY_OPERATORS);
+var STRING_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne, Operator["enum"].$in, Operator["enum"].$nin, Operator["enum"].$exists];
+var StringOperator = zod.z["enum"](STRING_OPERATORS);
+var NUMERIC_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne, Operator["enum"].$gt, Operator["enum"].$gte, Operator["enum"].$lt, Operator["enum"].$lte
+//Operator.enum.$between,
+//Operator.enum.$nonbetween,
+];
+var NumericOperator = zod.z["enum"](NUMERIC_OPERATORS);
+var BOOLEAN_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne];
+var BooleanOperator = zod.z["enum"](BOOLEAN_OPERATORS);
+var DATE_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne, Operator["enum"].$gt, Operator["enum"].$gte, Operator["enum"].$lt, Operator["enum"].$lte
+//Operator.enum.$between,
+//Operator.enum.$nonbetween,
+];
+var DateOperator = zod.z["enum"](DATE_OPERATORS);
+var SUPPORTED_TYPES = ["string", "integer", "boolean", "number", "array", "date"];
+var SupportedType = zod.z["enum"](SUPPORTED_TYPES);
+var SupportedTypes = zod.z.object(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, SupportedType["enum"].string, StringOperator), SupportedType["enum"].integer, NumericOperator), SupportedType["enum"]["boolean"], BooleanOperator), SupportedType["enum"].number, NumericOperator), SupportedType["enum"].array, ArrayOperator), SupportedType["enum"].date, DateOperator));
+var AllCredentialValues = zod.z.union([zod.z["boolean"](), zod.z.string(), zod.z.number(), zod.z.array(zod.z.string()), zod.z.array(zod.z.number())]);
+var QueryConfigSimplified = zod.z.object({
+  queryId: QueryId.describe("Unique ID for the query").optional(),
+  // TODO: this should not be optional?
+  requestId: zod.z.coerce.number().nullish().describe("Request ID for ZKPs"),
+  attribute: vault_schema.VaultMetadataLinkZodSchema,
+  value: AllCredentialValues.nullish(),
+  // TODO: Make the value type dynamic based on the attribute type
+  operator: Operator // TODO: Make the operator type dynamic based on the attribute type
+});
+var PartialQueryConfigSimplified = QueryConfigSimplified.partial();
+var OLD_ChallengeQuerySchema = zod.z.object({
+  id: zod.z.string().optional(),
+  query: QueryConfigSimplified
+});
+var OLD_CHALLENGE_QUERY_OPERATORS = ["GREATER_THAN", "LESS_THAN", "EQUAL_TO", "NOT_EQUAL_TO", "LESS_THAN_OR_EQUAL_TO", "GREATER_THAN_OR_EQUAL_TO", "IN", "NOT_IN",
+//"BETWEEN",
+//"NOT_BETWEEN",
+"EXISTS"];
+var OLD_ChallengeQueryOperator = zod.z["enum"](OLD_CHALLENGE_QUERY_OPERATORS);
+var OperatorMappings = {
+  toChallenge: _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, Operator["enum"].$noop, OLD_ChallengeQueryOperator["enum"].EQUAL_TO), Operator["enum"].$eq, OLD_ChallengeQueryOperator["enum"].EQUAL_TO), Operator["enum"].$lt, OLD_ChallengeQueryOperator["enum"].LESS_THAN), Operator["enum"].$lte, OLD_ChallengeQueryOperator["enum"].LESS_THAN_OR_EQUAL_TO), Operator["enum"].$gt, OLD_ChallengeQueryOperator["enum"].GREATER_THAN), Operator["enum"].$gte, OLD_ChallengeQueryOperator["enum"].GREATER_THAN_OR_EQUAL_TO), Operator["enum"].$in, OLD_ChallengeQueryOperator["enum"].IN), Operator["enum"].$nin, OLD_ChallengeQueryOperator["enum"].NOT_IN), Operator["enum"].$ne, OLD_ChallengeQueryOperator["enum"].NOT_EQUAL_TO), Operator["enum"].$exists, OLD_ChallengeQueryOperator["enum"].EXISTS),
+  fromChallenge: _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, OLD_ChallengeQueryOperator["enum"].EQUAL_TO, Operator["enum"].$eq), OLD_ChallengeQueryOperator["enum"].LESS_THAN, Operator["enum"].$lt), OLD_ChallengeQueryOperator["enum"].LESS_THAN_OR_EQUAL_TO, Operator["enum"].$lte), OLD_ChallengeQueryOperator["enum"].GREATER_THAN, Operator["enum"].$gt), OLD_ChallengeQueryOperator["enum"].GREATER_THAN_OR_EQUAL_TO, Operator["enum"].$gte), OLD_ChallengeQueryOperator["enum"].IN, Operator["enum"].$in), OLD_ChallengeQueryOperator["enum"].NOT_IN, Operator["enum"].$nin), OLD_ChallengeQueryOperator["enum"].NOT_EQUAL_TO, Operator["enum"].$ne), OLD_ChallengeQueryOperator["enum"].EXISTS, Operator["enum"].$exists)
+};
+var OperatorToOLD_ChallengeQueryOperator = OperatorMappings.toChallenge;
+var OLD_ChallengeQueryOperatorToOperator = OperatorMappings.fromChallenge;
+
+// FIXME: Remove this once we migrate to the vault metadata
+var OLD_QueryCredentialTypes = ["IDInformation", "IDImage", "SelfieImage", "ProofOfResidence", "AMLScreeningsResults", "ID3", "IDScan", "IDScanSelfie", "IDScanPassport"];
+var OLD_QueryCredentialType = zod.z["enum"](OLD_QueryCredentialTypes);
+/**
+ * @deprecated Use vault client and services instead
+ *
+ * FIXME: Have a better way to determine which credentials are required, centralize this logic if possible
+ *        and with a way that doesn't require looking into the link
+ *
+ * @param dataLink
+ * @returns
+ */
+function getOldCredentialType(dataLink) {
+  if (dataLink.path.includes("/vcs/")) {
+    var _dataLink$path$split$;
+    return (_dataLink$path$split$ = dataLink.path.split("/vcs/")[1]) === null || _dataLink$path$split$ === void 0 ? void 0 : _dataLink$path$split$.split("/")[0];
+  }
+  var mapping = {
+    "Customer/identityData/age": "IDInformation",
+    "Customer/identityData/nationality": "IDInformation",
+    "Customer/identityData/residence": "ProofOfResidence",
+    "Customer/kycStatus/selfieCheckStatus": "SelfieImage",
+    "Customer/kycStatus/idImageCheckStatus": "IDImage",
+    "Customer/kycStatus/idInformationCheckStatus": "IDInformation",
+    "Customer/kycStatus/proofOfResidenceCheckStatus": "ProofOfResidence"
+  };
+  if (dataLink.path in mapping) {
+    return mapping[dataLink.path];
+  }
+  return undefined;
+}
+
+/**
+ * @deprecated Use vault client and services instead
+ *
+ * @param dataLink
+ * @returns
+ */
+function getOldCredentialPath(dataLink) {
+  if (dataLink.path.includes("credentialSubject")) {
+    var _dataLink$path$split$2;
+    var path = (_dataLink$path$split$2 = dataLink.path.split("credentialSubject")[1]) !== null && _dataLink$path$split$2 !== void 0 ? _dataLink$path$split$2 : "";
+    path = path.startsWith("/") ? path.slice(1) : path;
+    path = path.replaceAll("/", ".");
+    return path;
+  }
+  var mapping = {
+    "Customer/identityData/age": "personalData.age",
+    "Customer/identityData/nationality": "personalData.nationality",
+    "Customer/identityData/residence": "personalData.residence"
+  };
+  if (dataLink.path in mapping) {
+    return mapping[dataLink.path];
+  }
+  return dataLink.path;
+}
+
+/**
+ * @deprecated Use vault client and services instead
+ */
+function oldCredentialPathToDataLink(path, credentialType) {
+  return {
+    version: "v1",
+    schema: "KycSession",
+    // all old paths are for customer credentials
+    path: "KycSession/vcs/".concat(credentialType, "/v1/credentialSubject/").concat(path.replaceAll(".", "/"))
+  };
+}
+
+var FLOW_TYPES = ["web2", "web3"];
+var FlowType = zod.z["enum"](FLOW_TYPES).describe("The flow type of the user");
+var VerificationModes = ["full_verification", "sandbox"];
+var VerificationMode = zod.z["enum"](VerificationModes).describe("The verification mode of the project");
+var IDENTITY_DOCUMENT_COUNTRY_LIST_OPTIONS = ["allowedCountryIdentityDocuments", "excludedCountryIdentityDocuments"];
+var IdentityDocumentCountryListOption = zod.z["enum"](IDENTITY_DOCUMENT_COUNTRY_LIST_OPTIONS);
+var IDENTITY_DOCUMENT_OPTIONS = ["PASSPORT", "ID_CARD", "DRIVING_LICENSE"];
+var IdentityDocumentOptionsType = zod.z["enum"](IDENTITY_DOCUMENT_OPTIONS);
+var PERSONAL_INFORMATION_FIELDS = ["EMAIL", "PHONE", "TWITTER", "DISCORD", "TELEGRAM"];
+var PersonalInformationFieldsIdentityDocuments = zod.z["enum"](PERSONAL_INFORMATION_FIELDS);
+var Identifier = zod.z.union([zod.z.literal("verification"), zod.z.literal("management")]);
+
+/**
+ * Represents the additional data that can be attached to a customer
+ */
+
+var AdditionalCustomerInformationParams = zod.z.object({
+  email: zod.z.string().email().optional(),
+  phone: zod.z.string().min(4).optional(),
+  wallet: zod.z.object({
+    address: BlockchainAddress,
+    namespace: BlockchainNamespace
+  }).optional()
+});
+var OrganizationId = zod.z.string();
+var WorkspaceId = zod.z.string();
+var WorkflowId = UuidString;
+var CustomerId = UuidString;
+var IdentityWidgetAccessToken = zod.z.object({
+  sub: BlockchainAddress,
+  blockchainNamespace: BlockchainNamespace,
+  exp: zod.z.number(),
+  projectId: zod.z.string(),
+  organizationId: OrganizationId,
+  customerId: UuidString,
+  workspaceId: WorkspaceId,
+  // cmsProjectId
+  workflowId: WorkflowId.optional(),
+  ipAddress: zod.z.string().optional(),
+  timestamp: zod.z.number(),
+  storeSharedVC: zod.z["boolean"]().nullish(),
+  verificationMode: VerificationMode,
+  hosts: zod.z.array(zod.z.string())
+});
+
+// represents an id of a consumer in the external system of our client
+// as it's an external id, it can be any string
+var ExternalCustomerId = zod.z.string();
+var IdentityAppV2BaseJWT = zod.z.object({
+  sub: IdentityId,
+  // @todo: this is named "flow type" here, but it's named "protocol" in the dashboard selection
+  flowType: zod.z.union([zod.z.literal(FlowType.Values.web3), zod.z.literal(FlowType.Values.web2)]),
+  exp: zod.z.number(),
+  customerId: UuidString,
+  verificationMode: VerificationMode,
+  organizationId: OrganizationId,
+  workspaceId: WorkspaceId,
+  workflowId: WorkflowId,
+  ipAddress: zod.z.string().optional(),
+  timestamp: zod.z.number(),
+  iat: zod.z.number(),
+  hosts: zod.z.array(zod.z.string())
+});
+var IdentityAppV2Web3JWT = IdentityAppV2BaseJWT.extend({
+  flowType: zod.z.literal(FlowType.Values.web3),
+  blockchainAddress: BlockchainAddress,
+  blockchainNamespace: BlockchainNamespace
+});
+var IdentityAppV2Web2JWT = IdentityAppV2BaseJWT.extend({
+  flowType: zod.z.literal(FlowType.Values.web2),
+  /**
+   * @deprecated Fetch the additional user information from the services instead of relying on this field
+   * We only have this field in web2 mode because most of the services are relying on the blockchain address to be present in the JWT
+   */
+  deprecated_additionalUserInformation: AdditionalCustomerInformationParams.optional()
+});
+var IdentityWidgetAccessToken_NEW = zod.z.union([IdentityAppV2Web3JWT, IdentityAppV2Web2JWT]);
+var IdentityWidgetSessionToken = zod.z.union([IdentityWidgetAccessToken, IdentityWidgetAccessToken_NEW]);
+
+/**
+ * The parameters required to create a new configuration in web2 mode.
+ */
+
+var Web2CreateSessionParams = zod.z.object({
+  workflowId: WorkflowId,
+  // required in web2 because we don't have the wallet address
+  externalCustomerId: ExternalCustomerId,
+  additionalInformation: AdditionalCustomerInformationParams.optional()
+});
+
+var ScenarioTypes = ["PrivacyPreservingMonitoring", "IndividualMonitoring", "TransactionMonitoring"];
+var ScenarioType = zod.z["enum"](ScenarioTypes);
+var BaseQueryResponse = zod.z.object({
+  result: zod.z.object({
+    is_valid: zod.z["boolean"](),
+    reasons: zod.z.array(zod.z.string())
+  })
+});
+var OffChainZKPRuleResult = BaseQueryResponse.extend({
+  result: zod.z.object({
+    is_valid: zod.z["boolean"](),
+    query: QueryConfigSimplified,
+    reasons: zod.z.array(zod.z.string())
+  })
+});
+var ExecuteQueryResponse = BaseQueryResponse.extend({
+  executionId: UuidString
+});
+var RuleEngineResponse = zod.z.object({
+  objectType: ScenarioType,
+  objectId: zod.z.string().describe("Object id in the cms (challengeQueryid, offChainZKPid)"),
+  name: zod.z.string(),
+  address: BlockchainAddress.nullish(),
+  result: ExecuteQueryResponse,
+  executionId: UuidString,
+  scenarioId: zod.z.string()
+});
+var ScenarioExecutionResponse = zod.z.array(RuleEngineResponse);
+var RuleResultStatuses = ["valid", "not-valid", "error", "unknown"];
+var RuleResultStatus = zod.z["enum"](RuleResultStatuses);
+var RuleResultStatusLabels = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, RuleResultStatus.Enum.valid, "Valid"), RuleResultStatus.Enum["not-valid"], "Not Valid"), RuleResultStatus.Enum.error, "Error"), RuleResultStatus.Enum.unknown, "Unknown");
+var SdkVerificationOutput = zod.z.object({
+  customerId: zod.z.string().optional(),
+  // for v1
+  scenarioExecutionId: zod.z.string().optional(),
+  // for v1
+  status: RuleResultStatus.optional(),
+  // for v1
+  results: zod.z.array(ScenarioExecutionResponse).optional() // for v1,
+});
+var VerificationSessionStatuses = ["IN_PROGRESS", "COMPLETED", "NOT_STARTED"];
+var VerificationSessionStatus = zod.z["enum"](VerificationSessionStatuses);
+var VerificationOutput = zod.z.object({
+  id: UuidString.nullable(),
+  verificationResult: SdkVerificationOutput.nullable(),
+  status: VerificationSessionStatus
+});
+var Scenario = zod.z.object({
+  id: ScenarioId,
+  name: zod.z.string(),
+  description: zod.z.string().nullish(),
+  queries: zod.z.array(QueryConfigSimplified),
+  type: ScenarioType,
+  workspaceId: WorkspaceId,
+  vcsIncluded: zod.z.array(CredentialType).nullish()
+});
+
+// creating this because SmartContractDeployment has an issue with AddressSchema
+// during rpcPublisher.send
+// also the parsing of the queryconfiguration fields changes type slightly as well.
+var AbbreviatedWorkflowScenario = Scenario.omit({
+  vcsIncluded: true,
+  queries: true
+}).extend({
+  queries: zod.z.array(QueryConfigSimplified)
+});
+var TemplateScenario = Scenario.omit({
+  workspaceId: true
+});
+var CreateTemplateScenario = TemplateScenario.omit({
+  id: true
+});
+
+var ScenarioAuthorizationData = zod.z.object({
+  executionId: UuidString,
+  sessionId: UuidString,
+  projectId: zod.z.string(),
+  address: BlockchainAddress.nullish(),
+  status: zod.z["enum"](["pending", "authorised", "unauthorised"]),
+  scenarioId: zod.z.string(),
+  scenarioName: zod.z.string(),
+  requestMessage: AuthorizationRequestMessage,
+  responseMessage: AuthorizationResponseMessage.nullish(),
+  verificationError: zod.z.string().nullish(),
+  query: QueryConfigSimplified.array(),
+  workflowSessionId: UuidString.optional()
+});
+// v1 sdk
+var SdkVerificationResponseSchema = SdkVerificationOutput;
+var CloseScreenNotification = zod.z.object({
+  type: zod.z.literal("closeScreen"),
+  identifier: zod.z.string(),
+  data: zod.z.undefined()
+});
+var KycCompletionData = zod.z.array(VerifiableCredential);
+var KycCompletionNotification = zod.z.object({
+  type: zod.z.literal("kycCompletion"),
+  identifier: zod.z.string(),
+  data: KycCompletionData
+});
+var RuleEngineScenarioExecutionData = zod.z.object({
+  type: zod.z.literal("RuleEngineScenarioExecution"),
+  data: SdkVerificationResponseSchema
+});
+var OffChainScenarioExecutionData = zod.z.object({
+  type: zod.z.literal("OffChainScenarioExecution"),
+  data: zod.z.array(ScenarioAuthorizationData)
+});
+var OnChainScenarioExecutionData = zod.z.object({
+  type: zod.z.literal("OnChainScenarioExecution"),
+  data: zod.z.any()
+});
+var ScenarioExecutionData = zod.z.union([RuleEngineScenarioExecutionData, OffChainScenarioExecutionData, OnChainScenarioExecutionData]);
+var ScenarioExecutionNotification = zod.z.object({
+  type: zod.z.literal("scenarioExecution"),
+  identifier: zod.z.string(),
+  data: ScenarioExecutionData
+});
+var IsVerifiedNotification = zod.z.object({
+  type: zod.z.literal("isVerifiedNotification"),
+  identifier: zod.z.string(),
+  isVerified: zod.z["boolean"]()
+});
+var PolygonIdInitialized = zod.z.object({
+  type: zod.z.literal("polygonIdInitialized"),
+  identifier: zod.z.string(),
+  data: zod.z.string()
+});
+var OcvSdkInitialized = zod.z.object({
+  type: zod.z.literal("ocvSdkInitialized"),
+  identifier: zod.z.string()
+});
+var StartCompletedNotification = zod.z.object({
+  type: zod.z.literal("startCompletedNotification"),
+  identifier: zod.z.string()
+});
+var IdentityNotificationMessage = zod.z.union([CloseScreenNotification, PolygonIdInitialized, OcvSdkInitialized, StartCompletedNotification, KycCompletionNotification, ScenarioExecutionNotification, IsVerifiedNotification]);
+var InitialDataRequest = zod.z.object({
+  type: zod.z.literal("initialDataRequest"),
+  identifier: zod.z.string()
+});
+var SignatureRequest = zod.z.object({
+  type: zod.z.literal("signatureRequest"),
+  identifier: zod.z.string(),
+  data: zod.z.object({
+    message: zod.z.string()
+  })
+});
+var TransactionData = zod.z.object({
+  accountAddress: BlockchainAddress,
+  to: BlockchainAddress,
+  data: String0x,
+  value: zod.z.string().optional()
+});
+var SendTransactionRequest = zod.z.object({
+  type: zod.z.literal("sendTransactionRequest"),
+  identifier: zod.z.string(),
+  data: TransactionData
+});
+var IdentityRequestMessage = zod.z.union([InitialDataRequest, SignatureRequest, SendTransactionRequest]);
+var AVAILABLE_FLOWS = ["VERIFICATION", "MANAGEMENT", "POLYGON_ID", "KYB"];
+var AvailableFlow = zod.z["enum"](AVAILABLE_FLOWS);
+var DataAvailableOnStart = zod.z.object({
+  identifier: zod.z.string().optional(),
+  flow: zod.z["enum"](AVAILABLE_FLOWS).optional(),
+  accessToken: zod.z.string(),
+  signingMessage: zod.z.string(),
+  signature: zod.z.string()
+});
+var InitialDataResponse = zod.z.object({
+  type: zod.z.literal("onStartKyc"),
+  data: DataAvailableOnStart
+});
+var SignatureResponse = zod.z.object({
+  type: zod.z.literal("signature"),
+  data: BlockchainSignature
+});
+var TransactionResponse = zod.z.object({
+  type: zod.z.literal("transactionResponse"),
+  data: zod.z.object({
+    txHash: TxHash
+  })
+});
+var HostResponseMessage = zod.z.union([InitialDataResponse, SignatureResponse, TransactionResponse]);
+
+/**
+ * Exported types
+ */
+
+var ComplianceImplementationStepsInput = zod.z.object({
+  identityChecks: zod.z["boolean"]().nullish(),
+  configureIdentity: zod.z["boolean"]().nullish(),
+  deployIdentity: zod.z["boolean"]().nullish(),
+  monitorIdentity: zod.z["boolean"]().nullish()
+});
+
+/////////////
+// EIP-155 //
+/////////////
+
+var TxAuthInput = zod.z.object({
+  workflowId: WorkflowId.optional(),
+  chainId: EvmChainId,
+  contractAbi: zod.z.array(zod.z.record(zod.z.unknown())),
+  contractAddress: AddressSchema,
+  functionName: zod.z.string(),
+  args: zod.z.array(zod.z.unknown()),
+  userAddress: AddressSchema,
+  blockExpiration: zod.z.number()["int"]().optional(),
+  nonce: zod.z.number()["int"]().optional()
+});
+// the api endpoint can source the userAddress from the session if it's not provided
+var ApiTxAuthInput = TxAuthInput.extend({
+  userAddress: AddressSchema.optional()
+});
+var TxSignatureResponse = zod.z.object({
+  signature: EIP155Signature,
+  blockExpiration: zod.z.number()
+});
+var GetTxAuthDataSignatureResponse = zod.z.union([zod.z.object({
+  isAuthorized: zod.z.literal(true),
+  signature: EIP155Signature,
+  payload: zod.z.string(),
+  blockExpiration: zod.z.number()
+}), zod.z.object({
+  isAuthorized: zod.z.literal(false),
+  errorMessage: zod.z.any()
+})]);
+/////////////
+// Tezos   //
+/////////////
+
+var TezosTxAuthInput = zod.z.object({
+  workflowId: WorkflowId.optional(),
+  chainID: TezosChainId,
+  contractAddress: TezosContractAddress,
+  functionName: TezosEntrypointName,
+  args: zod.z.string(),
+  userAddress: TezosImplicitAddress,
+  blockExpiration: zod.z.number()["int"]().optional(),
+  nonce: zod.z.number()["int"]().optional()
+});
+// the api endpoint can source the userAddress from the session if it's not provided
+var ApiTezosTxAuthInput = TezosTxAuthInput.extend({
+  userAddress: TezosImplicitAddress.optional()
+});
+var TezosTxSignatureResponse = zod.z.object({
+  signature: EdSignature,
+  blockExpiration: zod.z.number()
+});
+var GetTezosTxAuthDataSignatureResponse = zod.z.union([zod.z.object({
+  isAuthorized: zod.z.literal(true),
+  signature: EdSignature,
+  blockExpiration: zod.z.number()
+}), zod.z.object({
+  isAuthorized: zod.z.literal(false),
+  errorMessage: zod.z.any()
+})]);
+/////////////
+// General //
+/////////////
+
+var ExtendedTxAuthInput = TxAuthInput.and(zod.z.object({
+  namespace: zod.z.literal(BlockchainNamespace.Enum.eip155),
+  userAddress: AddressSchema
+}));
+var ExtendedTezosTxAuthInput = TezosTxAuthInput.and(zod.z.object({
+  namespace: zod.z.literal(BlockchainNamespace.Enum.tezos),
+  userAddress: TezosImplicitAddress
+}));
+var ExtendedTxAuthDataSignatureResponse = GetTxAuthDataSignatureResponse.and(zod.z.object({
+  namespace: zod.z.literal(BlockchainNamespace.Enum.eip155),
+  userAddress: AddressSchema
+}));
+var ExtendedTezosTxAuthDataSignatureResponse = GetTezosTxAuthDataSignatureResponse.and(zod.z.object({
+  namespace: zod.z.literal(BlockchainNamespace.Enum.tezos),
+  userAddress: TezosImplicitAddress
+}));
+var AnyTxAuthDataSignatureResponse = zod.z.union([ExtendedTxAuthDataSignatureResponse, ExtendedTezosTxAuthDataSignatureResponse]);
+/////////////
+// JS SDK  //
+/////////////
+
+var Eip155TxAuthInputJsSdk = ExtendedTxAuthInput.and(zod.z.object({
+  workflowId: WorkflowId
+}));
+var TezosTxAuthInputJsSdk = ExtendedTezosTxAuthInput.and(zod.z.object({
+  workflowId: WorkflowId
+}));
+var AnyTxAuthInputJsSdk = zod.z.union([Eip155TxAuthInputJsSdk, TezosTxAuthInputJsSdk]);
+
+var SimplifiedCredential = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.array(zod.z.string()),
+  issuanceDate: zod.z.string(),
+  journeyId: zod.z.string()
+});
+/**
+ * GetCredentialsRequest
+ */
+var GetCredentialsRequest = zod.z.object({
+  type: zod.z.literal("getCredentials"),
+  data: zod.z.undefined()
+});
+/**
+ * GetCredentialsResponse
+ */
+var GetCredentialsResponse = zod.z.object({
+  type: zod.z.literal("polygonIdCredentials"),
+  credentials: zod.z.array(SimplifiedCredential),
+  identifier: zod.z.string()
+});
+/**
+ * PolygonIdRequest
+ */
+var PolygonIdRequestData = zod.z.union([zod.z.object({
+  type: zod.z.literal("auth"),
+  authRequest: AuthorizationRequestMessage
+}), zod.z.object({
+  type: zod.z.literal("credentialOffer"),
+  credentialOfferRequest: QrCodeLinkWithSchemaType
+}), zod.z.object({
+  type: zod.z.literal("zkp"),
+  zkpRequest: ZeroKnowledgeProofRequest
+})]);
+var PolygonIdRequest = zod.z.object({
+  type: zod.z.literal("polygonIdRequest"),
+  data: PolygonIdRequestData
+});
+/**
+ * PolygonIdResponse
+ */
+var PolygonIdResponseData = zod.z.union([zod.z.object({
+  type: zod.z.literal("auth"),
+  authResponse: AuthorizationResponseMessage
+}), zod.z.object({
+  type: zod.z.literal("credentialOffer"),
+  credentialOfferResponse: zod.z.array(vault_schema.GenericVerifiableCredentialSchema)
+}), zod.z.object({
+  type: zod.z.literal("zkp"),
+  zkpResponse: ZeroKnowledgeProofResponse
+}), zod.z.object({
+  type: zod.z.literal("close"),
+  screen: zod.z["enum"](["auth", "credentialOffer", "zkp", "getCredentials"]),
+  closeResponse: zod.z.string()
+})]);
+var PolygonIdResponse = zod.z.object({
+  type: zod.z.literal("polygonIdResponse"),
+  identifier: zod.z.string(),
+  data: PolygonIdResponseData
+});
+/**
+ * StartFlowRequest
+ */
+var StartFlowRequest = zod.z.union([zod.z.object({
+  type: zod.z.literal("startVerification"),
+  data: zod.z.undefined()
+}), zod.z.object({
+  type: zod.z.literal("startManagement"),
+  data: zod.z.undefined()
+}), zod.z.object({
+  type: zod.z.literal("startKYB"),
+  data: zod.z.undefined()
+})]);
+/**
+ * IsVerifiedRequest
+ */
+var IsVerifiedRequest = zod.z.object({
+  type: zod.z.literal("isVerifiedRequest"),
+  data: zod.z.object({
+    userAddress: AddressSchema
+  }),
+  identifier: zod.z.string()
+});
+/**
+ * IsVerifiedResponse
+ */
+var IsVerifiedResponse = zod.z.object({
+  type: zod.z.literal("isVerifiedResponse"),
+  isVerified: zod.z["boolean"](),
+  identifier: zod.z.string()
+});
+/**
+ * GetTxAuthSigRequest
+ */
+var GetTxAuthSigRequest = zod.z.object({
+  type: zod.z.literal("getTxAuthSigRequest"),
+  data: ApiTxAuthInput,
+  identifier: zod.z.string()
+});
+/**
+ * GetTxAuthSigResponse
+ */
+var GetTxAuthSigResponse = zod.z.object({
+  type: zod.z.literal("getTxAuthSigResponse"),
+  signatureResponse: GetTxAuthDataSignatureResponse,
+  identifier: zod.z.string()
+});
+/**
+ * GetTxAuthSigRequest Tezos
+ */
+var GetTxAuthSigRequestTezos = zod.z.object({
+  type: zod.z.literal("getTxAuthSigRequestTezos"),
+  data: ApiTezosTxAuthInput,
+  identifier: zod.z.string()
+});
+/**
+ * GetTxAuthSigResponse Tezos
+ */
+var GetTxAuthSigResponseTezos = zod.z.object({
+  type: zod.z.literal("getTezosTxAuthSigResponse"),
+  signatureResponse: GetTezosTxAuthDataSignatureResponse,
+  identifier: zod.z.string()
+});
+var HostRequestMessage = zod.z.union([GetCredentialsRequest, PolygonIdRequest, StartFlowRequest, IsVerifiedRequest, GetTxAuthSigRequest, GetTxAuthSigRequestTezos]);
+var IdentityResponseMessage = zod.z.union([GetCredentialsResponse, PolygonIdResponse, IsVerifiedResponse, GetTxAuthSigResponse, GetTxAuthSigResponseTezos]);
+
+/**
+ * Wallet challenge parameters
+ */
+
+var GenerateWalletChallengeRequest = zod.z.object({
+  address: BlockchainAddress,
+  namespace: SupportedBlockchainNamespaceForSignatureAuth,
+  blockchainId: BlockchainId.optional(),
+  origin: zod.z.string().url(),
+  workflowId: WorkflowId,
+  externalCustomerId: ExternalCustomerId.optional(),
+  additionalInformation: AdditionalCustomerInformationParams.optional()
+});
+var AuthSession = zod.z.object({
+  // JWT token containing user authentication data
+  // Generated by the Identity-api using the IdentityWidgetAccessToken_NEW schema
+  // Used for user identification in the identity-v2-app
+  // We don't want users to rely on the structure of the token so we expose it as a string
+  token: zod.z.string(),
+  // the timestamp at which the session will expire
+  // in seconds since epoch to avoid timezone issues and date parsing errors
+  // this is exposed in case the app needs to store the session so it knows when
+  // the session becomes invalid again
+  // We don't want users to rely on the fact that the token is a JWT, as we
+  // want to change to openId in the future, so we expose the expiration as a number
+  expiresAt: zod.z.number(),
+  // if an external customer id was provided, it will be returned
+  // when obtaining the auth session to facilitate integration with the user's system
+  externalCustomerId: ExternalCustomerId.optional()
+});
+var AuthSessionData = zod.z.object({
+  /**
+   * The unique identifier of the user
+   */
+  identityId: zod.z.string(),
+  /**
+   * The unique identifier of the user's session
+   */
+  customerId: zod.z.string(),
+  /**
+   * The identifier passed by the user platform
+   */
+  externalCustomerId: ExternalCustomerId.optional()
+});
+var ChallengeResponse = zod.z.object({
+  challenge: zod.z.string()
+});
+////////////////
+// SDK messages
+////////////////
+
+var AppConfigRequest = zod.z.object({
+  type: zod.z.literal("appConfig"),
+  data: zod.z.object({
+    authSession: AuthSession
+  })
+});
+var WalletUpdated = zod.z.object({
+  type: zod.z.literal("walletUpdated"),
+  data: zod.z.object({
+    address: BlockchainAddress
+  })
+});
+var WalletSignResponse = zod.z.object({
+  type: zod.z.literal("walletSignResponse"),
+  data: zod.z.object({
+    message: zod.z.string(),
+    signature: BlockchainSignature
+  })
+});
+var TxAuthDataSignatureGatingRequest = zod.z.object({
+  type: zod.z.literal("txAuthDataSignatureGatingRequest"),
+  data: zod.z.object({
+    input: AnyTxAuthInputJsSdk
+  })
+});
+var GetCustomerStatusRequest = zod.z.object({
+  type: zod.z.literal("getCustomerStatusRequest")
+});
+var IdentitySdkMessage = zod.z.union([AppConfigRequest, WalletUpdated, WalletSignResponse, TransactionResponse, TxAuthDataSignatureGatingRequest, GetCustomerStatusRequest]);
+var IdentitySdkMessageWithIdentifier = zod.z.intersection(IdentitySdkMessage, zod.z.object({
+  identifier: zod.z.string()
+}));
+////////////////
+// App messages
+////////////////
+
+var IdentityAppLoadedNotification = zod.z.object({
+  type: zod.z.literal("identityAppLoaded")
+});
+var IdentityAppConfiguredNotification = zod.z.object({
+  type: zod.z.literal("identityAppConfigured"),
+  data: zod.z.object({
+    auth: AuthSession
+  })
+});
+var AuthenticationExpiredNotification = zod.z.object({
+  type: zod.z.literal("authenticationExpired"),
+  data: zod.z.object({
+    authSession: AuthSession
+  })
+});
+var WalletSignRequest = zod.z.object({
+  type: zod.z.literal("walletSignRequest"),
+  data: zod.z.object({
+    message: zod.z.string()
+  })
+});
+var TxAuthDataSignatureResponse = zod.z.object({
+  type: zod.z.literal("txAuthDataSignatureResponse"),
+  data: AnyTxAuthDataSignatureResponse
+});
+var TxAuthDataSignatureGatingError = zod.z.object({
+  type: zod.z.literal("txAuthDataSignatureGatingError"),
+  data: zod.z.object({
+    error: zod.z.string()
+  })
+});
+var GetCustomerStatusResponse = zod.z.object({
+  type: zod.z.literal("getCustomerStatusResponse"),
+  data: zod.z.union([vault_schema.CustomerStatus, zod.z["null"]()])
+});
+var IdentityAppMessage = zod.z.union([IdentityAppLoadedNotification, IdentityAppConfiguredNotification, AuthenticationExpiredNotification, WalletSignRequest, TxAuthDataSignatureResponse, TxAuthDataSignatureGatingError, GetCustomerStatusResponse,
+// `identifier` is a technical detail that should not be exposed to the app
+KycCompletionNotification.omit({
+  identifier: true
+}), ScenarioExecutionNotification.omit({
+  identifier: true
+}), CloseScreenNotification.omit({
+  identifier: true
+}), IsVerifiedNotification.omit({
+  identifier: true
+}), SendTransactionRequest.omit({
+  identifier: true
+})]);
+var IdentityWallet = zod.z.object({
+  address: BlockchainAddress,
+  namespace: SupportedBlockchainNamespaceForSignatureAuth
+});
+
+var ZKPRequest = zod.z.object({
+  id: zod.z.number(),
+  circuitId: zod.z["enum"](["credentialAtomicQuerySigV2", "credentialAtomicQuerySigV2OnChain"]),
+  optional: zod.z["boolean"]().optional(),
+  query: QueryConfigSimplified
+});
+var ZKPRequestFromZKVerifier = zod.z.object({
+  id: zod.z.number(),
+  circuitId: zod.z.string(),
+  optional: zod.z["boolean"]().optional(),
+  query: zod.z.record(zod.z.unknown())
+});
+var PrivacyPreservingMonitoring = zod.z.object({
+  requestingAuthorizationMessage: zod.z.string().nullish(),
+  zkpRequest: zod.z.array(ZKPRequest).nullish()
+});
+var CreateAuthRequestProps = zod.z.object({
+  hostUrl: zod.z.string().url(),
+  sessionId: UuidString,
+  audience: zod.z.string().describe("DID of the verifier"),
+  callbackURL: zod.z.string().describe("URL to which the auth response of the client callback will be sent"),
+  query: zod.z.array(QueryConfigSimplified),
+  onChainVerification: zod.z["boolean"]().optional(),
+  id: zod.z.string().uuid(),
+  thid: zod.z.string().uuid(),
+  message: zod.z.string().describe("Message shown to the user")
+});
+var AllScenarioExecutionAuthorizationData = zod.z.object({
+  executionId: UuidString,
+  projectId: zod.z.string(),
+  scenarioExecutionIds: zod.z.array(UuidString)
+});
+var SCENARIO_AUTHORIZATION_STATUSES = ["pending", "authorised", "unauthorised"];
+var ScenarioAuthorizationStatus = zod.z["enum"](SCENARIO_AUTHORIZATION_STATUSES);
+
+var HostMessage = zod.z.union([HostRequestMessage, HostResponseMessage]);
+var IdentityMessage = zod.z.union([IdentityNotificationMessage, IdentityRequestMessage, IdentityResponseMessage]);
+var RequiredDataRowSchema = zod.z.object({
+  type: CredentialType,
+  requiredAttributes: zod.z.array(zod.z.object({
+    attribute: zod.z.string(),
+    value: zod.z.string(),
+    operator: zod.z.string()
+  }))
+});
+var RequiredVerificationData = zod.z.object({
+  ruleEngine: zod.z.object({
+    requiredData: zod.z.array(RequiredDataRowSchema)
+  }),
+  PrivacyPreservingMonitoring: zod.z.object({
+    requiredData: zod.z.array(RequiredDataRowSchema),
+    verifications: zod.z.array(zod.z.object({
+      scenarioVerifierAddress: zod.z.string(),
+      conditions: zod.z.array(ZKPRequest)
+    }))
+  })
+});
+
+var WalletSignatureResponse = zod.z.object({
+  // the message we requested the user to sign
+  message: zod.z.string(),
+  // the signature of the message
+  signature: BlockchainSignature,
+  // some wallets like Cardano Nami generate a new address for each transaction or signature
+  // this means we have to request the signer's public key to verify the signature
+  signerPublicKey: PublicKey,
+  // the type of the signer's public key
+  // this is optional because some wallets don't provide this information
+  // but for other wallets like cosmos kepler, this is required to verify the signature
+  signerPublicKeyType: zod.z.string().optional(),
+  // some wallets like Aptos Petra wrap the message in some text metadata before signing
+  // this means the user doesn't sign the message directly, but a message that contains the original message
+  signedMessage: zod.z.string()
+});
+var VerifyWalletChallengeRequest = WalletSignatureResponse.and(zod.z.object({
+  address: BlockchainAddress,
+  namespace: SupportedBlockchainNamespaceForSignatureAuth,
+  blockchainId: BlockchainId.optional()
+}));
+
+exports.ACTIVE_APTOS_CHAIN_IDS = ACTIVE_APTOS_CHAIN_IDS;
+exports.ACTIVE_BITCOIN_CHAIN_IDS = ACTIVE_BITCOIN_CHAIN_IDS;
+exports.ACTIVE_CARDANO_CHAIN_IDS = ACTIVE_CARDANO_CHAIN_IDS;
+exports.ACTIVE_COSMOS_CHAIN_IDS = ACTIVE_COSMOS_CHAIN_IDS;
+exports.ACTIVE_EVM_CHAIN_VALUES = ACTIVE_EVM_CHAIN_VALUES;
+exports.ACTIVE_POLKADOT_CHAIN_IDS = ACTIVE_POLKADOT_CHAIN_IDS;
+exports.ACTIVE_SOLANA_CHAIN_IDS = ACTIVE_SOLANA_CHAIN_IDS;
+exports.ACTIVE_TEZOS_CHAIN_IDS = ACTIVE_TEZOS_CHAIN_IDS;
+exports.APTOS_CHAIN_IDS = APTOS_CHAIN_IDS;
+exports.APTOS_CHAIN_NAMES = APTOS_CHAIN_NAMES;
+exports.APTOS_CHAIN_NAMES_LIST = APTOS_CHAIN_NAMES_LIST;
+exports.ARRAY_OPERATORS = ARRAY_OPERATORS;
+exports.AUTHORIZATION_REQUEST_MESSAGE_TYPES = AUTHORIZATION_REQUEST_MESSAGE_TYPES;
+exports.AVAILABLE_FLOWS = AVAILABLE_FLOWS;
+exports.AbbreviatedWorkflowScenario = AbbreviatedWorkflowScenario;
+exports.ActionId = ActionId;
+exports.ActionPrefix = ActionPrefix;
+exports.AdditionalCustomerInformationParams = AdditionalCustomerInformationParams;
+exports.AddressSchema = AddressSchema;
+exports.AllCredentialValues = AllCredentialValues;
+exports.AllScenarioExecutionAuthorizationData = AllScenarioExecutionAuthorizationData;
+exports.AnyTxAuthDataSignatureResponse = AnyTxAuthDataSignatureResponse;
+exports.AnyTxAuthInputJsSdk = AnyTxAuthInputJsSdk;
+exports.ApiTezosTxAuthInput = ApiTezosTxAuthInput;
+exports.ApiTxAuthInput = ApiTxAuthInput;
+exports.AppId = AppId;
+exports.AppPrefix = AppPrefix;
+exports.AptosAddress = AptosAddress;
+exports.AptosChainId = AptosChainId;
+exports.AptosSignature = AptosSignature;
+exports.ArrayOperator = ArrayOperator;
+exports.AuthQrCodeData = AuthQrCodeData;
+exports.AuthSession = AuthSession;
+exports.AuthSessionData = AuthSessionData;
+exports.AuthorizationRequestMessage = AuthorizationRequestMessage;
+exports.AuthorizationRequestMessageType = AuthorizationRequestMessageType;
+exports.AuthorizationRequestMessageTypes = AuthorizationRequestMessageTypes;
+exports.AuthorizationResponseMessage = AuthorizationResponseMessage;
+exports.AvailableFlow = AvailableFlow;
+exports.BITCOIN_CHAIN_IDS = BITCOIN_CHAIN_IDS;
+exports.BITCOIN_CHAIN_NAMES = BITCOIN_CHAIN_NAMES;
+exports.BITCOIN_CHAIN_NAMES_LIST = BITCOIN_CHAIN_NAMES_LIST;
+exports.BLOCKCHAIN_NAMESPACES = BLOCKCHAIN_NAMESPACES;
+exports.BLOCKCHAIN_NAMESPACES_NAMES = BLOCKCHAIN_NAMESPACES_NAMES;
+exports.BLOCKCHAIN_NAMESPACE_TO_NAME = BLOCKCHAIN_NAMESPACE_TO_NAME;
+exports.BLOCKCHAIN_NAME_TO_NAMESPACE = BLOCKCHAIN_NAME_TO_NAMESPACE;
+exports.BOOLEAN_OPERATORS = BOOLEAN_OPERATORS;
+exports.BaseQueryResponse = BaseQueryResponse;
+exports.BitcoinAddress = BitcoinAddress;
+exports.BitcoinBech32Address = BitcoinBech32Address;
+exports.BitcoinChainId = BitcoinChainId;
+exports.BitcoinP2PKHAddress = BitcoinP2PKHAddress;
+exports.BitcoinP2SHAddress = BitcoinP2SHAddress;
+exports.BitcoinTestnetBech32Address = BitcoinTestnetBech32Address;
+exports.BitcoinTestnetP2PKHAddress = BitcoinTestnetP2PKHAddress;
+exports.BitcoinTestnetP2SHAddress = BitcoinTestnetP2SHAddress;
+exports.BlockchainAddress = BlockchainAddress;
+exports.BlockchainId = BlockchainId;
+exports.BlockchainNamespace = BlockchainNamespace;
+exports.BlockchainSignature = BlockchainSignature;
+exports.BooleanOperator = BooleanOperator;
+exports.CARDANO_CHAIN_IDS = CARDANO_CHAIN_IDS;
+exports.CARDANO_CHAIN_NAMES = CARDANO_CHAIN_NAMES;
+exports.CARDANO_CHAIN_NAMES_LIST = CARDANO_CHAIN_NAMES_LIST;
+exports.CIRCUIT_IDS = CIRCUIT_IDS;
+exports.COSMOS_CHAIN_IDS = COSMOS_CHAIN_IDS;
+exports.COSMOS_CHAIN_NAMES = COSMOS_CHAIN_NAMES;
+exports.COSMOS_CHAIN_NAMES_LIST = COSMOS_CHAIN_NAMES_LIST;
+exports.CardanoAddress = CardanoAddress;
+exports.CardanoChainId = CardanoChainId;
+exports.CardanoSignature = CardanoSignature;
+exports.ChallengeId = ChallengeId;
+exports.ChallengePrefix = ChallengePrefix;
+exports.ChallengeResponse = ChallengeResponse;
+exports.CircuitId = CircuitId;
+exports.CloseScreenNotification = CloseScreenNotification;
+exports.ComplianceImplementationStepsInput = ComplianceImplementationStepsInput;
+exports.CosmosAddress = CosmosAddress;
+exports.CosmosChainId = CosmosChainId;
+exports.CosmosSignature = CosmosSignature;
+exports.CreateAuthRequestProps = CreateAuthRequestProps;
+exports.CreateTemplateScenario = CreateTemplateScenario;
+exports.CredentialMediaType = CredentialMediaType;
+exports.CredentialNames = CredentialNames;
+exports.CredentialQrCodeData = CredentialQrCodeData;
+exports.CredentialSchemas = CredentialSchemas;
+exports.CredentialType = CredentialType;
+exports.CredentialTypes = CredentialTypes;
+exports.CustomerId = CustomerId;
+exports.CustomerScreeningId = CustomerScreeningId;
+exports.CustomerScreeningPrefix = CustomerScreeningPrefix;
+exports.DATE_OPERATORS = DATE_OPERATORS;
+exports.DISPLAYED_BLOCKCHAIN_NAMESPACES = DISPLAYED_BLOCKCHAIN_NAMESPACES;
+exports.DataAvailableOnStart = DataAvailableOnStart;
+exports.DateOperator = DateOperator;
+exports.DisplayedBlockchainNamespace = DisplayedBlockchainNamespace;
+exports.EIP155Signature = EIP155Signature;
+exports.ENVS = ENVS;
+exports.EVM_BLOCK_TIME = EVM_BLOCK_TIME;
+exports.EVM_CHAINS_WITHOUT_DEDICATED_NODE_RPC = EVM_CHAINS_WITHOUT_DEDICATED_NODE_RPC;
+exports.EdSignature = EdSignature;
+exports.Eip155TxAuthInputJsSdk = Eip155TxAuthInputJsSdk;
+exports.EmailId = EmailId;
+exports.EmailPrefix = EmailPrefix;
+exports.EnvironmentSchema = EnvironmentSchema;
+exports.EvmChainId = EvmChainId;
+exports.ExecuteQueryResponse = ExecuteQueryResponse;
+exports.ExtendedTezosTxAuthDataSignatureResponse = ExtendedTezosTxAuthDataSignatureResponse;
+exports.ExtendedTezosTxAuthInput = ExtendedTezosTxAuthInput;
+exports.ExtendedTxAuthDataSignatureResponse = ExtendedTxAuthDataSignatureResponse;
+exports.ExtendedTxAuthInput = ExtendedTxAuthInput;
+exports.ExternalCustomerId = ExternalCustomerId;
+exports.FLOW_TYPES = FLOW_TYPES;
+exports.FlowType = FlowType;
+exports.FunctionCallData = FunctionCallData;
+exports.GenerateWalletChallengeRequest = GenerateWalletChallengeRequest;
+exports.GetCredentialsRequest = GetCredentialsRequest;
+exports.GetCredentialsResponse = GetCredentialsResponse;
+exports.GetCustomerStatusRequest = GetCustomerStatusRequest;
+exports.GetCustomerStatusResponse = GetCustomerStatusResponse;
+exports.GetTezosTxAuthDataSignatureResponse = GetTezosTxAuthDataSignatureResponse;
+exports.GetTxAuthDataSignatureResponse = GetTxAuthDataSignatureResponse;
+exports.GetTxAuthSigRequest = GetTxAuthSigRequest;
+exports.GetTxAuthSigRequestTezos = GetTxAuthSigRequestTezos;
+exports.GetTxAuthSigResponse = GetTxAuthSigResponse;
+exports.GetTxAuthSigResponseTezos = GetTxAuthSigResponseTezos;
+exports.HexadecimalSchema = HexadecimalSchema;
+exports.HostMessage = HostMessage;
+exports.HostRequestMessage = HostRequestMessage;
+exports.HostResponseMessage = HostResponseMessage;
+exports.IDENTITY_DOCUMENT_COUNTRY_LIST_OPTIONS = IDENTITY_DOCUMENT_COUNTRY_LIST_OPTIONS;
+exports.IDENTITY_DOCUMENT_OPTIONS = IDENTITY_DOCUMENT_OPTIONS;
+exports.Identifier = Identifier;
+exports.IdentityAppMessage = IdentityAppMessage;
+exports.IdentityAppV2Web2JWT = IdentityAppV2Web2JWT;
+exports.IdentityAppV2Web3JWT = IdentityAppV2Web3JWT;
+exports.IdentityDocumentCountryListOption = IdentityDocumentCountryListOption;
+exports.IdentityDocumentOptionsType = IdentityDocumentOptionsType;
+exports.IdentityId = IdentityId;
+exports.IdentityMessage = IdentityMessage;
+exports.IdentityNotificationMessage = IdentityNotificationMessage;
+exports.IdentityPrefix = IdentityPrefix;
+exports.IdentityRequestMessage = IdentityRequestMessage;
+exports.IdentityResponseMessage = IdentityResponseMessage;
+exports.IdentitySdkMessage = IdentitySdkMessage;
+exports.IdentitySdkMessageWithIdentifier = IdentitySdkMessageWithIdentifier;
+exports.IdentityWallet = IdentityWallet;
+exports.IdentityWidgetAccessToken = IdentityWidgetAccessToken;
+exports.IdentityWidgetAccessToken_NEW = IdentityWidgetAccessToken_NEW;
+exports.IdentityWidgetSessionToken = IdentityWidgetSessionToken;
+exports.InitialDataRequest = InitialDataRequest;
+exports.InitialDataResponse = InitialDataResponse;
+exports.InstitutionExtractedInfosId = InstitutionExtractedInfosId;
+exports.InstitutionExtractedInfosPrefix = InstitutionExtractedInfosPrefix;
+exports.InstitutionId = InstitutionId;
+exports.InstitutionPrefix = InstitutionPrefix;
+exports.IpAddress = IpAddress;
+exports.IsVerifiedNotification = IsVerifiedNotification;
+exports.IsVerifiedRequest = IsVerifiedRequest;
+exports.IsVerifiedResponse = IsVerifiedResponse;
+exports.KycCompletionData = KycCompletionData;
+exports.KycCompletionNotification = KycCompletionNotification;
+exports.ListId = ListId;
+exports.ListPrefix = ListPrefix;
+exports.MediaType = MediaType;
+exports.MediaTypePID = MediaTypePID;
+exports.MemberId = MemberId;
+exports.NEXERA_ACTIVE_STARKNET_CHAIN_IDS = NEXERA_ACTIVE_STARKNET_CHAIN_IDS;
+exports.NEXERA_APTOS_CHAINS = NEXERA_APTOS_CHAINS;
+exports.NEXERA_BITCOIN_CHAINS = NEXERA_BITCOIN_CHAINS;
+exports.NEXERA_CARDANO_CHAINS = NEXERA_CARDANO_CHAINS;
+exports.NEXERA_COSMOS_CHAINS = NEXERA_COSMOS_CHAINS;
+exports.NEXERA_EVM_CHAINS = NEXERA_EVM_CHAINS;
+exports.NEXERA_EVM_CHAINS_ID = NEXERA_EVM_CHAINS_ID;
+exports.NEXERA_EVM_CHAIN_NAMES = NEXERA_EVM_CHAIN_NAMES;
+exports.NEXERA_EVM_CHAIN_NAMES_LIST = NEXERA_EVM_CHAIN_NAMES_LIST;
+exports.NEXERA_POLKADOT_CHAINS = NEXERA_POLKADOT_CHAINS;
+exports.NEXERA_SOLANA_CHAINS = NEXERA_SOLANA_CHAINS;
+exports.NEXERA_STARKNET_CHAINS = NEXERA_STARKNET_CHAINS;
+exports.NEXERA_STARKNET_CHAIN_IDS = NEXERA_STARKNET_CHAIN_IDS;
+exports.NEXERA_STARKNET_CHAIN_NAMES = NEXERA_STARKNET_CHAIN_NAMES;
+exports.NEXERA_TEZOS_CHAINS = NEXERA_TEZOS_CHAINS;
+exports.NEXERA_TEZOS_CHAIN_IDS = NEXERA_TEZOS_CHAIN_IDS;
+exports.NEXERA_TEZOS_CHAIN_NAMES = NEXERA_TEZOS_CHAIN_NAMES;
+exports.NEXERA_TEZOS_CHAIN_NAMES_LIST = NEXERA_TEZOS_CHAIN_NAMES_LIST;
+exports.NUMERIC_OPERATORS = NUMERIC_OPERATORS;
+exports.NexeraCredentialType = NexeraCredentialType;
+exports.NexeraEvmChains = NexeraEvmChains;
+exports.NonTestnetBlockchainId = NonTestnetBlockchainId;
+exports.NumericOperator = NumericOperator;
+exports.OLD_CHALLENGE_QUERY_OPERATORS = OLD_CHALLENGE_QUERY_OPERATORS;
+exports.OLD_ChallengeQueryOperator = OLD_ChallengeQueryOperator;
+exports.OLD_ChallengeQueryOperatorToOperator = OLD_ChallengeQueryOperatorToOperator;
+exports.OLD_ChallengeQuerySchema = OLD_ChallengeQuerySchema;
+exports.OLD_QueryCredentialType = OLD_QueryCredentialType;
+exports.OLD_QueryCredentialTypes = OLD_QueryCredentialTypes;
+exports.OPERATORS = OPERATORS;
+exports.OcvSdkInitialized = OcvSdkInitialized;
+exports.OffChainScenarioExecutionData = OffChainScenarioExecutionData;
+exports.OffChainZKPRuleResult = OffChainZKPRuleResult;
+exports.OnChainScenarioExecutionData = OnChainScenarioExecutionData;
+exports.Operator = Operator;
+exports.OperatorMappings = OperatorMappings;
+exports.OperatorToOLD_ChallengeQueryOperator = OperatorToOLD_ChallengeQueryOperator;
+exports.OrganizationId = OrganizationId;
+exports.OtpCode = OtpCode;
+exports.P2Signature = P2Signature;
+exports.PERSONAL_INFORMATION_FIELDS = PERSONAL_INFORMATION_FIELDS;
+exports.POLKADOT_CHAIN_IDS = POLKADOT_CHAIN_IDS;
+exports.POLKADOT_CHAIN_NAMES = POLKADOT_CHAIN_NAMES;
+exports.POLKADOT_CHAIN_NAMES_LIST = POLKADOT_CHAIN_NAMES_LIST;
+exports.POLYGON_NETWORK_NAMES = POLYGON_NETWORK_NAMES;
+exports.PUBLIC_SERVICES_SCHEMA_MAP = PUBLIC_SERVICES_SCHEMA_MAP;
+exports.PartialQueryConfigSimplified = PartialQueryConfigSimplified;
+exports.PersonalInformationFieldsIdentityDocuments = PersonalInformationFieldsIdentityDocuments;
+exports.PolkadotAddress = PolkadotAddress;
+exports.PolkadotChainId = PolkadotChainId;
+exports.PolkadotSignature = PolkadotSignature;
+exports.PolygonIdInitialized = PolygonIdInitialized;
+exports.PolygonIdRequest = PolygonIdRequest;
+exports.PolygonIdRequestData = PolygonIdRequestData;
+exports.PolygonIdResponse = PolygonIdResponse;
+exports.PolygonIdResponseData = PolygonIdResponseData;
+exports.PolygonNetworkNames = PolygonNetworkNames;
+exports.PrivacyPreservingMonitoring = PrivacyPreservingMonitoring;
+exports.PrivateKey = PrivateKey;
+exports.ProofData = ProofData;
+exports.PublicKey = PublicKey;
+exports.QUERY_LOGIC_OPERATOR = QUERY_LOGIC_OPERATOR;
+exports.QrCodeLinkWithSchemaType = QrCodeLinkWithSchemaType;
+exports.QueryConfigSimplified = QueryConfigSimplified;
+exports.QueryId = QueryId;
+exports.QueryLogicOperator = QueryLogicOperator;
+exports.QueryPrefix = QueryPrefix;
+exports.RequiredDataRowSchema = RequiredDataRowSchema;
+exports.RequiredVerificationData = RequiredVerificationData;
+exports.RuleEngineResponse = RuleEngineResponse;
+exports.RuleEngineScenarioExecutionData = RuleEngineScenarioExecutionData;
+exports.RuleResultStatus = RuleResultStatus;
+exports.RuleResultStatusLabels = RuleResultStatusLabels;
+exports.RuleResultStatuses = RuleResultStatuses;
+exports.SCENARIO_AUTHORIZATION_STATUSES = SCENARIO_AUTHORIZATION_STATUSES;
+exports.SOLANA_CHAIN_IDS = SOLANA_CHAIN_IDS;
+exports.SOLANA_CHAIN_NAMES = SOLANA_CHAIN_NAMES;
+exports.SOLANA_CHAIN_NAMES_LIST = SOLANA_CHAIN_NAMES_LIST;
+exports.STRING_OPERATORS = STRING_OPERATORS;
+exports.SUPPORTED_BLOCKCHAIN_NAMESPACES_FOR_SIGNATURE_AUTH = SUPPORTED_BLOCKCHAIN_NAMESPACES_FOR_SIGNATURE_AUTH;
+exports.SUPPORTED_TYPES = SUPPORTED_TYPES;
+exports.Scenario = Scenario;
+exports.ScenarioAuthorizationData = ScenarioAuthorizationData;
+exports.ScenarioAuthorizationStatus = ScenarioAuthorizationStatus;
+exports.ScenarioExecutionData = ScenarioExecutionData;
+exports.ScenarioExecutionNotification = ScenarioExecutionNotification;
+exports.ScenarioExecutionResponse = ScenarioExecutionResponse;
+exports.ScenarioId = ScenarioId;
+exports.ScenarioPrefix = ScenarioPrefix;
+exports.ScenarioType = ScenarioType;
+exports.ScenarioTypes = ScenarioTypes;
+exports.SdkVerificationOutput = SdkVerificationOutput;
+exports.SdkVerificationResponseSchema = SdkVerificationResponseSchema;
+exports.SendTransactionRequest = SendTransactionRequest;
+exports.SignatureRequest = SignatureRequest;
+exports.SignatureResponse = SignatureResponse;
+exports.SimplifiedCredential = SimplifiedCredential;
+exports.SolanaChainId = SolanaChainId;
+exports.SpSignature = SpSignature;
+exports.StarknetAddress = StarknetAddress;
+exports.StarknetChainId = StarknetChainId;
+exports.StarknetSignature = StarknetSignature;
+exports.StartCompletedNotification = StartCompletedNotification;
+exports.StartFlowRequest = StartFlowRequest;
+exports.StorageId = StorageId;
+exports.StoragePrefix = StoragePrefix;
+exports.String0x = String0x;
+exports.StringOperator = StringOperator;
+exports.SupportedBlockchainNamespaceForSignatureAuth = SupportedBlockchainNamespaceForSignatureAuth;
+exports.SupportedType = SupportedType;
+exports.SupportedTypes = SupportedTypes;
+exports.TagId = TagId;
+exports.TagPrefix = TagPrefix;
+exports.TagsToTransactionReviewsId = TagsToTransactionReviewsId;
+exports.TagsToTransactionReviewsPrefix = TagsToTransactionReviewsPrefix;
+exports.TemplateScenario = TemplateScenario;
+exports.TestId = TestId;
+exports.TestPrefix = TestPrefix;
+exports.TezosAddress = TezosAddress;
+exports.TezosChainId = TezosChainId;
+exports.TezosContractAddress = TezosContractAddress;
+exports.TezosEntrypointName = TezosEntrypointName;
+exports.TezosImplicitAddress = TezosImplicitAddress;
+exports.TezosSignature = TezosSignature;
+exports.TezosTxAuthInput = TezosTxAuthInput;
+exports.TezosTxAuthInputJsSdk = TezosTxAuthInputJsSdk;
+exports.TezosTxSignatureResponse = TezosTxSignatureResponse;
+exports.TransactionAddressesId = TransactionAddressesId;
+exports.TransactionAddressesPrefix = TransactionAddressesPrefix;
+exports.TransactionAmountId = TransactionAmountId;
+exports.TransactionAmountPrefix = TransactionAmountPrefix;
+exports.TransactionData = TransactionData;
+exports.TransactionExtractedInfosId = TransactionExtractedInfosId;
+exports.TransactionExtractedInfosPrefix = TransactionExtractedInfosPrefix;
+exports.TransactionFeesId = TransactionFeesId;
+exports.TransactionFeesPrefix = TransactionFeesPrefix;
+exports.TransactionId = TransactionId;
+exports.TransactionInfosId = TransactionInfosId;
+exports.TransactionInfosPrefix = TransactionInfosPrefix;
+exports.TransactionMethodExtractedInfosId = TransactionMethodExtractedInfosId;
+exports.TransactionMethodExtractedInfosPrefix = TransactionMethodExtractedInfosPrefix;
+exports.TransactionMethodsId = TransactionMethodsId;
+exports.TransactionMethodsPrefix = TransactionMethodsPrefix;
+exports.TransactionPartiesId = TransactionPartiesId;
+exports.TransactionPartiesPrefix = TransactionPartiesPrefix;
+exports.TransactionPrefix = TransactionPrefix;
+exports.TransactionResponse = TransactionResponse;
+exports.TransactionReviewId = TransactionReviewId;
+exports.TransactionReviewPrefix = TransactionReviewPrefix;
+exports.TxAuthDataSignatureGatingError = TxAuthDataSignatureGatingError;
+exports.TxAuthDataSignatureGatingRequest = TxAuthDataSignatureGatingRequest;
+exports.TxAuthDataSignatureResponse = TxAuthDataSignatureResponse;
+exports.TxAuthInput = TxAuthInput;
+exports.TxHash = TxHash;
+exports.TxSignatureResponse = TxSignatureResponse;
+exports.UuidString = UuidString;
+exports.VerifiableCredential = VerifiableCredential;
+exports.VerificationMode = VerificationMode;
+exports.VerificationModes = VerificationModes;
+exports.VerificationOutput = VerificationOutput;
+exports.VerificationSessionStatus = VerificationSessionStatus;
+exports.VerificationSessionStatuses = VerificationSessionStatuses;
+exports.VerifyWalletChallengeRequest = VerifyWalletChallengeRequest;
+exports.WalletId = WalletId;
+exports.WalletPrefix = WalletPrefix;
+exports.WalletSignResponse = WalletSignResponse;
+exports.WalletSignatureResponse = WalletSignatureResponse;
+exports.Web2CreateSessionParams = Web2CreateSessionParams;
+exports.WorkflowId = WorkflowId;
+exports.WorkflowSessionAttributeId = WorkflowSessionAttributeId;
+exports.WorkflowSessionAttributePrefix = WorkflowSessionAttributePrefix;
+exports.WorkflowSessionId = WorkflowSessionId;
+exports.WorkspaceId = WorkspaceId;
+exports.ZKPOperator = ZKPOperator;
+exports.ZKPRequest = ZKPRequest;
+exports.ZKPRequestFromZKVerifier = ZKPRequestFromZKVerifier;
+exports.ZeroKnowledgeProofRequest = ZeroKnowledgeProofRequest;
+exports.ZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse;
+exports._defineProperty = _defineProperty;
+exports.createBrandedSchemaId = createBrandedSchemaId;
+exports.generateId = generateId;
+exports.getCredentialName = getCredentialName;
+exports.getOldCredentialPath = getOldCredentialPath;
+exports.getOldCredentialType = getOldCredentialType;
+exports.isValidAddress = isValidAddress;
+exports.oldCredentialPathToDataLink = oldCredentialPathToDataLink;
+exports.operatorDisplayMap = operatorDisplayMap;
+exports.parseIden3Message = parseIden3Message;
+exports.parseSessionIdFromUrl = parseSessionIdFromUrl;
+exports.shortBlockchainAddress = shortBlockchainAddress;