@nexeraid/identity-schemas 2.66.0-dev → 2.67.0-dev

package/dist/identity-api.schema-095969b9.cjs.prod.cjs

@@ -0,0 +1,1308 @@
+'use strict';
+
+var zod = require('zod');
+var vault_schema = require('./vault.schema-cc989cdf.cjs.prod.cjs');
+
+var CredentialSchemas = {
+  ProofOfResidence: vault_schema.ProofOfResidenceCredentialSubjectSchema,
+  SelfieImage: vault_schema.SelfieImageCredentialSubjectSchema,
+  IDImage: vault_schema.IDImageCredentialSubjectSchema,
+  IDInformation: vault_schema.IDInformationCredentialSubjectSchema,
+  IDInformationTfhe: vault_schema.IDInformationTfheCredentialSubjectSchema,
+  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"
+}, {
+  value: "IDInformationTfhe",
+  label: "ID information for TFHE"
+}];
+var CredentialTypes = ["AMLScreeningsResults", "ProofOfResidence", "SelfieImage", "IDImage", "IDInformation", "IDInformationTfhe", "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 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 = 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"].$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", "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(),
+  value: zod.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(),
+  link: vault_schema.VaultMetadataLinkZodSchema
+}));
+var QueryType = zod.z["enum"](["IDInformation", "IDInformationTfhe", "SelfieImage", "IDImage", "ProofOfResidence", "AMLScreeningsResults",
+// backwards compatibility
+"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 QueryConfigTfhe = zod.z.object({
+  type: zod.z.literal("IDInformationTfhe"),
+  requestId: zod.z.coerce.number().nullish(),
+  attribute: zod.z.string(),
+  value: zod.z.string(),
+  operator: Operator
+});
+var QueryConfigSimplified = zod.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"),
+  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 RuleResultQueryConfig = QueryConfigSimplified.extend({
+  attribute: zod.z.union([zod.z.string(), vault_schema.VaultMetadataLinkZodSchema]),
+  // string for backwards compatibility
+  type: QueryType.nullish() // Backwards compatibility
+});
+var PartialQueryConfigSimplified = QueryConfigSimplified.partial();
+var OLD_ChallengeQuerySchema = zod.z.object({
+  id: zod.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(),
+  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: 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)
+};
+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 ScenarioTypes = ["PrivacyPreservingMonitoring", "IndividualMonitoring", "TransactionMonitoring", "TFHE" // TODO integrate TFHE verification
+];
+var ScenarioType = zod.z["enum"](ScenarioTypes);
+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()
+  }),
+  status: zod.z["enum"]([ScenarioStatus.Enum.enabled, ScenarioStatus.Enum.disabled]).optional()
+});
+var BackwardsCompatibleScenarioTypes = ["PrivacyPreservingMonitoring", "IndividualMonitoring", "TransactionMonitoring", "TFHE", "OffChainZKP",
+// Backwards compatible
+"ChallengeQuery" // Backwards compatible
+];
+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 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: vault_schema.UuidString
+});
+var RuleEngineResponse = zod.z.object({
+  objectType: BackwardsCompatibleScenarioType,
+  objectId: zod.z.string().describe("Object id in the cms (challengeQueryid, offChainZKPid)"),
+  name: zod.z.string(),
+  address: vault_schema.BlockchainAddress.nullish(),
+  result: ExecuteQueryResponse,
+  executionId: vault_schema.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 = vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._defineProperty(vault_schema._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: vault_schema.UuidString.nullable(),
+  verificationResult: SdkVerificationOutput.nullable(),
+  status: VerificationSessionStatus
+});
+var Scenario = zod.z.object({
+  id: vault_schema.ScenarioId,
+  name: zod.z.string(),
+  description: zod.z.string().nullish(),
+  queries: zod.z.array(QueryConfigSimplified),
+  type: ScenarioType,
+  workspaceId: vault_schema.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: vault_schema.UuidString,
+  sessionId: vault_schema.UuidString,
+  projectId: zod.z.string(),
+  address: vault_schema.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: 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(),
+  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: vault_schema.BlockchainAddress,
+  to: vault_schema.BlockchainAddress,
+  data: vault_schema.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: vault_schema.BlockchainSignature
+});
+var TransactionResponse = zod.z.object({
+  type: zod.z.literal("transactionResponse"),
+  data: zod.z.object({
+    txHash: vault_schema.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: vault_schema.WorkflowId.optional(),
+  chainId: vault_schema.EvmChainId,
+  contractAbi: zod.z.array(zod.z.record(zod.z.unknown())),
+  contractAddress: vault_schema.AddressSchema,
+  functionName: zod.z.string(),
+  args: zod.z.array(zod.z.unknown()),
+  userAddress: vault_schema.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: vault_schema.AddressSchema.optional()
+});
+var TxSignatureResponse = zod.z.object({
+  signature: vault_schema.EIP155Signature,
+  blockExpiration: zod.z.number()
+});
+var GetTxAuthDataSignatureResponse = zod.z.union([zod.z.object({
+  isAuthorized: zod.z.literal(true),
+  signature: vault_schema.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: vault_schema.WorkflowId.optional(),
+  chainID: vault_schema.TezosChainId,
+  contractAddress: vault_schema.TezosContractAddress,
+  functionName: vault_schema.TezosEntrypointName,
+  args: zod.z.string(),
+  userAddress: vault_schema.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: vault_schema.TezosImplicitAddress.optional()
+});
+var TezosTxSignatureResponse = zod.z.object({
+  signature: vault_schema.EdSignature,
+  blockExpiration: zod.z.number()
+});
+var GetTezosTxAuthDataSignatureResponse = zod.z.union([zod.z.object({
+  isAuthorized: zod.z.literal(true),
+  signature: vault_schema.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(vault_schema.BlockchainNamespace.Enum.eip155),
+  userAddress: vault_schema.AddressSchema
+}));
+var ExtendedTezosTxAuthInput = TezosTxAuthInput.and(zod.z.object({
+  namespace: zod.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),
+  userAddress: vault_schema.AddressSchema
+}));
+var ExtendedTezosTxAuthDataSignatureResponse = GetTezosTxAuthDataSignatureResponse.and(zod.z.object({
+  namespace: zod.z.literal(vault_schema.BlockchainNamespace.Enum.tezos),
+  userAddress: vault_schema.TezosImplicitAddress
+}));
+var AnyTxAuthDataSignatureResponse = zod.z.union([ExtendedTxAuthDataSignatureResponse, ExtendedTezosTxAuthDataSignatureResponse]);
+/////////////
+// JS SDK  //
+/////////////
+
+var Eip155TxAuthInputJsSdk = ExtendedTxAuthInput.and(zod.z.object({
+  workflowId: vault_schema.WorkflowId
+}));
+var TezosTxAuthInputJsSdk = ExtendedTezosTxAuthInput.and(zod.z.object({
+  workflowId: vault_schema.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: vault_schema.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]);
+
+// Risk Score
+var RiskScoreTypes = ["Low", "Medium", "High", "No risk"];
+var RiskScoreType = zod.z["enum"](RiskScoreTypes);
+// Customer Type
+var CustomerTypes = ["Individual", "Company"];
+var CustomerType = zod.z["enum"](CustomerTypes);
+// KYC Onboarding Level
+var KycOnboardingLevels = ["Sign-up", "AML screening", "KYC", "Questionaire", "Onboarded"];
+var KycOnboardingLevel = zod.z["enum"](KycOnboardingLevels);
+// KYB Onboarding Level
+var KybOnboardingLevels = ["Onboarding", "KYB", "Onboarded"];
+var KybOnboardingLevel = zod.z["enum"](KybOnboardingLevels);
+var CustomerOnboardingLevels = [].concat(KycOnboardingLevels, KybOnboardingLevels);
+var CustomerOnboardingLevel = zod.z["enum"](CustomerOnboardingLevels);
+// Customer Status
+var CustomerStatuses = ["Active", "Rejected", "Dormant", "To be reviewed", "Failed", "Escalated", "Terminated", "No status"];
+var CustomerStatus = zod.z["enum"](CustomerStatuses);
+var BasicCustomerContactInformation = zod.z.object({
+  email: zod.z.string().email(),
+  phone: zod.z.string().min(4),
+  twitter: zod.z.string(),
+  discord: zod.z.string(),
+  telegram: zod.z.string()
+}).partial();
+var CUSTOMERS_CHARTS = ["totalCustomers", "onboarded", "active", "dormant", "rejected", "topCountriesByCustomersCount", "customersRiskLevel", "customersByStatus", "trendOfStatusesOverTime"];
+var CustomersChartType = zod.z["enum"](CUSTOMERS_CHARTS);
+var CUSTOMER_TABLE_COLUMNS = ["selected", "wallets", "type", "country_of_residence", "risk_score", "onboarding_level", "open_alerts_count", "status", "date_onboarded"];
+var CustomerTableColumn = zod.z["enum"](CUSTOMER_TABLE_COLUMNS);
+var CUSTOMER_AUTOMATION_REASONS = {
+  "rule-engine": {
+    fail: "Rules engine verification failed",
+    pass: "Rules engine verification passed"
+  },
+  kyc: {
+    green: {
+      "final": "Passed KYC"
+    },
+    yellow: {
+      retry: "User rejected by the KYC provider with possibility to retry",
+      fail: "User rejected by the KYC provider"
+    },
+    red: {
+      retry: "User rejected by the KYC provider with possibility to retry",
+      fail: "User rejected by the KYC provider"
+    }
+  },
+  kyb: {
+    green: {
+      "final": "Passed KYB"
+    },
+    yellow: {
+      retry: "Company rejected by the KYB provider with possibility to retry",
+      fail: "Company rejected by the KYB provider"
+    },
+    red: {
+      retry: "Company rejected by the KYB provider with possibility to retry",
+      fail: "Company rejected by the KYB provider"
+    },
+    beneficiaryOnToBeReviewState: "One or more beneficiaries are on 'To be reviewed' state"
+  },
+  "aml-screening": {
+    fail: "AML screening hits received during onboarding",
+    ongoingMonitoringFail: "AML screening hits received during ongoing monitoring",
+    pass: "Passed AML screening"
+  },
+  offchain_zkp: {
+    fail: "Offchain ZKP verification failed",
+    pass: "Offchain ZKP verification passed"
+  },
+  tfhe: {
+    fail: "TFHE verification failed",
+    pass: "TFHE verification passed"
+  }
+};
+
+/**
+ * Wallet challenge parameters
+ */
+
+var GenerateWalletChallengeRequest = zod.z.object({
+  address: vault_schema.BlockchainAddress,
+  namespace: vault_schema.SupportedBlockchainNamespaceForSignatureAuth,
+  blockchainId: vault_schema.BlockchainId.optional(),
+  origin: zod.z.string().url(),
+  workflowId: vault_schema.WorkflowId,
+  externalCustomerId: vault_schema.ExternalCustomerId.optional(),
+  additionalInformation: vault_schema.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: vault_schema.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: vault_schema.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: vault_schema.BlockchainAddress
+  })
+});
+var WalletSignResponse = zod.z.object({
+  type: zod.z.literal("walletSignResponse"),
+  data: zod.z.object({
+    message: zod.z.string(),
+    signature: vault_schema.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([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: 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(),
+  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: 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({
+  executionId: vault_schema.UuidString,
+  projectId: zod.z.string(),
+  scenarioExecutionIds: zod.z.array(vault_schema.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)
+    }))
+  }),
+  tfhe: zod.z.object({
+    requiredData: zod.z.array(RequiredDataRowSchema),
+    verifications: zod.z.array(QueryConfigSimplified)
+  })
+});
+
+var WalletSignatureResponse = zod.z.object({
+  // the message we requested the user to sign
+  message: zod.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
+  // this means we have to request the signer's public key to verify the signature
+  signerPublicKey: vault_schema.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: vault_schema.BlockchainAddress,
+  namespace: vault_schema.SupportedBlockchainNamespaceForSignatureAuth,
+  blockchainId: vault_schema.BlockchainId.optional()
+}));
+
+exports.ARRAY_OPERATORS = ARRAY_OPERATORS;
+exports.AUTHORIZATION_REQUEST_MESSAGE_TYPES = AUTHORIZATION_REQUEST_MESSAGE_TYPES;
+exports.AVAILABLE_FLOWS = AVAILABLE_FLOWS;
+exports.AbbreviatedWorkflowScenario = AbbreviatedWorkflowScenario;
+exports.AllCredentialValues = AllCredentialValues;
+exports.AllScenarioExecutionAuthorizationData = AllScenarioExecutionAuthorizationData;
+exports.AnyTxAuthDataSignatureResponse = AnyTxAuthDataSignatureResponse;
+exports.AnyTxAuthInputJsSdk = AnyTxAuthInputJsSdk;
+exports.ApiTezosTxAuthInput = ApiTezosTxAuthInput;
+exports.ApiTxAuthInput = ApiTxAuthInput;
+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.BOOLEAN_OPERATORS = BOOLEAN_OPERATORS;
+exports.BackwardsCompatibleScenarioType = BackwardsCompatibleScenarioType;
+exports.BackwardsCompatibleScenarioTypes = BackwardsCompatibleScenarioTypes;
+exports.BaseQueryResponse = BaseQueryResponse;
+exports.BasicCustomerContactInformation = BasicCustomerContactInformation;
+exports.BooleanOperator = BooleanOperator;
+exports.CIRCUIT_IDS = CIRCUIT_IDS;
+exports.CUSTOMERS_CHARTS = CUSTOMERS_CHARTS;
+exports.CUSTOMER_AUTOMATION_REASONS = CUSTOMER_AUTOMATION_REASONS;
+exports.CUSTOMER_TABLE_COLUMNS = CUSTOMER_TABLE_COLUMNS;
+exports.ChallengeQuerySchema = ChallengeQuerySchema;
+exports.ChallengeResponse = ChallengeResponse;
+exports.CircuitId = CircuitId;
+exports.CloseScreenNotification = CloseScreenNotification;
+exports.ComplianceImplementationStepsInput = ComplianceImplementationStepsInput;
+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.CustomerOnboardingLevel = CustomerOnboardingLevel;
+exports.CustomerOnboardingLevels = CustomerOnboardingLevels;
+exports.CustomerStatus = CustomerStatus;
+exports.CustomerStatuses = CustomerStatuses;
+exports.CustomerTableColumn = CustomerTableColumn;
+exports.CustomerType = CustomerType;
+exports.CustomerTypes = CustomerTypes;
+exports.CustomersChartType = CustomersChartType;
+exports.DATE_OPERATORS = DATE_OPERATORS;
+exports.DataAvailableOnStart = DataAvailableOnStart;
+exports.DateOperator = DateOperator;
+exports.Eip155TxAuthInputJsSdk = Eip155TxAuthInputJsSdk;
+exports.ExecuteQueryResponse = ExecuteQueryResponse;
+exports.ExtendedTezosTxAuthDataSignatureResponse = ExtendedTezosTxAuthDataSignatureResponse;
+exports.ExtendedTezosTxAuthInput = ExtendedTezosTxAuthInput;
+exports.ExtendedTxAuthDataSignatureResponse = ExtendedTxAuthDataSignatureResponse;
+exports.ExtendedTxAuthInput = ExtendedTxAuthInput;
+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.HostMessage = HostMessage;
+exports.HostRequestMessage = HostRequestMessage;
+exports.HostResponseMessage = HostResponseMessage;
+exports.IDInformationTfhe = IDInformationTfhe;
+exports.IdentityAppMessage = IdentityAppMessage;
+exports.IdentityMessage = IdentityMessage;
+exports.IdentityNotificationMessage = IdentityNotificationMessage;
+exports.IdentityRequestMessage = IdentityRequestMessage;
+exports.IdentityResponseMessage = IdentityResponseMessage;
+exports.IdentitySdkMessage = IdentitySdkMessage;
+exports.IdentitySdkMessageWithIdentifier = IdentitySdkMessageWithIdentifier;
+exports.IdentityWallet = IdentityWallet;
+exports.InitialDataRequest = InitialDataRequest;
+exports.InitialDataResponse = InitialDataResponse;
+exports.IsVerifiedNotification = IsVerifiedNotification;
+exports.IsVerifiedRequest = IsVerifiedRequest;
+exports.IsVerifiedResponse = IsVerifiedResponse;
+exports.KybOnboardingLevel = KybOnboardingLevel;
+exports.KybOnboardingLevels = KybOnboardingLevels;
+exports.KycCompletionData = KycCompletionData;
+exports.KycCompletionNotification = KycCompletionNotification;
+exports.KycOnboardingLevel = KycOnboardingLevel;
+exports.KycOnboardingLevels = KycOnboardingLevels;
+exports.MediaType = MediaType;
+exports.MediaTypePID = MediaTypePID;
+exports.NUMERIC_OPERATORS = NUMERIC_OPERATORS;
+exports.NexeraCredentialType = NexeraCredentialType;
+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.PartialQueryConfigSimplified = PartialQueryConfigSimplified;
+exports.PolygonIdInitialized = PolygonIdInitialized;
+exports.PolygonIdRequest = PolygonIdRequest;
+exports.PolygonIdRequestData = PolygonIdRequestData;
+exports.PolygonIdResponse = PolygonIdResponse;
+exports.PolygonIdResponseData = PolygonIdResponseData;
+exports.PrivacyPreservingMonitoring = PrivacyPreservingMonitoring;
+exports.ProofData = ProofData;
+exports.QUERY_LOGIC_OPERATOR = QUERY_LOGIC_OPERATOR;
+exports.QrCodeLinkWithSchemaType = QrCodeLinkWithSchemaType;
+exports.QueriesOptions = QueriesOptions;
+exports.QueryConfigSimplified = QueryConfigSimplified;
+exports.QueryConfigTfhe = QueryConfigTfhe;
+exports.QueryCredentialType = QueryCredentialType;
+exports.QueryCredentialTypes = QueryCredentialTypes;
+exports.QueryLogicOperator = QueryLogicOperator;
+exports.QueryType = QueryType;
+exports.RequiredDataRowSchema = RequiredDataRowSchema;
+exports.RequiredVerificationData = RequiredVerificationData;
+exports.RiskScoreType = RiskScoreType;
+exports.RiskScoreTypes = RiskScoreTypes;
+exports.RuleEngineResponse = RuleEngineResponse;
+exports.RuleEngineScenarioExecutionData = RuleEngineScenarioExecutionData;
+exports.RuleResultQueryConfig = RuleResultQueryConfig;
+exports.RuleResultStatus = RuleResultStatus;
+exports.RuleResultStatusLabels = RuleResultStatusLabels;
+exports.RuleResultStatuses = RuleResultStatuses;
+exports.SCENARIO_AUTHORIZATION_STATUSES = SCENARIO_AUTHORIZATION_STATUSES;
+exports.STRING_OPERATORS = STRING_OPERATORS;
+exports.SUPPORTED_TYPES = SUPPORTED_TYPES;
+exports.Scenario = Scenario;
+exports.ScenarioAuthorizationData = ScenarioAuthorizationData;
+exports.ScenarioAuthorizationStatus = ScenarioAuthorizationStatus;
+exports.ScenarioExecutionData = ScenarioExecutionData;
+exports.ScenarioExecutionNotification = ScenarioExecutionNotification;
+exports.ScenarioExecutionResponse = ScenarioExecutionResponse;
+exports.ScenarioSchema = ScenarioSchema;
+exports.ScenarioStatus = ScenarioStatus;
+exports.ScenarioStatuses = ScenarioStatuses;
+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.StartCompletedNotification = StartCompletedNotification;
+exports.StartFlowRequest = StartFlowRequest;
+exports.StringOperator = StringOperator;
+exports.SupportedType = SupportedType;
+exports.SupportedTypes = SupportedTypes;
+exports.TemplateScenario = TemplateScenario;
+exports.TezosTxAuthInput = TezosTxAuthInput;
+exports.TezosTxAuthInputJsSdk = TezosTxAuthInputJsSdk;
+exports.TezosTxSignatureResponse = TezosTxSignatureResponse;
+exports.TransactionData = TransactionData;
+exports.TransactionResponse = TransactionResponse;
+exports.TxAuthDataSignatureGatingError = TxAuthDataSignatureGatingError;
+exports.TxAuthDataSignatureGatingRequest = TxAuthDataSignatureGatingRequest;
+exports.TxAuthDataSignatureResponse = TxAuthDataSignatureResponse;
+exports.TxAuthInput = TxAuthInput;
+exports.TxSignatureResponse = TxSignatureResponse;
+exports.VerifiableCredential = VerifiableCredential;
+exports.VerificationOutput = VerificationOutput;
+exports.VerificationSessionStatus = VerificationSessionStatus;
+exports.VerificationSessionStatuses = VerificationSessionStatuses;
+exports.VerifyWalletChallengeRequest = VerifyWalletChallengeRequest;
+exports.WalletSignResponse = WalletSignResponse;
+exports.WalletSignatureResponse = WalletSignatureResponse;
+exports.ZKPOperator = ZKPOperator;
+exports.ZKPRequest = ZKPRequest;
+exports.ZKPRequestFromZKVerifier = ZKPRequestFromZKVerifier;
+exports.ZeroKnowledgeProofRequest = ZeroKnowledgeProofRequest;
+exports.ZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse;
+exports.getCredentialName = getCredentialName;
+exports.getOldCredentialPath = getOldCredentialPath;
+exports.getOldCredentialType = getOldCredentialType;
+exports.oldCredentialPathToDataLink = oldCredentialPathToDataLink;
+exports.operatorDisplayMap = operatorDisplayMap;
+exports.parseIden3Message = parseIden3Message;
+exports.parseSessionIdFromUrl = parseSessionIdFromUrl;