@nexeraid/identity-schemas 2.164.0-dev → 2.165.0-dev

package/dist/{identity-api.schema-073b77e8.cjs.dev.cjs → identity-api.schema-9a1b028a.cjs.dev.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var zod = require('zod');
-var vault_schema = require('./vault.schema-68148c82.cjs.dev.cjs');
+var z = require('zod');
+var vault_schema = require('./vault.schema-6368506b.cjs.dev.cjs');
 
 var CredentialSchemas = {
   ProofOfResidence: vault_schema.ProofOfResidenceCredentialSubjectSchema,
@@ -42,24 +42,24 @@ var CredentialTypes = ["AMLScreeningsResults", "ProofOfResidence", "SelfieImage"
 // this is for backwards compatibility
 "IDScanPassport" // this is for backwards compatibility
 ];
-var NexeraCredentialType = zod.z["enum"](CredentialTypes);
+var NexeraCredentialType = z.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) {
+var CredentialType = z.z.string().transform(function (x) {
   return x.replace("_", "-");
 }) // TODO determine why this is needed
-.pipe(zod.z["enum"](CredentialTypes));
+.pipe(z.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 VerifiableCredential = z.z.object({
+  issuer: z.z.string(),
+  type: z.z.array(z.z.union([z.z.string(), CredentialType])),
+  credentialSubject: z.z.record(z.z.unknown())
+}).catchall(z.z.any());
 var CredentialMediaType = vault_schema.IDImageCredentialSubjectSchema.shape.mediaType_front;
 
 // Request
@@ -70,14 +70,14 @@ var MediaType = /*#__PURE__*/function (MediaType) {
   MediaType["SignedMessage"] = "application/iden3comm-signed-json";
   return MediaType;
 }({});
-var MediaTypePID = zod.z.nativeEnum(MediaType);
+var MediaTypePID = z.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().or(zod.z.string()),
-  circuitId: zod.z.string(),
-  optional: zod.z["boolean"]().optional(),
-  query: zod.z.record(zod.z.string(), zod.z.any())
+var CircuitId = z.z["enum"](CIRCUIT_IDS);
+var ZeroKnowledgeProofRequest = z.z.object({
+  id: z.z.number().or(z.z.string()),
+  circuitId: z.z.string(),
+  optional: z.z["boolean"]().optional(),
+  query: z.z.record(z.z.string(), z.z.any())
 });
 var AUTHORIZATION_REQUEST_MESSAGE_TYPES = {
   AUTHORIZATION_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/authorization/1.0/request",
@@ -102,78 +102,78 @@ var AUTHORIZATION_REQUEST_MESSAGE_TYPES = {
   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(),
+var AuthorizationRequestMessageType = z.z["enum"](AuthorizationRequestMessageTypes);
+var AuthorizationRequestMessage = z.z.object({
+  id: z.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)
+  thid: z.z.string().optional(),
+  body: z.z.object({
+    callbackUrl: z.z.string(),
+    reason: z.z.string().optional(),
+    did_doc: z.z.any().optional(),
+    message: z.z.string().optional(),
+    scope: z.z.array(ZeroKnowledgeProofRequest)
   }),
-  from: zod.z.string(),
-  to: zod.z.string().optional()
+  from: z.z.string(),
+  to: z.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(),
+var ProofData = z.z.object({
+  pi_a: z.z.array(z.z.string()),
+  pi_b: z.z.array(z.z.array(z.z.string())),
+  pi_c: z.z.array(z.z.string()),
+  protocol: z.z.string(),
+  curve: z.z.string().optional()
+});
+var ZeroKnowledgeProofResponse = z.z.object({
+  id: z.z.number(),
+  circuitId: z.z.string(),
+  vp: z.z.any().optional(),
   proof: ProofData,
-  pub_signals: zod.z.array(zod.z.string())
+  pub_signals: z.z.array(z.z.string())
 });
-var AuthorizationResponseMessage = zod.z.object({
-  id: zod.z.string(),
+var AuthorizationResponseMessage = z.z.object({
+  id: z.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)
+  type: z.z.string(),
+  thid: z.z.string().optional(),
+  body: z.z.object({
+    did_doc: z.z.any().optional(),
+    message: z.z.string().optional(),
+    scope: z.z.array(ZeroKnowledgeProofResponse)
   }),
-  from: zod.z.string().optional(),
-  to: zod.z.string().optional()
+  from: z.z.string().optional(),
+  to: z.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()
+var CredentialQrCodeData = z.z.object({
+  id: z.z.string(),
+  typ: z.z.string(),
+  type: z.z.string(),
+  thid: z.z.string(),
+  body: z.z.object({
+    url: z.z.string(),
+    credentials: z.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: z.z.string(),
+  to: z.z.string()
+});
+var AuthQrCodeData = z.z.object({
+  id: z.z.string(),
+  typ: z.z.string(),
+  type: z.z.string(),
+  thid: z.z.string(),
+  body: z.z.object({
+    callbackUrl: z.z.string(),
+    reason: z.z.string(),
+    scope: z.z.unknown()
   }),
-  from: zod.z.string()
+  from: z.z.string()
 });
-var QrCodeLinkWithSchemaType = zod.z.object({
-  qrCodeLink: zod.z.string().nullish(),
-  schemaType: zod.z.string().nullish()
+var QrCodeLinkWithSchemaType = z.z.object({
+  qrCodeLink: z.z.string().nullish(),
+  schemaType: z.z.string().nullish()
 }).describe("Polygon ID Verifiable Credential Offer, to be consumed by the Polygon ID Wallet");
 function parseIden3Message(input) {
   var prefix = "request_uri=";
@@ -181,7 +181,7 @@ function parseIden3Message(input) {
   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));
+  return z.z.string().url().parse(input.substring(startIndex + prefix.length));
 }
 function parseSessionIdFromUrl(urlString) {
   var url = new URL(urlString);
@@ -195,7 +195,7 @@ function parseSessionIdFromUrl(urlString) {
 
 var _operatorDisplayMap;
 var QUERY_LOGIC_OPERATOR = ["AND", "OR"];
-var QueryLogicOperator = zod.z["enum"](QUERY_LOGIC_OPERATOR);
+var QueryLogicOperator = z.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",
@@ -222,42 +222,42 @@ var OPERATORS = ["$noop",
 // has
 "$nhas" // has not
 ];
-var Operator = zod.z["enum"](OPERATORS);
-var ZKPOperator = zod.z["enum"](OPERATORS).exclude(["$lte", "$gte", "$has", "$nhas"]);
+var Operator = z.z["enum"](OPERATORS);
+var ZKPOperator = z.z["enum"](OPERATORS).exclude(["$lte", "$gte", "$has", "$nhas"]);
 var operatorDisplayMap = (_operatorDisplayMap = {}, vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(_operatorDisplayMap, Operator["enum"].$eq, "is"), Operator["enum"].$ne, "is not"), Operator["enum"].$gt, "is greater than"), Operator["enum"].$lt, "is lower than"), Operator["enum"].$gte, "is greater than or equal to"), Operator["enum"].$lte, "is lower than or equal to"), Operator["enum"].$in, "is one of"), Operator["enum"].$nin, "is not one of"), Operator["enum"].$has, "has"), Operator["enum"].$nhas, "has not"), vault_schema._defineProperty(vault_schema._defineProperty(_operatorDisplayMap, Operator["enum"].$noop, "noop"), Operator["enum"].$exists, "exists"));
 var ARRAY_OPERATORS = [Operator["enum"].$has, Operator["enum"].$nhas];
-var ArrayOperator = zod.z["enum"](ARRAY_OPERATORS);
+var ArrayOperator = z.z["enum"](ARRAY_OPERATORS);
 var STRING_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne, Operator["enum"].$in, Operator["enum"].$nin];
-var StringOperator = zod.z["enum"](STRING_OPERATORS);
+var StringOperator = z.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 NumericOperator = z.z["enum"](NUMERIC_OPERATORS);
 var BOOLEAN_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne];
-var BooleanOperator = zod.z["enum"](BOOLEAN_OPERATORS);
+var BooleanOperator = z.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 DateOperator = z.z["enum"](DATE_OPERATORS);
 var SUPPORTED_TYPES = ["string", "integer", "boolean", "number", "array", "date", "decimal"];
-var SupportedType = zod.z["enum"](SUPPORTED_TYPES);
-var SupportedTypes = zod.z.object(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._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), SupportedType["enum"].decimal, NumericOperator));
-var IDInformationTfhe = zod.z.object({
-  type: zod.z.literal("IDInformationTfhe"),
-  requestId: zod.z.coerce.number().nullish(),
-  attribute: zod.z.string(),
-  secondaryAttribute: zod.z.string().nullish(),
-  value: zod.z.string(),
+var SupportedType = z.z["enum"](SUPPORTED_TYPES);
+var SupportedTypes = z.z.object(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._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), SupportedType["enum"].decimal, NumericOperator));
+var IDInformationTfhe = z.z.object({
+  type: z.z.literal("IDInformationTfhe"),
+  requestId: z.z.coerce.number().nullish(),
+  attribute: z.z.string(),
+  secondaryAttribute: z.z.string().nullish(),
+  value: z.z.string(),
   operator: Operator
 });
-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 QueriesOptions = zod.z.array(zod.z.object({
-  title: zod.z.string(),
+var AllCredentialValues = z.z.union([z.z["boolean"](), z.z.string(), z.z.number(), z.z.array(z.z.string()), z.z.array(z.z.number())]);
+var QueriesOptions = z.z.array(z.z.object({
+  title: z.z.string(),
   link: vault_schema.VaultMetadataLinkZodSchema
 }));
-var QueryType = zod.z["enum"](["IDInformation", "IDInformationTfhe", "SelfieImage", "IDImage", "ProofOfResidence", "AMLScreeningsResults",
+var QueryType = z.z["enum"](["IDInformation", "IDInformationTfhe", "SelfieImage", "IDImage", "ProofOfResidence", "AMLScreeningsResults",
 // backwards compatibility
 "ID3",
 // this is for backwards compatibility
@@ -267,20 +267,20 @@ var QueryType = zod.z["enum"](["IDInformation", "IDInformationTfhe", "SelfieImag
 // this is for backwards compatibility
 "IDScanPassport" // this is for backwards compatibility
 ]);
-var QueryConfigTfhe = zod.z.object({
-  type: zod.z.literal("IDInformationTfhe"),
-  requestId: zod.z.coerce.number().nullish(),
-  attribute: zod.z.string(),
-  secondaryAttribute: zod.z.string().nullish(),
-  value: zod.z.string(),
+var QueryConfigTfhe = z.z.object({
+  type: z.z.literal("IDInformationTfhe"),
+  requestId: z.z.coerce.number().nullish(),
+  attribute: z.z.string(),
+  secondaryAttribute: z.z.string().nullish(),
+  value: z.z.string(),
   operator: Operator
 });
-var QueryConfigSimplified = zod.z.object({
+var QueryConfigSimplified = z.z.object({
   queryId: vault_schema.QueryId.describe("Unique ID for the query").optional(),
   // TODO: this should not be optional?
   id: vault_schema.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"),
+  requestId: z.z.coerce.number().nullish().describe("Request ID for ZKPs"),
   attribute: vault_schema.VaultMetadataLinkZodSchema,
   secondaryAttribute: vault_schema.VaultMetadataLinkZodSchema.nullish(),
   value: AllCredentialValues.nullish(),
@@ -289,34 +289,34 @@ var QueryConfigSimplified = zod.z.object({
   // TODO: Make the operator type dynamic based on the attribute type
   datasetColumnId: vault_schema.DatasetColumnId.nullish()
 });
-var QueryGroupConfigSimplified = zod.z.object({
+var QueryGroupConfigSimplified = z.z.object({
   id: vault_schema.QueryGroupId.describe("Unique ID for the query group").optional(),
   operator: QueryLogicOperator,
-  queries: zod.z.array(QueryConfigSimplified)
+  queries: z.z.array(QueryConfigSimplified)
 });
 var RuleResultQueryConfig = QueryConfigSimplified.extend({
-  attribute: zod.z.union([zod.z.string(), vault_schema.VaultMetadataLinkZodSchema]),
+  attribute: z.z.union([z.z.string(), vault_schema.VaultMetadataLinkZodSchema]),
   // string for backwards compatibility
-  secondaryAttribute: zod.z.union([zod.z.string(), vault_schema.VaultMetadataLinkZodSchema]).nullish(),
+  secondaryAttribute: z.z.union([z.z.string(), vault_schema.VaultMetadataLinkZodSchema]).nullish(),
   // string for backwards compatibility
   type: QueryType.nullish() // Backwards compatibility
 });
 var PartialQueryConfigSimplified = QueryConfigSimplified.partial();
-var OLD_ChallengeQuerySchema = zod.z.object({
-  id: zod.z.string().optional(),
+var OLD_ChallengeQuerySchema = z.z.object({
+  id: z.z.string().optional(),
   query: QueryConfigSimplified
 });
 var QueryCredentialTypes = ["IDInformation", "IDInformationTfhe", "IDImage", "SelfieImage", "ProofOfResidence"];
-var QueryCredentialType = zod.z["enum"](QueryCredentialTypes);
-var ChallengeQuerySchema = zod.z.object({
-  id: zod.z.string().optional(),
+var QueryCredentialType = z.z["enum"](QueryCredentialTypes);
+var ChallengeQuerySchema = z.z.object({
+  id: z.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 OLD_ChallengeQueryOperator = z.z["enum"](OLD_CHALLENGE_QUERY_OPERATORS);
 var OperatorMappings = {
   toChallenge: vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._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: vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._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)
@@ -326,7 +326,7 @@ 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);
+var OLD_QueryCredentialType = z.z["enum"](OLD_QueryCredentialTypes);
 /**
  * @deprecated Use vault client and services instead
  *
@@ -394,97 +394,97 @@ function oldCredentialPathToDataLink(path, credentialType) {
 }
 
 var SCENARIO_ACTION_TYPES = ["SET_CUSTOMER_RISK_LEVEL", "SET_CUSTOMER_STATUS", "SET_ALERT_RISK_LEVEL", "SET_TRANSACTION_RISK_LEVEL", "SET_TRANSACTION_STATUS", "ASSIGN_COMPLIANCE_OFFICER", "CREATE_ALERT", "ASSIGN_TAG", "BLOCK_ON_CHAIN_TRANSACTION"];
-var ActionType = zod.z["enum"](SCENARIO_ACTION_TYPES);
+var ActionType = z.z["enum"](SCENARIO_ACTION_TYPES);
 var ACTION_TRIGGERS = ["ON_TRUE", "ON_FALSE", "ALWAYS"];
-var ActionTrigger = zod.z["enum"](ACTION_TRIGGERS);
+var ActionTrigger = z.z["enum"](ACTION_TRIGGERS);
 var ACTION_STATUSES = ["ENABLED", "DISABLED"];
-var ActionStatus = zod.z["enum"](ACTION_STATUSES);
-var ActionValue = zod.z.string();
+var ActionStatus = z.z["enum"](ACTION_STATUSES);
+var ActionValue = z.z.string();
 var ScenarioTypes = ["PrivacyPreservingMonitoring", "IndividualMonitoring", "TransactionMonitoring", "TFHE",
 // TODO integrate TFHE verification
 "BlockchainPolicies"];
-var ScenarioType = zod.z["enum"](ScenarioTypes);
+var ScenarioType = z.z["enum"](ScenarioTypes);
 var ScenarioModes = ["INTERNAL", "EXTERNAL"];
-var ScenarioMode = zod.z["enum"](ScenarioModes);
+var ScenarioMode = z.z["enum"](ScenarioModes);
 var ScenarioStatuses = ["enabled", "disabled"];
-var ScenarioStatus = zod.z["enum"](ScenarioStatuses);
-var ScenarioSchema = zod.z.object({
-  title: zod.z.string(),
-  link: zod.z.object({
-    version: zod.z.string(),
-    schema: zod.z.string(),
-    path: zod.z.string()
+var ScenarioStatus = z.z["enum"](ScenarioStatuses);
+var ScenarioSchema = z.z.object({
+  title: z.z.string(),
+  link: z.z.object({
+    version: z.z.string(),
+    schema: z.z.string(),
+    path: z.z.string()
   }),
-  status: zod.z["enum"]([ScenarioStatus.Enum.enabled, ScenarioStatus.Enum.disabled]).optional()
+  status: z.z["enum"]([ScenarioStatus.Enum.enabled, ScenarioStatus.Enum.disabled]).optional()
 });
 var BackwardsCompatibleScenarioTypes = ["PrivacyPreservingMonitoring", "IndividualMonitoring", "TransactionMonitoring", "TFHE", "OffChainZKP",
 // Backwards compatible
 "ChallengeQuery",
 // Backwards compatible
 "BlockchainPolicies"];
-var BackwardsCompatibleScenarioType = zod.z["enum"](BackwardsCompatibleScenarioTypes);
-var BaseQueryResponse = zod.z.object({
-  result: zod.z.object({
-    is_valid: zod.z["boolean"](),
-    reasons: zod.z.array(zod.z.string())
+var BackwardsCompatibleScenarioType = z.z["enum"](BackwardsCompatibleScenarioTypes);
+var BaseQueryResponse = z.z.object({
+  result: z.z.object({
+    is_valid: z.z["boolean"](),
+    reasons: z.z.array(z.z.string())
   })
 });
 var OffChainZKPRuleResult = BaseQueryResponse.extend({
-  result: zod.z.object({
-    is_valid: zod.z["boolean"](),
+  result: z.z.object({
+    is_valid: z.z["boolean"](),
     query: QueryConfigSimplified,
-    reasons: zod.z.array(zod.z.string())
+    reasons: z.z.array(z.z.string())
   })
 });
 var ExecuteQueryResponse = BaseQueryResponse.extend({
   executionId: vault_schema.UuidString
 });
-var RuleEngineResponse = zod.z.object({
+var RuleEngineResponse = z.z.object({
   objectType: BackwardsCompatibleScenarioType,
-  objectId: zod.z.string().describe("Object id in the cms (challengeQueryid, offChainZKPid)"),
-  name: zod.z.string(),
+  objectId: z.z.string().describe("Object id in the cms (challengeQueryid, offChainZKPid)"),
+  name: z.z.string(),
   address: vault_schema.BlockchainAddress.nullish(),
   result: ExecuteQueryResponse,
   executionId: vault_schema.UuidString,
-  scenarioId: zod.z.string()
+  scenarioId: z.z.string()
 });
-var ScenarioExecutionResponse = zod.z.array(RuleEngineResponse);
+var ScenarioExecutionResponse = z.z.array(RuleEngineResponse);
 var RuleResultStatuses = ["valid", "not-valid", "skipped", "error", "unknown"];
-var RuleResultStatus = zod.z["enum"](RuleResultStatuses);
+var RuleResultStatus = z.z["enum"](RuleResultStatuses);
 var RuleResultStatusLabels = vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty({}, RuleResultStatus.Enum.valid, "Valid"), RuleResultStatus.Enum["not-valid"], "Not Valid"), RuleResultStatus.Enum.skipped, "Skipped"), RuleResultStatus.Enum.error, "Error"), RuleResultStatus.Enum.unknown, "Unknown");
-var SdkVerificationOutput = zod.z.object({
-  customerId: zod.z.string().optional(),
+var SdkVerificationOutput = z.z.object({
+  customerId: z.z.string().optional(),
   // for v1
-  scenarioExecutionId: zod.z.string().optional(),
+  scenarioExecutionId: z.z.string().optional(),
   // for v1
   status: RuleResultStatus.optional(),
   // for v1
-  results: zod.z.array(ScenarioExecutionResponse).optional() // for v1,
+  results: z.z.array(ScenarioExecutionResponse).optional() // for v1,
 });
 var VerificationSessionStatuses = ["IN_PROGRESS", "COMPLETED", "NOT_STARTED"];
-var VerificationSessionStatus = zod.z["enum"](VerificationSessionStatuses);
-var VerificationOutput = zod.z.object({
+var VerificationSessionStatus = z.z["enum"](VerificationSessionStatuses);
+var VerificationOutput = z.z.object({
   id: vault_schema.UuidString.nullable(),
   verificationResult: SdkVerificationOutput.nullable(),
   status: VerificationSessionStatus
 });
-var Action = zod.z.object({
+var Action = z.z.object({
   type: ActionType,
   trigger: ActionTrigger,
   status: ActionStatus,
   value: ActionValue
 });
-var SimplifiedScenario = zod.z.object({
+var SimplifiedScenario = z.z.object({
   id: vault_schema.ScenarioId,
-  name: zod.z.string(),
-  description: zod.z.string().nullish(),
-  queries: zod.z.array(QueryConfigSimplified),
-  queryGroups: zod.z.array(QueryGroupConfigSimplified),
-  actions: zod.z.array(Action),
+  name: z.z.string(),
+  description: z.z.string().nullish(),
+  queries: z.z.array(QueryConfigSimplified),
+  queryGroups: z.z.array(QueryGroupConfigSimplified),
+  actions: z.z.array(Action),
   type: ScenarioType,
   mode: ScenarioMode,
   workspaceId: vault_schema.WorkspaceId,
-  vcsIncluded: zod.z.array(CredentialType).nullish()
+  vcsIncluded: z.z.array(CredentialType).nullish()
 });
 
 // creating this because SmartContractDeployment has an issue with EvmAddress
@@ -494,7 +494,7 @@ var AbbreviatedWorkflowScenario = SimplifiedScenario.omit({
   vcsIncluded: true,
   queries: true
 }).extend({
-  queries: zod.z.array(QueryConfigSimplified)
+  queries: z.z.array(QueryConfigSimplified)
 });
 var TemplateScenario = SimplifiedScenario.omit({
   workspaceId: true
@@ -502,478 +502,478 @@ var TemplateScenario = SimplifiedScenario.omit({
 var CreateTemplateScenario = TemplateScenario.omit({
   id: true
 }).extend({
-  entityType: zod.z["enum"](["individual", "company", "transaction"]).optional()
+  entityType: z.z["enum"](["individual", "company", "transaction"]).optional()
 });
 
-var ScenarioAuthorizationData = zod.z.object({
+var ScenarioAuthorizationData = z.z.object({
   executionId: vault_schema.UuidString,
   sessionId: vault_schema.UuidString,
-  projectId: zod.z.string(),
+  projectId: z.z.string(),
   address: vault_schema.BlockchainAddress.nullish(),
-  status: zod.z["enum"](["pending", "authorised", "unauthorised"]),
-  scenarioId: zod.z.string(),
-  scenarioName: zod.z.string(),
+  status: z.z["enum"](["pending", "authorised", "unauthorised"]),
+  scenarioId: z.z.string(),
+  scenarioName: z.z.string(),
   requestMessage: AuthorizationRequestMessage,
   responseMessage: AuthorizationResponseMessage.nullish(),
-  verificationError: zod.z.string().nullish(),
+  verificationError: z.z.string().nullish(),
   query: QueryConfigSimplified.array(),
   workflowSessionId: vault_schema.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(),
+var CloseScreenNotification = z.z.object({
+  type: z.z.literal("closeScreen"),
+  identifier: z.z.string(),
+  data: z.z.undefined()
+});
+var KycCompletionData = z.z.array(VerifiableCredential);
+var KycCompletionNotification = z.z.object({
+  type: z.z.literal("kycCompletion"),
+  identifier: z.z.string(),
   data: KycCompletionData
 });
-var RuleEngineScenarioExecutionData = zod.z.object({
-  type: zod.z.literal("RuleEngineScenarioExecution"),
+var RuleEngineScenarioExecutionData = z.z.object({
+  type: z.z.literal("RuleEngineScenarioExecution"),
   data: SdkVerificationResponseSchema
 });
-var OffChainScenarioExecutionData = zod.z.object({
-  type: zod.z.literal("OffChainScenarioExecution"),
-  data: zod.z.array(ScenarioAuthorizationData)
+var OffChainScenarioExecutionData = z.z.object({
+  type: z.z.literal("OffChainScenarioExecution"),
+  data: z.z.array(ScenarioAuthorizationData)
 });
-var OnChainScenarioExecutionData = zod.z.object({
-  type: zod.z.literal("OnChainScenarioExecution"),
-  data: zod.z.any()
+var OnChainScenarioExecutionData = z.z.object({
+  type: z.z.literal("OnChainScenarioExecution"),
+  data: z.z.any()
 });
-var ScenarioExecutionData = zod.z.union([RuleEngineScenarioExecutionData, OffChainScenarioExecutionData, OnChainScenarioExecutionData]);
-var ScenarioExecutionNotification = zod.z.object({
-  type: zod.z.literal("scenarioExecution"),
-  identifier: zod.z.string(),
+var ScenarioExecutionData = z.z.union([RuleEngineScenarioExecutionData, OffChainScenarioExecutionData, OnChainScenarioExecutionData]);
+var ScenarioExecutionNotification = z.z.object({
+  type: z.z.literal("scenarioExecution"),
+  identifier: z.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 IsVerifiedNotification = z.z.object({
+  type: z.z.literal("isVerifiedNotification"),
+  identifier: z.z.string(),
+  isVerified: z.z["boolean"]()
+});
+var PolygonIdInitialized = z.z.object({
+  type: z.z.literal("polygonIdInitialized"),
+  identifier: z.z.string(),
+  data: z.z.string()
+});
+var OcvSdkInitialized = z.z.object({
+  type: z.z.literal("ocvSdkInitialized"),
+  identifier: z.z.string()
+});
+var StartCompletedNotification = z.z.object({
+  type: z.z.literal("startCompletedNotification"),
+  identifier: z.z.string()
+});
+var IdentityNotificationMessage = z.z.union([CloseScreenNotification, PolygonIdInitialized, OcvSdkInitialized, StartCompletedNotification, KycCompletionNotification, ScenarioExecutionNotification, IsVerifiedNotification]);
+var InitialDataRequest = z.z.object({
+  type: z.z.literal("initialDataRequest"),
+  identifier: z.z.string()
+});
+var SignatureRequest = z.z.object({
+  type: z.z.literal("signatureRequest"),
+  identifier: z.z.string(),
+  data: z.z.object({
+    message: z.z.string()
   })
 });
-var TransactionData = zod.z.object({
+var TransactionData = z.z.object({
   accountAddress: vault_schema.BlockchainAddress,
   to: vault_schema.BlockchainAddress,
   data: vault_schema.String0x,
-  value: zod.z.string().optional()
+  value: z.z.string().optional()
 });
-var SendTransactionRequest = zod.z.object({
-  type: zod.z.literal("sendTransactionRequest"),
-  identifier: zod.z.string(),
+var SendTransactionRequest = z.z.object({
+  type: z.z.literal("sendTransactionRequest"),
+  identifier: z.z.string(),
   data: TransactionData
 });
-var IdentityRequestMessage = zod.z.union([InitialDataRequest, SignatureRequest, SendTransactionRequest]);
+var IdentityRequestMessage = z.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"),
+var AvailableFlow = z.z["enum"](AVAILABLE_FLOWS);
+var DataAvailableOnStart = z.z.object({
+  identifier: z.z.string().optional(),
+  flow: z.z["enum"](AVAILABLE_FLOWS).optional(),
+  accessToken: z.z.string(),
+  signingMessage: z.z.string(),
+  signature: z.z.string()
+});
+var InitialDataResponse = z.z.object({
+  type: z.z.literal("onStartKyc"),
   data: DataAvailableOnStart
 });
-var SignatureResponse = zod.z.object({
-  type: zod.z.literal("signature"),
+var SignatureResponse = z.z.object({
+  type: z.z.literal("signature"),
   data: vault_schema.BlockchainSignature
 });
-var TransactionResponse = zod.z.object({
-  type: zod.z.literal("transactionResponse"),
-  data: zod.z.object({
+var TransactionResponse = z.z.object({
+  type: z.z.literal("transactionResponse"),
+  data: z.z.object({
     txHash: vault_schema.TxHash
   })
 });
-var HostResponseMessage = zod.z.union([InitialDataResponse, SignatureResponse, TransactionResponse]);
+var HostResponseMessage = z.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()
+var ComplianceImplementationStepsInput = z.z.object({
+  identityChecks: z.z["boolean"]().nullish(),
+  configureIdentity: z.z["boolean"]().nullish(),
+  deployIdentity: z.z["boolean"]().nullish(),
+  monitorIdentity: z.z["boolean"]().nullish()
 });
 
 /////////////
 // EIP-155 //
 /////////////
 
-var TxAuthInput = zod.z.object({
+var TxAuthInput = z.z.object({
   workflowId: vault_schema.WorkflowId.optional(),
   chainId: vault_schema.EvmChainId,
-  contractAbi: zod.z.array(zod.z.record(zod.z.unknown())),
+  contractAbi: z.z.array(z.z.record(z.z.unknown())),
   contractAddress: vault_schema.EvmAddress,
-  functionName: zod.z.string(),
-  args: zod.z.array(zod.z.unknown()),
+  functionName: z.z.string(),
+  args: z.z.array(z.z.unknown()),
   userAddress: vault_schema.EvmAddress,
-  blockExpiration: zod.z.number()["int"]().optional(),
-  nonce: zod.z.number()["int"]().optional()
+  blockExpiration: z.z.number()["int"]().optional(),
+  nonce: z.z.number()["int"]().optional()
 });
 // the api endpoint can source the userAddress from the session if it's not provided
 var ApiTxAuthInput = TxAuthInput.extend({
   userAddress: vault_schema.EvmAddress.optional()
 });
-var TxSignatureResponse = zod.z.object({
+var TxSignatureResponse = z.z.object({
   signature: vault_schema.EIP155Signature,
-  blockExpiration: zod.z.number()
+  blockExpiration: z.z.number()
 });
-var GetTxAuthDataSignatureSuccessResponse = zod.z.object({
-  isAuthorized: zod.z.literal(true),
+var GetTxAuthDataSignatureSuccessResponse = z.z.object({
+  isAuthorized: z.z.literal(true),
   signature: vault_schema.EIP155Signature,
-  payload: zod.z.string(),
-  blockExpiration: zod.z.number()
+  payload: z.z.string(),
+  blockExpiration: z.z.number()
 });
-var GetTxAuthDataSignatureFailureResponse = zod.z.object({
-  isAuthorized: zod.z.literal(false),
-  errorMessage: zod.z.string()
+var GetTxAuthDataSignatureFailureResponse = z.z.object({
+  isAuthorized: z.z.literal(false),
+  errorMessage: z.z.string()
 });
-var GetTxAuthDataSignatureResponse = zod.z.union([GetTxAuthDataSignatureSuccessResponse, GetTxAuthDataSignatureFailureResponse]);
+var GetTxAuthDataSignatureResponse = z.z.union([GetTxAuthDataSignatureSuccessResponse, GetTxAuthDataSignatureFailureResponse]);
 /////////////
 // Tezos   //
 /////////////
 
-var TezosTxAuthInput = zod.z.object({
+var TezosTxAuthInput = z.z.object({
   workflowId: vault_schema.WorkflowId.optional(),
   chainID: vault_schema.TezosChainId,
   contractAddress: vault_schema.TezosContractAddress,
   functionName: vault_schema.TezosEntrypointName,
-  args: zod.z.string(),
+  args: z.z.string(),
   userAddress: vault_schema.TezosImplicitAddress,
-  blockExpiration: zod.z.number()["int"]().optional(),
-  nonce: zod.z.number()["int"]().optional()
+  blockExpiration: z.z.number()["int"]().optional(),
+  nonce: z.z.number()["int"]().optional()
 });
 // the api endpoint can source the userAddress from the session if it's not provided
 var ApiTezosTxAuthInput = TezosTxAuthInput.extend({
   userAddress: vault_schema.TezosImplicitAddress.optional()
 });
-var TezosTxSignatureResponse = zod.z.object({
+var TezosTxSignatureResponse = z.z.object({
   signature: vault_schema.EdSignature,
-  blockExpiration: zod.z.number()
+  blockExpiration: z.z.number()
 });
-var GetTezosTxAuthDataSignatureResponse = zod.z.union([zod.z.object({
-  isAuthorized: zod.z.literal(true),
+var GetTezosTxAuthDataSignatureResponse = z.z.union([z.z.object({
+  isAuthorized: z.z.literal(true),
   signature: vault_schema.EdSignature,
-  blockExpiration: zod.z.number()
-}), zod.z.object({
-  isAuthorized: zod.z.literal(false),
-  errorMessage: zod.z.any()
+  blockExpiration: z.z.number()
+}), z.z.object({
+  isAuthorized: z.z.literal(false),
+  errorMessage: z.z.any()
 })]);
 /////////////
 // General //
 /////////////
 
-var ExtendedTxAuthInput = TxAuthInput.and(zod.z.object({
-  namespace: zod.z.literal(vault_schema.BlockchainNamespace.Enum.eip155),
+var ExtendedTxAuthInput = TxAuthInput.and(z.z.object({
+  namespace: z.z.literal(vault_schema.BlockchainNamespace.Enum.eip155),
   userAddress: vault_schema.EvmAddress
 }));
-var ExtendedTezosTxAuthInput = TezosTxAuthInput.and(zod.z.object({
-  namespace: zod.z.literal(vault_schema.BlockchainNamespace.Enum.tezos),
+var ExtendedTezosTxAuthInput = TezosTxAuthInput.and(z.z.object({
+  namespace: z.z.literal(vault_schema.BlockchainNamespace.Enum.tezos),
   userAddress: vault_schema.TezosImplicitAddress
 }));
-var ExtendedTxAuthDataSignatureResponse = GetTxAuthDataSignatureResponse.and(zod.z.object({
-  namespace: zod.z.literal(vault_schema.BlockchainNamespace.Enum.eip155),
+var ExtendedTxAuthDataSignatureResponse = GetTxAuthDataSignatureResponse.and(z.z.object({
+  namespace: z.z.literal(vault_schema.BlockchainNamespace.Enum.eip155),
   userAddress: vault_schema.EvmAddress
 }));
-var ExtendedTezosTxAuthDataSignatureResponse = GetTezosTxAuthDataSignatureResponse.and(zod.z.object({
-  namespace: zod.z.literal(vault_schema.BlockchainNamespace.Enum.tezos),
+var ExtendedTezosTxAuthDataSignatureResponse = GetTezosTxAuthDataSignatureResponse.and(z.z.object({
+  namespace: z.z.literal(vault_schema.BlockchainNamespace.Enum.tezos),
   userAddress: vault_schema.TezosImplicitAddress
 }));
-var AnyTxAuthDataSignatureResponse = zod.z.union([ExtendedTxAuthDataSignatureResponse, ExtendedTezosTxAuthDataSignatureResponse]);
+var AnyTxAuthDataSignatureResponse = z.z.union([ExtendedTxAuthDataSignatureResponse, ExtendedTezosTxAuthDataSignatureResponse]);
 /////////////
 // JS SDK  //
 /////////////
 
-var Eip155TxAuthInputJsSdk = ExtendedTxAuthInput.and(zod.z.object({
+var Eip155TxAuthInputJsSdk = ExtendedTxAuthInput.and(z.z.object({
   workflowId: vault_schema.WorkflowId
 }));
-var TezosTxAuthInputJsSdk = ExtendedTezosTxAuthInput.and(zod.z.object({
+var TezosTxAuthInputJsSdk = ExtendedTezosTxAuthInput.and(z.z.object({
   workflowId: vault_schema.WorkflowId
 }));
-var AnyTxAuthInputJsSdk = zod.z.union([Eip155TxAuthInputJsSdk, TezosTxAuthInputJsSdk]);
+var AnyTxAuthInputJsSdk = z.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()
+var SimplifiedCredential = z.z.object({
+  id: z.z.string(),
+  type: z.z.array(z.z.string()),
+  issuanceDate: z.z.string(),
+  journeyId: z.z.string()
 });
 /**
  * GetCredentialsRequest
  */
-var GetCredentialsRequest = zod.z.object({
-  type: zod.z.literal("getCredentials"),
-  data: zod.z.undefined()
+var GetCredentialsRequest = z.z.object({
+  type: z.z.literal("getCredentials"),
+  data: z.z.undefined()
 });
 /**
  * GetCredentialsResponse
  */
-var GetCredentialsResponse = zod.z.object({
-  type: zod.z.literal("polygonIdCredentials"),
-  credentials: zod.z.array(SimplifiedCredential),
-  identifier: zod.z.string()
+var GetCredentialsResponse = z.z.object({
+  type: z.z.literal("polygonIdCredentials"),
+  credentials: z.z.array(SimplifiedCredential),
+  identifier: z.z.string()
 });
 /**
  * PolygonIdRequest
  */
-var PolygonIdRequestData = zod.z.union([zod.z.object({
-  type: zod.z.literal("auth"),
+var PolygonIdRequestData = z.z.union([z.z.object({
+  type: z.z.literal("auth"),
   authRequest: AuthorizationRequestMessage
-}), zod.z.object({
-  type: zod.z.literal("credentialOffer"),
+}), z.z.object({
+  type: z.z.literal("credentialOffer"),
   credentialOfferRequest: QrCodeLinkWithSchemaType
-}), zod.z.object({
-  type: zod.z.literal("zkp"),
+}), z.z.object({
+  type: z.z.literal("zkp"),
   zkpRequest: ZeroKnowledgeProofRequest
 })]);
-var PolygonIdRequest = zod.z.object({
-  type: zod.z.literal("polygonIdRequest"),
+var PolygonIdRequest = z.z.object({
+  type: z.z.literal("polygonIdRequest"),
   data: PolygonIdRequestData
 });
 /**
  * PolygonIdResponse
  */
-var PolygonIdResponseData = zod.z.union([zod.z.object({
-  type: zod.z.literal("auth"),
+var PolygonIdResponseData = z.z.union([z.z.object({
+  type: z.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"),
+}), z.z.object({
+  type: z.z.literal("credentialOffer"),
+  credentialOfferResponse: z.z.array(vault_schema.GenericVerifiableCredentialSchema)
+}), z.z.object({
+  type: z.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()
+}), z.z.object({
+  type: z.z.literal("close"),
+  screen: z.z["enum"](["auth", "credentialOffer", "zkp", "getCredentials"]),
+  closeResponse: z.z.string()
 })]);
-var PolygonIdResponse = zod.z.object({
-  type: zod.z.literal("polygonIdResponse"),
-  identifier: zod.z.string(),
+var PolygonIdResponse = z.z.object({
+  type: z.z.literal("polygonIdResponse"),
+  identifier: z.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()
+var StartFlowRequest = z.z.union([z.z.object({
+  type: z.z.literal("startVerification"),
+  data: z.z.undefined()
+}), z.z.object({
+  type: z.z.literal("startManagement"),
+  data: z.z.undefined()
+}), z.z.object({
+  type: z.z.literal("startKYB"),
+  data: z.z.undefined()
 })]);
 /**
  * IsVerifiedRequest
  */
-var IsVerifiedRequest = zod.z.object({
-  type: zod.z.literal("isVerifiedRequest"),
-  data: zod.z.object({
+var IsVerifiedRequest = z.z.object({
+  type: z.z.literal("isVerifiedRequest"),
+  data: z.z.object({
     userAddress: vault_schema.EvmAddress
   }),
-  identifier: zod.z.string()
+  identifier: z.z.string()
 });
 /**
  * IsVerifiedResponse
  */
-var IsVerifiedResponse = zod.z.object({
-  type: zod.z.literal("isVerifiedResponse"),
-  isVerified: zod.z["boolean"](),
-  identifier: zod.z.string()
+var IsVerifiedResponse = z.z.object({
+  type: z.z.literal("isVerifiedResponse"),
+  isVerified: z.z["boolean"](),
+  identifier: z.z.string()
 });
 /**
  * GetTxAuthSigRequest
  */
-var GetTxAuthSigRequest = zod.z.object({
-  type: zod.z.literal("getTxAuthSigRequest"),
+var GetTxAuthSigRequest = z.z.object({
+  type: z.z.literal("getTxAuthSigRequest"),
   data: ApiTxAuthInput,
-  identifier: zod.z.string()
+  identifier: z.z.string()
 });
 /**
  * GetTxAuthSigResponse
  */
-var GetTxAuthSigResponse = zod.z.object({
-  type: zod.z.literal("getTxAuthSigResponse"),
+var GetTxAuthSigResponse = z.z.object({
+  type: z.z.literal("getTxAuthSigResponse"),
   signatureResponse: GetTxAuthDataSignatureResponse,
-  identifier: zod.z.string()
+  identifier: z.z.string()
 });
 /**
  * GetTxAuthSigRequest Tezos
  */
-var GetTxAuthSigRequestTezos = zod.z.object({
-  type: zod.z.literal("getTxAuthSigRequestTezos"),
+var GetTxAuthSigRequestTezos = z.z.object({
+  type: z.z.literal("getTxAuthSigRequestTezos"),
   data: ApiTezosTxAuthInput,
-  identifier: zod.z.string()
+  identifier: z.z.string()
 });
 /**
  * GetTxAuthSigResponse Tezos
  */
-var GetTxAuthSigResponseTezos = zod.z.object({
-  type: zod.z.literal("getTezosTxAuthSigResponse"),
+var GetTxAuthSigResponseTezos = z.z.object({
+  type: z.z.literal("getTezosTxAuthSigResponse"),
   signatureResponse: GetTezosTxAuthDataSignatureResponse,
-  identifier: zod.z.string()
+  identifier: z.z.string()
 });
-var HostRequestMessage = zod.z.union([GetCredentialsRequest, PolygonIdRequest, StartFlowRequest, IsVerifiedRequest, GetTxAuthSigRequest, GetTxAuthSigRequestTezos]);
-var IdentityResponseMessage = zod.z.union([GetCredentialsResponse, PolygonIdResponse, IsVerifiedResponse, GetTxAuthSigResponse, GetTxAuthSigResponseTezos]);
+var HostRequestMessage = z.z.union([GetCredentialsRequest, PolygonIdRequest, StartFlowRequest, IsVerifiedRequest, GetTxAuthSigRequest, GetTxAuthSigRequestTezos]);
+var IdentityResponseMessage = z.z.union([GetCredentialsResponse, PolygonIdResponse, IsVerifiedResponse, GetTxAuthSigResponse, GetTxAuthSigResponseTezos]);
 
 /**
  * Wallet challenge parameters
  */
 
-var GenerateWalletChallengeRequest = zod.z.object({
+var GenerateWalletChallengeRequest = z.z.object({
   address: vault_schema.BlockchainAddress,
   namespace: vault_schema.SupportedBlockchainNamespaceForSignatureAuth,
   blockchainId: vault_schema.BlockchainId.optional(),
-  origin: zod.z.string().url(),
+  origin: z.z.string().url(),
   workflowId: vault_schema.WorkflowId,
   externalCustomerId: vault_schema.ExternalCustomerId.optional(),
   additionalInformation: vault_schema.AdditionalCustomerInformationParams.optional()
 });
-var AuthSession = zod.z.object({
+var AuthSession = z.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(),
+  token: z.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(),
+  expiresAt: z.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: vault_schema.ExternalCustomerId.optional()
 });
-var AuthSessionData = zod.z.object({
+var AuthSessionData = z.z.object({
   /**
    * The unique identifier of the user
    */
-  identityId: zod.z.string(),
+  identityId: z.z.string(),
   /**
    * The unique identifier of the user's session
    */
-  customerId: zod.z.string(),
+  customerId: z.z.string(),
   /**
    * The identifier passed by the user platform
    */
   externalCustomerId: vault_schema.ExternalCustomerId.optional()
 });
-var ChallengeResponse = zod.z.object({
-  challenge: zod.z.string()
+var ChallengeResponse = z.z.object({
+  challenge: z.z.string()
 });
 ////////////////
 // SDK messages
 ////////////////
 
-var AppConfigRequest = zod.z.object({
-  type: zod.z.literal("appConfig"),
-  data: zod.z.object({
+var AppConfigRequest = z.z.object({
+  type: z.z.literal("appConfig"),
+  data: z.z.object({
     authSession: AuthSession
   })
 });
-var WalletUpdated = zod.z.object({
-  type: zod.z.literal("walletUpdated"),
-  data: zod.z.object({
+var WalletUpdated = z.z.object({
+  type: z.z.literal("walletUpdated"),
+  data: z.z.object({
     address: vault_schema.BlockchainAddress
   })
 });
-var WalletSignResponse = zod.z.object({
-  type: zod.z.literal("walletSignResponse"),
-  data: zod.z.object({
-    message: zod.z.string(),
+var WalletSignResponse = z.z.object({
+  type: z.z.literal("walletSignResponse"),
+  data: z.z.object({
+    message: z.z.string(),
     signature: vault_schema.BlockchainSignature
   })
 });
-var TxAuthDataSignatureGatingRequest = zod.z.object({
-  type: zod.z.literal("txAuthDataSignatureGatingRequest"),
-  data: zod.z.object({
+var TxAuthDataSignatureGatingRequest = z.z.object({
+  type: z.z.literal("txAuthDataSignatureGatingRequest"),
+  data: z.z.object({
     input: AnyTxAuthInputJsSdk
   })
 });
-var GetCustomerStatusRequest = zod.z.object({
-  type: zod.z.literal("getCustomerStatusRequest")
+var GetCustomerStatusRequest = z.z.object({
+  type: z.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()
+var IdentitySdkMessage = z.z.union([AppConfigRequest, WalletUpdated, WalletSignResponse, TransactionResponse, TxAuthDataSignatureGatingRequest, GetCustomerStatusRequest]);
+var IdentitySdkMessageWithIdentifier = z.z.intersection(IdentitySdkMessage, z.z.object({
+  identifier: z.z.string()
 }));
 ////////////////
 // App messages
 ////////////////
 
-var IdentityAppLoadedNotification = zod.z.object({
-  type: zod.z.literal("identityAppLoaded")
+var IdentityAppLoadedNotification = z.z.object({
+  type: z.z.literal("identityAppLoaded")
 });
-var IdentityAppConfiguredNotification = zod.z.object({
-  type: zod.z.literal("identityAppConfigured"),
-  data: zod.z.object({
+var IdentityAppConfiguredNotification = z.z.object({
+  type: z.z.literal("identityAppConfigured"),
+  data: z.z.object({
     auth: AuthSession
   })
 });
-var AuthenticationExpiredNotification = zod.z.object({
-  type: zod.z.literal("authenticationExpired"),
-  data: zod.z.object({
+var AuthenticationExpiredNotification = z.z.object({
+  type: z.z.literal("authenticationExpired"),
+  data: z.z.object({
     authSession: AuthSession
   })
 });
-var WalletSignRequest = zod.z.object({
-  type: zod.z.literal("walletSignRequest"),
-  data: zod.z.object({
-    message: zod.z.string()
+var WalletSignRequest = z.z.object({
+  type: z.z.literal("walletSignRequest"),
+  data: z.z.object({
+    message: z.z.string()
   })
 });
-var TxAuthDataSignatureResponse = zod.z.object({
-  type: zod.z.literal("txAuthDataSignatureResponse"),
+var TxAuthDataSignatureResponse = z.z.object({
+  type: z.z.literal("txAuthDataSignatureResponse"),
   data: AnyTxAuthDataSignatureResponse
 });
-var TxAuthDataSignatureGatingError = zod.z.object({
-  type: zod.z.literal("txAuthDataSignatureGatingError"),
-  data: zod.z.object({
-    error: zod.z.string()
+var TxAuthDataSignatureGatingError = z.z.object({
+  type: z.z.literal("txAuthDataSignatureGatingError"),
+  data: z.z.object({
+    error: z.z.string()
   })
 });
-var GetCustomerStatusResponse = zod.z.object({
-  type: zod.z.literal("getCustomerStatusResponse"),
-  data: zod.z.union([vault_schema.CustomerStatus, zod.z["null"]()])
+var GetCustomerStatusResponse = z.z.object({
+  type: z.z.literal("getCustomerStatusResponse"),
+  data: z.z.union([vault_schema.CustomerStatus, z.z["null"]()])
 });
-var IdentityAppMessage = zod.z.union([IdentityAppLoadedNotification, IdentityAppConfiguredNotification, AuthenticationExpiredNotification, WalletSignRequest, TxAuthDataSignatureResponse, TxAuthDataSignatureGatingError, GetCustomerStatusResponse,
+var IdentityAppMessage = z.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
@@ -986,76 +986,76 @@ KycCompletionNotification.omit({
 }), SendTransactionRequest.omit({
   identifier: true
 })]);
-var IdentityWallet = zod.z.object({
+var IdentityWallet = z.z.object({
   address: vault_schema.BlockchainAddress,
   namespace: vault_schema.SupportedBlockchainNamespaceForSignatureAuth
 });
 
-var ZKPRequest = zod.z.object({
-  id: zod.z.number(),
-  circuitId: zod.z["enum"](["credentialAtomicQuerySigV2", "credentialAtomicQuerySigV2OnChain"]),
-  optional: zod.z["boolean"]().optional(),
+var ZKPRequest = z.z.object({
+  id: z.z.number(),
+  circuitId: z.z["enum"](["credentialAtomicQuerySigV2", "credentialAtomicQuerySigV2OnChain"]),
+  optional: z.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 ZKPRequestFromZKVerifier = z.z.object({
+  id: z.z.number(),
+  circuitId: z.z.string(),
+  optional: z.z["boolean"]().optional(),
+  query: z.z.record(z.z.unknown())
 });
-var PrivacyPreservingMonitoring = zod.z.object({
-  requestingAuthorizationMessage: zod.z.string().nullish(),
-  zkpRequest: zod.z.array(ZKPRequest).nullish()
+var PrivacyPreservingMonitoring = z.z.object({
+  requestingAuthorizationMessage: z.z.string().nullish(),
+  zkpRequest: z.z.array(ZKPRequest).nullish()
 });
-var CreateAuthRequestProps = zod.z.object({
-  hostUrl: zod.z.string().url(),
+var CreateAuthRequestProps = z.z.object({
+  hostUrl: z.z.string().url(),
   sessionId: vault_schema.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({
+  audience: z.z.string().describe("DID of the verifier"),
+  callbackURL: z.z.string().describe("URL to which the auth response of the client callback will be sent"),
+  query: z.z.array(QueryConfigSimplified),
+  onChainVerification: z.z["boolean"]().optional(),
+  id: z.z.string().uuid(),
+  thid: z.z.string().uuid(),
+  message: z.z.string().describe("Message shown to the user")
+});
+var AllScenarioExecutionAuthorizationData = z.z.object({
   executionId: vault_schema.UuidString,
-  projectId: zod.z.string(),
-  scenarioExecutionIds: zod.z.array(vault_schema.UuidString)
+  projectId: z.z.string(),
+  scenarioExecutionIds: z.z.array(vault_schema.UuidString)
 });
 var SCENARIO_AUTHORIZATION_STATUSES = ["pending", "authorised", "unauthorised"];
-var ScenarioAuthorizationStatus = zod.z["enum"](SCENARIO_AUTHORIZATION_STATUSES);
+var ScenarioAuthorizationStatus = z.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({
+var HostMessage = z.z.union([HostRequestMessage, HostResponseMessage]);
+var IdentityMessage = z.z.union([IdentityNotificationMessage, IdentityRequestMessage, IdentityResponseMessage]);
+var RequiredDataRowSchema = z.z.object({
   type: CredentialType,
-  requiredAttributes: zod.z.array(zod.z.object({
-    attribute: zod.z.string(),
-    value: zod.z.string(),
-    operator: zod.z.string()
+  requiredAttributes: z.z.array(z.z.object({
+    attribute: z.z.string(),
+    value: z.z.string(),
+    operator: z.z.string()
   }))
 });
-var RequiredVerificationData = zod.z.object({
-  ruleEngine: zod.z.object({
-    requiredData: zod.z.array(RequiredDataRowSchema)
+var RequiredVerificationData = z.z.object({
+  ruleEngine: z.z.object({
+    requiredData: z.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)
+  PrivacyPreservingMonitoring: z.z.object({
+    requiredData: z.z.array(RequiredDataRowSchema),
+    verifications: z.z.array(z.z.object({
+      scenarioVerifierAddress: z.z.string(),
+      conditions: z.z.array(ZKPRequest)
     }))
   }),
-  tfhe: zod.z.object({
-    requiredData: zod.z.array(RequiredDataRowSchema),
-    verifications: zod.z.array(QueryConfigSimplified)
+  tfhe: z.z.object({
+    requiredData: z.z.array(RequiredDataRowSchema),
+    verifications: z.z.array(QueryConfigSimplified)
   })
 });
 
-var WalletSignatureResponse = zod.z.object({
+var WalletSignatureResponse = z.z.object({
   // the message we requested the user to sign
-  message: zod.z.string(),
+  message: z.z.string(),
   // the signature of the message
   signature: vault_schema.BlockchainSignature,
   // some wallets like Cardano Nami generate a new address for each transaction or signature
@@ -1064,12 +1064,12 @@ var WalletSignatureResponse = zod.z.object({
   // 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(),
+  signerPublicKeyType: z.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()
+  signedMessage: z.z.string()
 });
-var VerifyWalletChallengeRequest = WalletSignatureResponse.and(zod.z.object({
+var VerifyWalletChallengeRequest = WalletSignatureResponse.and(z.z.object({
   address: vault_schema.BlockchainAddress,
   namespace: vault_schema.SupportedBlockchainNamespaceForSignatureAuth,
   blockchainId: vault_schema.BlockchainId.optional()