@nexeraid/identity-schemas 2.65.0 → 2.67.0-dev

package/dist/identity-api.schema-36a2a1b2.esm.mjs

@@ -0,0 +1,1113 @@
+import { z } from 'zod';
+import { cM as IDImageCredentialSubjectSchema, cO as ProofOfResidenceCredentialSubjectSchema, cN as SelfieImageCredentialSubjectSchema, cL as IDInformationCredentialSubjectSchema, cK as IDInformationTfheCredentialSubjectSchema, cJ as OLD_AMLScreeningsResultsCredentialSubjectSchema, cB as ID3CredentialSubjectSchema, cC as IDScanCredentialSubjectSchema, cE as IDScanSelfieCredentialSubjectSchema, cD as IDScanPassportCredentialSubjectSchema, dV as _defineProperty, dM as VaultMetadataLinkZodSchema, c6 as QueryId, aS as UuidString, ar as BlockchainAddress, c4 as ScenarioId, cs as WorkspaceId, as as String0x, aN as BlockchainSignature, aa as TxHash, ct as WorkflowId, g as EvmChainId, a9 as AddressSchema, aD as EIP155Signature, T as TezosChainId, ah as TezosContractAddress, aP as TezosEntrypointName, ag as TezosImplicitAddress, aI as EdSignature, av as BlockchainNamespace, cP as GenericVerifiableCredentialSchema, ax as SupportedBlockchainNamespaceForSignatureAuth, B as BlockchainId, cv as ExternalCustomerId, cq as AdditionalCustomerInformationParams, a8 as PublicKey } from './vault.schema-1c1dcdb7.esm.mjs';
+
+var CredentialSchemas = {
+  ProofOfResidence: ProofOfResidenceCredentialSubjectSchema,
+  SelfieImage: SelfieImageCredentialSubjectSchema,
+  IDImage: IDImageCredentialSubjectSchema,
+  IDInformation: IDInformationCredentialSubjectSchema,
+  IDInformationTfhe: IDInformationTfheCredentialSubjectSchema,
+  AMLScreeningsResults: OLD_AMLScreeningsResultsCredentialSubjectSchema,
+  ID3: ID3CredentialSubjectSchema,
+  IDScan: IDScanCredentialSubjectSchema,
+  IDScanSelfie: IDScanSelfieCredentialSubjectSchema,
+  IDScanPassport: 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 = 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 = z.string().transform(function (x) {
+  return x.replace("_", "-");
+}) // TODO determine why this is needed
+.pipe(z["enum"](CredentialTypes));
+// Should this be replaced by GenericVerifiableCredentialSchema?
+
+var VerifiableCredential = z.object({
+  issuer: z.string(),
+  type: z.array(z.union([z.string(), CredentialType])),
+  credentialSubject: z.record(z.unknown())
+}).catchall(z.any());
+var CredentialMediaType = 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 = z.nativeEnum(MediaType);
+var CIRCUIT_IDS = ["authV2", "stateTransition", "credentialAtomicQueryMTPV2", "credentialAtomicQueryMTPV2OnChain", "credentialAtomicQuerySigV2", "credentialAtomicQuerySigV2OnChain", "credentialAtomicQueryV3-beta.1", "credentialAtomicQueryV3OnChain-beta.1", "linkedMultiQuery10-beta.1"];
+var CircuitId = z["enum"](CIRCUIT_IDS);
+var ZeroKnowledgeProofRequest = z.object({
+  id: z.number(),
+  circuitId: z.string(),
+  optional: z["boolean"]().optional(),
+  query: z.record(z.string(), 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 = z["enum"](AuthorizationRequestMessageTypes);
+var AuthorizationRequestMessage = z.object({
+  id: z.string(),
+  typ: MediaTypePID.optional(),
+  type: AuthorizationRequestMessageType,
+  thid: z.string().optional(),
+  body: z.object({
+    callbackUrl: z.string(),
+    reason: z.string().optional(),
+    did_doc: z.any().optional(),
+    message: z.string().optional(),
+    scope: z.array(ZeroKnowledgeProofRequest)
+  }),
+  from: z.string(),
+  to: z.string().optional()
+});
+// Response
+var ProofData = z.object({
+  pi_a: z.array(z.string()),
+  pi_b: z.array(z.array(z.string())),
+  pi_c: z.array(z.string()),
+  protocol: z.string(),
+  curve: z.string().optional()
+});
+var ZeroKnowledgeProofResponse = z.object({
+  id: z.number(),
+  circuitId: z.string(),
+  vp: z.any().optional(),
+  proof: ProofData,
+  pub_signals: z.array(z.string())
+});
+var AuthorizationResponseMessage = z.object({
+  id: z.string(),
+  typ: MediaTypePID.optional(),
+  type: z.string(),
+  thid: z.string().optional(),
+  body: z.object({
+    did_doc: z.any().optional(),
+    message: z.string().optional(),
+    scope: z.array(ZeroKnowledgeProofResponse)
+  }),
+  from: z.string().optional(),
+  to: z.string().optional()
+});
+// Polygon Wallet
+var CredentialQrCodeData = z.object({
+  id: z.string(),
+  typ: z.string(),
+  type: z.string(),
+  thid: z.string(),
+  body: z.object({
+    url: z.string(),
+    credentials: z.unknown()
+  }),
+  from: z.string(),
+  to: z.string()
+});
+var AuthQrCodeData = z.object({
+  id: z.string(),
+  typ: z.string(),
+  type: z.string(),
+  thid: z.string(),
+  body: z.object({
+    callbackUrl: z.string(),
+    reason: z.string(),
+    scope: z.unknown()
+  }),
+  from: z.string()
+});
+var QrCodeLinkWithSchemaType = z.object({
+  qrCodeLink: z.string().nullish(),
+  schemaType: 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 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 = 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 = z["enum"](OPERATORS);
+var ZKPOperator = z["enum"](OPERATORS).exclude(["$lte", "$gte"]);
+var operatorDisplayMap = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, Operator["enum"].$eq, "="), Operator["enum"].$gt, ">"), Operator["enum"].$lt, "<"), Operator["enum"].$gte, ">="), Operator["enum"].$lte, "<="), Operator["enum"].$ne, "!="), Operator["enum"].$in, "in"), Operator["enum"].$nin, "not in"), Operator["enum"].$noop, "noop"), Operator["enum"].$exists, "exists");
+var ARRAY_OPERATORS = [Operator["enum"].$in, Operator["enum"].$nin, Operator["enum"].$eq, Operator["enum"].$ne
+//Operator.enum.$between,
+//Operator.enum.$nonbetween,
+];
+var ArrayOperator = z["enum"](ARRAY_OPERATORS);
+var STRING_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne, Operator["enum"].$in, Operator["enum"].$nin, Operator["enum"].$exists];
+var StringOperator = 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 = z["enum"](NUMERIC_OPERATORS);
+var BOOLEAN_OPERATORS = [Operator["enum"].$eq, Operator["enum"].$ne];
+var BooleanOperator = 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 = z["enum"](DATE_OPERATORS);
+var SUPPORTED_TYPES = ["string", "integer", "boolean", "number", "array", "date", "decimal"];
+var SupportedType = z["enum"](SUPPORTED_TYPES);
+var SupportedTypes = z.object(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, SupportedType["enum"].string, StringOperator), SupportedType["enum"].integer, NumericOperator), SupportedType["enum"]["boolean"], BooleanOperator), SupportedType["enum"].number, NumericOperator), SupportedType["enum"].array, ArrayOperator), SupportedType["enum"].date, DateOperator), SupportedType["enum"].decimal, NumericOperator));
+var IDInformationTfhe = z.object({
+  type: z.literal("IDInformationTfhe"),
+  requestId: z.coerce.number().nullish(),
+  attribute: z.string(),
+  value: z.string(),
+  operator: Operator
+});
+var AllCredentialValues = z.union([z["boolean"](), z.string(), z.number(), z.array(z.string()), z.array(z.number())]);
+var QueriesOptions = z.array(z.object({
+  title: z.string(),
+  link: VaultMetadataLinkZodSchema
+}));
+var QueryType = 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 = z.object({
+  type: z.literal("IDInformationTfhe"),
+  requestId: z.coerce.number().nullish(),
+  attribute: z.string(),
+  value: z.string(),
+  operator: Operator
+});
+var QueryConfigSimplified = z.object({
+  queryId: QueryId.describe("Unique ID for the query").optional(),
+  // TODO: this should not be optional?
+  id: QueryId.describe("Unique ID for the query").optional(),
+  // TODO: this should not be optional?
+  requestId: z.coerce.number().nullish().describe("Request ID for ZKPs"),
+  attribute: 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: z.union([z.string(), VaultMetadataLinkZodSchema]),
+  // string for backwards compatibility
+  type: QueryType.nullish() // Backwards compatibility
+});
+var PartialQueryConfigSimplified = QueryConfigSimplified.partial();
+var OLD_ChallengeQuerySchema = z.object({
+  id: z.string().optional(),
+  query: QueryConfigSimplified
+});
+var QueryCredentialTypes = ["IDInformation", "IDInformationTfhe", "IDImage", "SelfieImage", "ProofOfResidence"];
+var QueryCredentialType = z["enum"](QueryCredentialTypes);
+var ChallengeQuerySchema = z.object({
+  id: 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 = z["enum"](OLD_CHALLENGE_QUERY_OPERATORS);
+var OperatorMappings = {
+  toChallenge: _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, Operator["enum"].$noop, OLD_ChallengeQueryOperator["enum"].EQUAL_TO), Operator["enum"].$eq, OLD_ChallengeQueryOperator["enum"].EQUAL_TO), Operator["enum"].$lt, OLD_ChallengeQueryOperator["enum"].LESS_THAN), Operator["enum"].$lte, OLD_ChallengeQueryOperator["enum"].LESS_THAN_OR_EQUAL_TO), Operator["enum"].$gt, OLD_ChallengeQueryOperator["enum"].GREATER_THAN), Operator["enum"].$gte, OLD_ChallengeQueryOperator["enum"].GREATER_THAN_OR_EQUAL_TO), Operator["enum"].$in, OLD_ChallengeQueryOperator["enum"].IN), Operator["enum"].$nin, OLD_ChallengeQueryOperator["enum"].NOT_IN), Operator["enum"].$ne, OLD_ChallengeQueryOperator["enum"].NOT_EQUAL_TO), Operator["enum"].$exists, OLD_ChallengeQueryOperator["enum"].EXISTS),
+  fromChallenge: _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, OLD_ChallengeQueryOperator["enum"].EQUAL_TO, Operator["enum"].$eq), OLD_ChallengeQueryOperator["enum"].LESS_THAN, Operator["enum"].$lt), OLD_ChallengeQueryOperator["enum"].LESS_THAN_OR_EQUAL_TO, Operator["enum"].$lte), OLD_ChallengeQueryOperator["enum"].GREATER_THAN, Operator["enum"].$gt), OLD_ChallengeQueryOperator["enum"].GREATER_THAN_OR_EQUAL_TO, Operator["enum"].$gte), OLD_ChallengeQueryOperator["enum"].IN, Operator["enum"].$in), OLD_ChallengeQueryOperator["enum"].NOT_IN, Operator["enum"].$nin), OLD_ChallengeQueryOperator["enum"].NOT_EQUAL_TO, Operator["enum"].$ne), OLD_ChallengeQueryOperator["enum"].EXISTS, Operator["enum"].$exists)
+};
+var OperatorToOLD_ChallengeQueryOperator = OperatorMappings.toChallenge;
+var OLD_ChallengeQueryOperatorToOperator = OperatorMappings.fromChallenge;
+
+// FIXME: Remove this once we migrate to the vault metadata
+var OLD_QueryCredentialTypes = ["IDInformation", "IDImage", "SelfieImage", "ProofOfResidence", "AMLScreeningsResults", "ID3", "IDScan", "IDScanSelfie", "IDScanPassport"];
+var OLD_QueryCredentialType = 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 = z["enum"](ScenarioTypes);
+var ScenarioStatuses = ["enabled", "disabled"];
+var ScenarioStatus = z["enum"](ScenarioStatuses);
+var ScenarioSchema = z.object({
+  title: z.string(),
+  link: z.object({
+    version: z.string(),
+    schema: z.string(),
+    path: z.string()
+  }),
+  status: z["enum"]([ScenarioStatus.Enum.enabled, ScenarioStatus.Enum.disabled]).optional()
+});
+var BackwardsCompatibleScenarioTypes = ["PrivacyPreservingMonitoring", "IndividualMonitoring", "TransactionMonitoring", "TFHE", "OffChainZKP",
+// Backwards compatible
+"ChallengeQuery" // Backwards compatible
+];
+var BackwardsCompatibleScenarioType = z["enum"](BackwardsCompatibleScenarioTypes);
+var BaseQueryResponse = z.object({
+  result: z.object({
+    is_valid: z["boolean"](),
+    reasons: z.array(z.string())
+  })
+});
+var OffChainZKPRuleResult = BaseQueryResponse.extend({
+  result: z.object({
+    is_valid: z["boolean"](),
+    query: QueryConfigSimplified,
+    reasons: z.array(z.string())
+  })
+});
+var ExecuteQueryResponse = BaseQueryResponse.extend({
+  executionId: UuidString
+});
+var RuleEngineResponse = z.object({
+  objectType: BackwardsCompatibleScenarioType,
+  objectId: z.string().describe("Object id in the cms (challengeQueryid, offChainZKPid)"),
+  name: z.string(),
+  address: BlockchainAddress.nullish(),
+  result: ExecuteQueryResponse,
+  executionId: UuidString,
+  scenarioId: z.string()
+});
+var ScenarioExecutionResponse = z.array(RuleEngineResponse);
+var RuleResultStatuses = ["valid", "not-valid", "error", "unknown"];
+var RuleResultStatus = z["enum"](RuleResultStatuses);
+var RuleResultStatusLabels = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, RuleResultStatus.Enum.valid, "Valid"), RuleResultStatus.Enum["not-valid"], "Not Valid"), RuleResultStatus.Enum.error, "Error"), RuleResultStatus.Enum.unknown, "Unknown");
+var SdkVerificationOutput = z.object({
+  customerId: z.string().optional(),
+  // for v1
+  scenarioExecutionId: z.string().optional(),
+  // for v1
+  status: RuleResultStatus.optional(),
+  // for v1
+  results: z.array(ScenarioExecutionResponse).optional() // for v1,
+});
+var VerificationSessionStatuses = ["IN_PROGRESS", "COMPLETED", "NOT_STARTED"];
+var VerificationSessionStatus = z["enum"](VerificationSessionStatuses);
+var VerificationOutput = z.object({
+  id: UuidString.nullable(),
+  verificationResult: SdkVerificationOutput.nullable(),
+  status: VerificationSessionStatus
+});
+var Scenario = z.object({
+  id: ScenarioId,
+  name: z.string(),
+  description: z.string().nullish(),
+  queries: z.array(QueryConfigSimplified),
+  type: ScenarioType,
+  workspaceId: WorkspaceId,
+  vcsIncluded: 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: z.array(QueryConfigSimplified)
+});
+var TemplateScenario = Scenario.omit({
+  workspaceId: true
+});
+var CreateTemplateScenario = TemplateScenario.omit({
+  id: true
+});
+
+var ScenarioAuthorizationData = z.object({
+  executionId: UuidString,
+  sessionId: UuidString,
+  projectId: z.string(),
+  address: BlockchainAddress.nullish(),
+  status: z["enum"](["pending", "authorised", "unauthorised"]),
+  scenarioId: z.string(),
+  scenarioName: z.string(),
+  requestMessage: AuthorizationRequestMessage,
+  responseMessage: AuthorizationResponseMessage.nullish(),
+  verificationError: z.string().nullish(),
+  query: QueryConfigSimplified.array(),
+  workflowSessionId: UuidString.optional()
+});
+// v1 sdk
+var SdkVerificationResponseSchema = SdkVerificationOutput;
+var CloseScreenNotification = z.object({
+  type: z.literal("closeScreen"),
+  identifier: z.string(),
+  data: z.undefined()
+});
+var KycCompletionData = z.array(VerifiableCredential);
+var KycCompletionNotification = z.object({
+  type: z.literal("kycCompletion"),
+  identifier: z.string(),
+  data: KycCompletionData
+});
+var RuleEngineScenarioExecutionData = z.object({
+  type: z.literal("RuleEngineScenarioExecution"),
+  data: SdkVerificationResponseSchema
+});
+var OffChainScenarioExecutionData = z.object({
+  type: z.literal("OffChainScenarioExecution"),
+  data: z.array(ScenarioAuthorizationData)
+});
+var OnChainScenarioExecutionData = z.object({
+  type: z.literal("OnChainScenarioExecution"),
+  data: z.any()
+});
+var ScenarioExecutionData = z.union([RuleEngineScenarioExecutionData, OffChainScenarioExecutionData, OnChainScenarioExecutionData]);
+var ScenarioExecutionNotification = z.object({
+  type: z.literal("scenarioExecution"),
+  identifier: z.string(),
+  data: ScenarioExecutionData
+});
+var IsVerifiedNotification = z.object({
+  type: z.literal("isVerifiedNotification"),
+  identifier: z.string(),
+  isVerified: z["boolean"]()
+});
+var PolygonIdInitialized = z.object({
+  type: z.literal("polygonIdInitialized"),
+  identifier: z.string(),
+  data: z.string()
+});
+var OcvSdkInitialized = z.object({
+  type: z.literal("ocvSdkInitialized"),
+  identifier: z.string()
+});
+var StartCompletedNotification = z.object({
+  type: z.literal("startCompletedNotification"),
+  identifier: z.string()
+});
+var IdentityNotificationMessage = z.union([CloseScreenNotification, PolygonIdInitialized, OcvSdkInitialized, StartCompletedNotification, KycCompletionNotification, ScenarioExecutionNotification, IsVerifiedNotification]);
+var InitialDataRequest = z.object({
+  type: z.literal("initialDataRequest"),
+  identifier: z.string()
+});
+var SignatureRequest = z.object({
+  type: z.literal("signatureRequest"),
+  identifier: z.string(),
+  data: z.object({
+    message: z.string()
+  })
+});
+var TransactionData = z.object({
+  accountAddress: BlockchainAddress,
+  to: BlockchainAddress,
+  data: String0x,
+  value: z.string().optional()
+});
+var SendTransactionRequest = z.object({
+  type: z.literal("sendTransactionRequest"),
+  identifier: z.string(),
+  data: TransactionData
+});
+var IdentityRequestMessage = z.union([InitialDataRequest, SignatureRequest, SendTransactionRequest]);
+var AVAILABLE_FLOWS = ["VERIFICATION", "MANAGEMENT", "POLYGON_ID", "KYB"];
+var AvailableFlow = z["enum"](AVAILABLE_FLOWS);
+var DataAvailableOnStart = z.object({
+  identifier: z.string().optional(),
+  flow: z["enum"](AVAILABLE_FLOWS).optional(),
+  accessToken: z.string(),
+  signingMessage: z.string(),
+  signature: z.string()
+});
+var InitialDataResponse = z.object({
+  type: z.literal("onStartKyc"),
+  data: DataAvailableOnStart
+});
+var SignatureResponse = z.object({
+  type: z.literal("signature"),
+  data: BlockchainSignature
+});
+var TransactionResponse = z.object({
+  type: z.literal("transactionResponse"),
+  data: z.object({
+    txHash: TxHash
+  })
+});
+var HostResponseMessage = z.union([InitialDataResponse, SignatureResponse, TransactionResponse]);
+
+/**
+ * Exported types
+ */
+
+var ComplianceImplementationStepsInput = z.object({
+  identityChecks: z["boolean"]().nullish(),
+  configureIdentity: z["boolean"]().nullish(),
+  deployIdentity: z["boolean"]().nullish(),
+  monitorIdentity: z["boolean"]().nullish()
+});
+
+/////////////
+// EIP-155 //
+/////////////
+
+var TxAuthInput = z.object({
+  workflowId: WorkflowId.optional(),
+  chainId: EvmChainId,
+  contractAbi: z.array(z.record(z.unknown())),
+  contractAddress: AddressSchema,
+  functionName: z.string(),
+  args: z.array(z.unknown()),
+  userAddress: AddressSchema,
+  blockExpiration: z.number()["int"]().optional(),
+  nonce: z.number()["int"]().optional()
+});
+// the api endpoint can source the userAddress from the session if it's not provided
+var ApiTxAuthInput = TxAuthInput.extend({
+  userAddress: AddressSchema.optional()
+});
+var TxSignatureResponse = z.object({
+  signature: EIP155Signature,
+  blockExpiration: z.number()
+});
+var GetTxAuthDataSignatureResponse = z.union([z.object({
+  isAuthorized: z.literal(true),
+  signature: EIP155Signature,
+  payload: z.string(),
+  blockExpiration: z.number()
+}), z.object({
+  isAuthorized: z.literal(false),
+  errorMessage: z.any()
+})]);
+/////////////
+// Tezos   //
+/////////////
+
+var TezosTxAuthInput = z.object({
+  workflowId: WorkflowId.optional(),
+  chainID: TezosChainId,
+  contractAddress: TezosContractAddress,
+  functionName: TezosEntrypointName,
+  args: z.string(),
+  userAddress: TezosImplicitAddress,
+  blockExpiration: z.number()["int"]().optional(),
+  nonce: z.number()["int"]().optional()
+});
+// the api endpoint can source the userAddress from the session if it's not provided
+var ApiTezosTxAuthInput = TezosTxAuthInput.extend({
+  userAddress: TezosImplicitAddress.optional()
+});
+var TezosTxSignatureResponse = z.object({
+  signature: EdSignature,
+  blockExpiration: z.number()
+});
+var GetTezosTxAuthDataSignatureResponse = z.union([z.object({
+  isAuthorized: z.literal(true),
+  signature: EdSignature,
+  blockExpiration: z.number()
+}), z.object({
+  isAuthorized: z.literal(false),
+  errorMessage: z.any()
+})]);
+/////////////
+// General //
+/////////////
+
+var ExtendedTxAuthInput = TxAuthInput.and(z.object({
+  namespace: z.literal(BlockchainNamespace.Enum.eip155),
+  userAddress: AddressSchema
+}));
+var ExtendedTezosTxAuthInput = TezosTxAuthInput.and(z.object({
+  namespace: z.literal(BlockchainNamespace.Enum.tezos),
+  userAddress: TezosImplicitAddress
+}));
+var ExtendedTxAuthDataSignatureResponse = GetTxAuthDataSignatureResponse.and(z.object({
+  namespace: z.literal(BlockchainNamespace.Enum.eip155),
+  userAddress: AddressSchema
+}));
+var ExtendedTezosTxAuthDataSignatureResponse = GetTezosTxAuthDataSignatureResponse.and(z.object({
+  namespace: z.literal(BlockchainNamespace.Enum.tezos),
+  userAddress: TezosImplicitAddress
+}));
+var AnyTxAuthDataSignatureResponse = z.union([ExtendedTxAuthDataSignatureResponse, ExtendedTezosTxAuthDataSignatureResponse]);
+/////////////
+// JS SDK  //
+/////////////
+
+var Eip155TxAuthInputJsSdk = ExtendedTxAuthInput.and(z.object({
+  workflowId: WorkflowId
+}));
+var TezosTxAuthInputJsSdk = ExtendedTezosTxAuthInput.and(z.object({
+  workflowId: WorkflowId
+}));
+var AnyTxAuthInputJsSdk = z.union([Eip155TxAuthInputJsSdk, TezosTxAuthInputJsSdk]);
+
+var SimplifiedCredential = z.object({
+  id: z.string(),
+  type: z.array(z.string()),
+  issuanceDate: z.string(),
+  journeyId: z.string()
+});
+/**
+ * GetCredentialsRequest
+ */
+var GetCredentialsRequest = z.object({
+  type: z.literal("getCredentials"),
+  data: z.undefined()
+});
+/**
+ * GetCredentialsResponse
+ */
+var GetCredentialsResponse = z.object({
+  type: z.literal("polygonIdCredentials"),
+  credentials: z.array(SimplifiedCredential),
+  identifier: z.string()
+});
+/**
+ * PolygonIdRequest
+ */
+var PolygonIdRequestData = z.union([z.object({
+  type: z.literal("auth"),
+  authRequest: AuthorizationRequestMessage
+}), z.object({
+  type: z.literal("credentialOffer"),
+  credentialOfferRequest: QrCodeLinkWithSchemaType
+}), z.object({
+  type: z.literal("zkp"),
+  zkpRequest: ZeroKnowledgeProofRequest
+})]);
+var PolygonIdRequest = z.object({
+  type: z.literal("polygonIdRequest"),
+  data: PolygonIdRequestData
+});
+/**
+ * PolygonIdResponse
+ */
+var PolygonIdResponseData = z.union([z.object({
+  type: z.literal("auth"),
+  authResponse: AuthorizationResponseMessage
+}), z.object({
+  type: z.literal("credentialOffer"),
+  credentialOfferResponse: z.array(GenericVerifiableCredentialSchema)
+}), z.object({
+  type: z.literal("zkp"),
+  zkpResponse: ZeroKnowledgeProofResponse
+}), z.object({
+  type: z.literal("close"),
+  screen: z["enum"](["auth", "credentialOffer", "zkp", "getCredentials"]),
+  closeResponse: z.string()
+})]);
+var PolygonIdResponse = z.object({
+  type: z.literal("polygonIdResponse"),
+  identifier: z.string(),
+  data: PolygonIdResponseData
+});
+/**
+ * StartFlowRequest
+ */
+var StartFlowRequest = z.union([z.object({
+  type: z.literal("startVerification"),
+  data: z.undefined()
+}), z.object({
+  type: z.literal("startManagement"),
+  data: z.undefined()
+}), z.object({
+  type: z.literal("startKYB"),
+  data: z.undefined()
+})]);
+/**
+ * IsVerifiedRequest
+ */
+var IsVerifiedRequest = z.object({
+  type: z.literal("isVerifiedRequest"),
+  data: z.object({
+    userAddress: AddressSchema
+  }),
+  identifier: z.string()
+});
+/**
+ * IsVerifiedResponse
+ */
+var IsVerifiedResponse = z.object({
+  type: z.literal("isVerifiedResponse"),
+  isVerified: z["boolean"](),
+  identifier: z.string()
+});
+/**
+ * GetTxAuthSigRequest
+ */
+var GetTxAuthSigRequest = z.object({
+  type: z.literal("getTxAuthSigRequest"),
+  data: ApiTxAuthInput,
+  identifier: z.string()
+});
+/**
+ * GetTxAuthSigResponse
+ */
+var GetTxAuthSigResponse = z.object({
+  type: z.literal("getTxAuthSigResponse"),
+  signatureResponse: GetTxAuthDataSignatureResponse,
+  identifier: z.string()
+});
+/**
+ * GetTxAuthSigRequest Tezos
+ */
+var GetTxAuthSigRequestTezos = z.object({
+  type: z.literal("getTxAuthSigRequestTezos"),
+  data: ApiTezosTxAuthInput,
+  identifier: z.string()
+});
+/**
+ * GetTxAuthSigResponse Tezos
+ */
+var GetTxAuthSigResponseTezos = z.object({
+  type: z.literal("getTezosTxAuthSigResponse"),
+  signatureResponse: GetTezosTxAuthDataSignatureResponse,
+  identifier: z.string()
+});
+var HostRequestMessage = z.union([GetCredentialsRequest, PolygonIdRequest, StartFlowRequest, IsVerifiedRequest, GetTxAuthSigRequest, GetTxAuthSigRequestTezos]);
+var IdentityResponseMessage = z.union([GetCredentialsResponse, PolygonIdResponse, IsVerifiedResponse, GetTxAuthSigResponse, GetTxAuthSigResponseTezos]);
+
+// Risk Score
+var RiskScoreTypes = ["Low", "Medium", "High", "No risk"];
+var RiskScoreType = z["enum"](RiskScoreTypes);
+// Customer Type
+var CustomerTypes = ["Individual", "Company"];
+var CustomerType = z["enum"](CustomerTypes);
+// KYC Onboarding Level
+var KycOnboardingLevels = ["Sign-up", "AML screening", "KYC", "Questionaire", "Onboarded"];
+var KycOnboardingLevel = z["enum"](KycOnboardingLevels);
+// KYB Onboarding Level
+var KybOnboardingLevels = ["Onboarding", "KYB", "Onboarded"];
+var KybOnboardingLevel = z["enum"](KybOnboardingLevels);
+var CustomerOnboardingLevels = [].concat(KycOnboardingLevels, KybOnboardingLevels);
+var CustomerOnboardingLevel = z["enum"](CustomerOnboardingLevels);
+// Customer Status
+var CustomerStatuses = ["Active", "Rejected", "Dormant", "To be reviewed", "Failed", "Escalated", "Terminated", "No status"];
+var CustomerStatus = z["enum"](CustomerStatuses);
+var BasicCustomerContactInformation = z.object({
+  email: z.string().email(),
+  phone: z.string().min(4),
+  twitter: z.string(),
+  discord: z.string(),
+  telegram: z.string()
+}).partial();
+var CUSTOMERS_CHARTS = ["totalCustomers", "onboarded", "active", "dormant", "rejected", "topCountriesByCustomersCount", "customersRiskLevel", "customersByStatus", "trendOfStatusesOverTime"];
+var CustomersChartType = 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 = 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 = z.object({
+  address: BlockchainAddress,
+  namespace: SupportedBlockchainNamespaceForSignatureAuth,
+  blockchainId: BlockchainId.optional(),
+  origin: z.string().url(),
+  workflowId: WorkflowId,
+  externalCustomerId: ExternalCustomerId.optional(),
+  additionalInformation: AdditionalCustomerInformationParams.optional()
+});
+var AuthSession = 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: 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: z.number(),
+  // if an external customer id was provided, it will be returned
+  // when obtaining the auth session to facilitate integration with the user's system
+  externalCustomerId: ExternalCustomerId.optional()
+});
+var AuthSessionData = z.object({
+  /**
+   * The unique identifier of the user
+   */
+  identityId: z.string(),
+  /**
+   * The unique identifier of the user's session
+   */
+  customerId: z.string(),
+  /**
+   * The identifier passed by the user platform
+   */
+  externalCustomerId: ExternalCustomerId.optional()
+});
+var ChallengeResponse = z.object({
+  challenge: z.string()
+});
+////////////////
+// SDK messages
+////////////////
+
+var AppConfigRequest = z.object({
+  type: z.literal("appConfig"),
+  data: z.object({
+    authSession: AuthSession
+  })
+});
+var WalletUpdated = z.object({
+  type: z.literal("walletUpdated"),
+  data: z.object({
+    address: BlockchainAddress
+  })
+});
+var WalletSignResponse = z.object({
+  type: z.literal("walletSignResponse"),
+  data: z.object({
+    message: z.string(),
+    signature: BlockchainSignature
+  })
+});
+var TxAuthDataSignatureGatingRequest = z.object({
+  type: z.literal("txAuthDataSignatureGatingRequest"),
+  data: z.object({
+    input: AnyTxAuthInputJsSdk
+  })
+});
+var GetCustomerStatusRequest = z.object({
+  type: z.literal("getCustomerStatusRequest")
+});
+var IdentitySdkMessage = z.union([AppConfigRequest, WalletUpdated, WalletSignResponse, TransactionResponse, TxAuthDataSignatureGatingRequest, GetCustomerStatusRequest]);
+var IdentitySdkMessageWithIdentifier = z.intersection(IdentitySdkMessage, z.object({
+  identifier: z.string()
+}));
+////////////////
+// App messages
+////////////////
+
+var IdentityAppLoadedNotification = z.object({
+  type: z.literal("identityAppLoaded")
+});
+var IdentityAppConfiguredNotification = z.object({
+  type: z.literal("identityAppConfigured"),
+  data: z.object({
+    auth: AuthSession
+  })
+});
+var AuthenticationExpiredNotification = z.object({
+  type: z.literal("authenticationExpired"),
+  data: z.object({
+    authSession: AuthSession
+  })
+});
+var WalletSignRequest = z.object({
+  type: z.literal("walletSignRequest"),
+  data: z.object({
+    message: z.string()
+  })
+});
+var TxAuthDataSignatureResponse = z.object({
+  type: z.literal("txAuthDataSignatureResponse"),
+  data: AnyTxAuthDataSignatureResponse
+});
+var TxAuthDataSignatureGatingError = z.object({
+  type: z.literal("txAuthDataSignatureGatingError"),
+  data: z.object({
+    error: z.string()
+  })
+});
+var GetCustomerStatusResponse = z.object({
+  type: z.literal("getCustomerStatusResponse"),
+  data: z.union([CustomerStatus, z["null"]()])
+});
+var IdentityAppMessage = 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 = z.object({
+  address: BlockchainAddress,
+  namespace: SupportedBlockchainNamespaceForSignatureAuth
+});
+
+var ZKPRequest = z.object({
+  id: z.number(),
+  circuitId: z["enum"](["credentialAtomicQuerySigV2", "credentialAtomicQuerySigV2OnChain"]),
+  optional: z["boolean"]().optional(),
+  query: QueryConfigSimplified
+});
+var ZKPRequestFromZKVerifier = z.object({
+  id: z.number(),
+  circuitId: z.string(),
+  optional: z["boolean"]().optional(),
+  query: z.record(z.unknown())
+});
+var PrivacyPreservingMonitoring = z.object({
+  requestingAuthorizationMessage: z.string().nullish(),
+  zkpRequest: z.array(ZKPRequest).nullish()
+});
+var CreateAuthRequestProps = z.object({
+  hostUrl: z.string().url(),
+  sessionId: UuidString,
+  audience: z.string().describe("DID of the verifier"),
+  callbackURL: z.string().describe("URL to which the auth response of the client callback will be sent"),
+  query: z.array(QueryConfigSimplified),
+  onChainVerification: z["boolean"]().optional(),
+  id: z.string().uuid(),
+  thid: z.string().uuid(),
+  message: z.string().describe("Message shown to the user")
+});
+var AllScenarioExecutionAuthorizationData = z.object({
+  executionId: UuidString,
+  projectId: z.string(),
+  scenarioExecutionIds: z.array(UuidString)
+});
+var SCENARIO_AUTHORIZATION_STATUSES = ["pending", "authorised", "unauthorised"];
+var ScenarioAuthorizationStatus = z["enum"](SCENARIO_AUTHORIZATION_STATUSES);
+
+var HostMessage = z.union([HostRequestMessage, HostResponseMessage]);
+var IdentityMessage = z.union([IdentityNotificationMessage, IdentityRequestMessage, IdentityResponseMessage]);
+var RequiredDataRowSchema = z.object({
+  type: CredentialType,
+  requiredAttributes: z.array(z.object({
+    attribute: z.string(),
+    value: z.string(),
+    operator: z.string()
+  }))
+});
+var RequiredVerificationData = z.object({
+  ruleEngine: z.object({
+    requiredData: z.array(RequiredDataRowSchema)
+  }),
+  PrivacyPreservingMonitoring: z.object({
+    requiredData: z.array(RequiredDataRowSchema),
+    verifications: z.array(z.object({
+      scenarioVerifierAddress: z.string(),
+      conditions: z.array(ZKPRequest)
+    }))
+  }),
+  tfhe: z.object({
+    requiredData: z.array(RequiredDataRowSchema),
+    verifications: z.array(QueryConfigSimplified)
+  })
+});
+
+var WalletSignatureResponse = z.object({
+  // the message we requested the user to sign
+  message: z.string(),
+  // the signature of the message
+  signature: BlockchainSignature,
+  // some wallets like Cardano Nami generate a new address for each transaction or signature
+  // this means we have to request the signer's public key to verify the signature
+  signerPublicKey: PublicKey,
+  // the type of the signer's public key
+  // this is optional because some wallets don't provide this information
+  // but for other wallets like cosmos kepler, this is required to verify the signature
+  signerPublicKeyType: 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: z.string()
+});
+var VerifyWalletChallengeRequest = WalletSignatureResponse.and(z.object({
+  address: BlockchainAddress,
+  namespace: SupportedBlockchainNamespaceForSignatureAuth,
+  blockchainId: BlockchainId.optional()
+}));
+
+export { BaseQueryResponse as $, InitialDataRequest as A, BasicCustomerContactInformation as B, CredentialTypes as C, SignatureRequest as D, SendTransactionRequest as E, IdentityRequestMessage as F, AVAILABLE_FLOWS as G, AvailableFlow as H, IsVerifiedNotification as I, DataAvailableOnStart as J, KycOnboardingLevels as K, InitialDataResponse as L, SignatureResponse as M, TransactionResponse as N, OffChainScenarioExecutionData as O, PolygonIdInitialized as P, HostResponseMessage as Q, RiskScoreTypes as R, ScenarioAuthorizationData as S, TransactionData as T, ScenarioTypes as U, ScenarioType as V, ScenarioStatuses as W, ScenarioStatus as X, ScenarioSchema as Y, BackwardsCompatibleScenarioTypes as Z, BackwardsCompatibleScenarioType as _, RiskScoreType as a, AuthQrCodeData as a$, OffChainZKPRuleResult as a0, ExecuteQueryResponse as a1, RuleEngineResponse as a2, ScenarioExecutionResponse as a3, RuleResultStatuses as a4, RuleResultStatus as a5, RuleResultStatusLabels as a6, SdkVerificationOutput as a7, VerificationSessionStatuses as a8, VerificationSessionStatus as a9, WalletSignResponse as aA, TxAuthDataSignatureGatingRequest as aB, GetCustomerStatusRequest as aC, IdentitySdkMessage as aD, IdentitySdkMessageWithIdentifier as aE, TxAuthDataSignatureResponse as aF, TxAuthDataSignatureGatingError as aG, GetCustomerStatusResponse as aH, IdentityAppMessage as aI, IdentityWallet as aJ, HostMessage as aK, IdentityMessage as aL, RequiredDataRowSchema as aM, RequiredVerificationData as aN, MediaType as aO, MediaTypePID as aP, CIRCUIT_IDS as aQ, CircuitId as aR, ZeroKnowledgeProofRequest as aS, AUTHORIZATION_REQUEST_MESSAGE_TYPES as aT, AuthorizationRequestMessageTypes as aU, AuthorizationRequestMessageType as aV, AuthorizationRequestMessage as aW, ProofData as aX, ZeroKnowledgeProofResponse as aY, AuthorizationResponseMessage as aZ, CredentialQrCodeData as a_, VerificationOutput as aa, Scenario as ab, AbbreviatedWorkflowScenario as ac, TemplateScenario as ad, CreateTemplateScenario as ae, ComplianceImplementationStepsInput as af, SimplifiedCredential as ag, GetCredentialsRequest as ah, GetCredentialsResponse as ai, PolygonIdRequestData as aj, PolygonIdRequest as ak, PolygonIdResponseData as al, PolygonIdResponse as am, StartFlowRequest as an, IsVerifiedRequest as ao, IsVerifiedResponse as ap, GetTxAuthSigRequest as aq, GetTxAuthSigResponse as ar, GetTxAuthSigRequestTezos as as, GetTxAuthSigResponseTezos as at, HostRequestMessage as au, IdentityResponseMessage as av, GenerateWalletChallengeRequest as aw, AuthSession as ax, AuthSessionData as ay, ChallengeResponse as az, CustomerTypes as b, CreateAuthRequestProps as b$, QrCodeLinkWithSchemaType as b0, parseIden3Message as b1, parseSessionIdFromUrl as b2, QUERY_LOGIC_OPERATOR as b3, QueryLogicOperator as b4, OPERATORS as b5, Operator as b6, ZKPOperator as b7, operatorDisplayMap as b8, ARRAY_OPERATORS as b9, OperatorMappings as bA, OperatorToOLD_ChallengeQueryOperator as bB, OLD_ChallengeQueryOperatorToOperator as bC, OLD_QueryCredentialTypes as bD, OLD_QueryCredentialType as bE, getOldCredentialType as bF, getOldCredentialPath as bG, oldCredentialPathToDataLink as bH, TxAuthInput as bI, ApiTxAuthInput as bJ, TxSignatureResponse as bK, GetTxAuthDataSignatureResponse as bL, TezosTxAuthInput as bM, ApiTezosTxAuthInput as bN, TezosTxSignatureResponse as bO, GetTezosTxAuthDataSignatureResponse as bP, ExtendedTxAuthInput as bQ, ExtendedTezosTxAuthInput as bR, ExtendedTxAuthDataSignatureResponse as bS, ExtendedTezosTxAuthDataSignatureResponse as bT, AnyTxAuthDataSignatureResponse as bU, Eip155TxAuthInputJsSdk as bV, TezosTxAuthInputJsSdk as bW, AnyTxAuthInputJsSdk as bX, ZKPRequest as bY, ZKPRequestFromZKVerifier as bZ, PrivacyPreservingMonitoring as b_, ArrayOperator as ba, STRING_OPERATORS as bb, StringOperator as bc, NUMERIC_OPERATORS as bd, NumericOperator as be, BOOLEAN_OPERATORS as bf, BooleanOperator as bg, DATE_OPERATORS as bh, DateOperator as bi, SUPPORTED_TYPES as bj, SupportedType as bk, SupportedTypes as bl, IDInformationTfhe as bm, AllCredentialValues as bn, QueriesOptions as bo, QueryType as bp, QueryConfigTfhe as bq, QueryConfigSimplified as br, RuleResultQueryConfig as bs, PartialQueryConfigSimplified as bt, OLD_ChallengeQuerySchema as bu, QueryCredentialTypes as bv, QueryCredentialType as bw, ChallengeQuerySchema as bx, OLD_CHALLENGE_QUERY_OPERATORS as by, OLD_ChallengeQueryOperator as bz, CustomerType as c, AllScenarioExecutionAuthorizationData as c0, SCENARIO_AUTHORIZATION_STATUSES as c1, ScenarioAuthorizationStatus as c2, WalletSignatureResponse as c3, VerifyWalletChallengeRequest as c4, CredentialSchemas as c5, CredentialNames as c6, NexeraCredentialType as c7, getCredentialName as c8, CredentialType as c9, VerifiableCredential as ca, CredentialMediaType as cb, KycOnboardingLevel as d, KybOnboardingLevels as e, KybOnboardingLevel as f, CustomerOnboardingLevels as g, CustomerOnboardingLevel as h, CustomerStatuses as i, CustomerStatus as j, CUSTOMERS_CHARTS as k, CustomersChartType as l, CUSTOMER_TABLE_COLUMNS as m, CustomerTableColumn as n, CUSTOMER_AUTOMATION_REASONS as o, SdkVerificationResponseSchema as p, CloseScreenNotification as q, KycCompletionData as r, KycCompletionNotification as s, RuleEngineScenarioExecutionData as t, OnChainScenarioExecutionData as u, ScenarioExecutionData as v, ScenarioExecutionNotification as w, OcvSdkInitialized as x, StartCompletedNotification as y, IdentityNotificationMessage as z };