dcql 0.2.18 → 0.2.19

package/dist/index.d.mts

@@ -0,0 +1,2885 @@
+import * as v from 'valibot';
+
+declare function getCauseFromUnknown(cause: unknown): Error | undefined;
+declare function getDcqlErrorFromUnknown(cause: unknown): DcqlError;
+type DCQL_ERROR_CODE = 'PARSE_ERROR' | 'INTERNAL_SERVER_ERROR' | 'NOT_IMPLEMENTED' | 'BAD_REQUEST';
+declare class DcqlError extends Error {
+    readonly cause?: Error;
+    readonly code: DCQL_ERROR_CODE;
+    constructor(opts: {
+        message?: string;
+        code: DCQL_ERROR_CODE;
+        cause?: unknown;
+    });
+}
+
+declare class DcqlCredentialSetError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlUndefinedClaimSetIdError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlNonUniqueCredentialQueryIdsError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlParseError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlInvalidClaimsQueryIdError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlMissingClaimSetParseError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlInvalidPresentationRecordError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+declare class DcqlPresentationResultError extends DcqlError {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+
+type UnknownBaseSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;
+type EnsureOutputAssignableToInput<T extends UnknownBaseSchema> = v.InferOutput<T> extends v.InferInput<T> ? T : never;
+declare class Model<T extends UnknownBaseSchema> {
+    private input;
+    constructor(input: {
+        vModel: EnsureOutputAssignableToInput<T>;
+    });
+    get v(): EnsureOutputAssignableToInput<T>;
+    parse(input: T): DcqlParseError | v.InferOutput<T>;
+    safeParse(input: unknown): {
+        success: true;
+        output: v.InferOutput<T>;
+    } | {
+        success: false;
+        flattened: v.FlatErrors<T>;
+        error: v.ValiError<T>;
+    };
+    is(input: unknown): input is v.InferOutput<T>;
+}
+type InferModelTypes<T extends Model<any>> = T extends Model<infer U> ? {
+    Input: v.InferInput<U>;
+    Output: v.InferOutput<U>;
+} : never;
+
+type Json = string | number | boolean | null | {
+    [key: string]: Json;
+} | Json[];
+
+declare namespace DcqlMdocPresentation {
+    const vModel: v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>;
+    const model: Model<v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>>;
+    type Model = InferModelTypes<typeof model>;
+}
+type DcqlMdocPresentation = DcqlMdocPresentation.Model['Output'];
+declare namespace DcqlSdJwtVcPresentation {
+    const vModel: v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>;
+    const model: Model<v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>>;
+    type Model = InferModelTypes<typeof model>;
+}
+type DcqlSdJwtVcPresentation = DcqlSdJwtVcPresentation.Model['Output'];
+declare namespace DcqlW3cVcPresentation {
+    const vModel: v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>;
+    const model: Model<v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>>;
+    type Model = InferModelTypes<typeof model>;
+}
+type DcqlW3cVcPresentation = DcqlW3cVcPresentation.Model['Output'];
+declare namespace DcqlCredentialPresentation {
+    const model: Model<v.VariantSchema<"credential_format", [v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>], undefined>>;
+    type Model = InferModelTypes<typeof model>;
+}
+type DcqlCredentialPresentation = DcqlCredentialPresentation.Model['Output'];
+
+declare namespace DcqlQueryResult {
+    const vCredentialQueryResult: v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.UnionSchema<[v.UndefinedSchema<undefined>, v.ObjectSchema<{
+        readonly success: v.LiteralSchema<true, undefined>;
+        readonly typed: v.LiteralSchema<true, undefined>;
+        readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+        readonly input_credential_index: v.NumberSchema<undefined>;
+        readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+        readonly output: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+            readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+            readonly doctype: v.StringSchema<undefined>;
+            readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+            readonly vct: v.StringSchema<undefined>;
+            readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+            readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+        }, undefined>], undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly success: v.LiteralSchema<false, undefined>;
+        readonly typed: v.BooleanSchema<undefined>;
+        readonly output: v.UnknownSchema;
+        readonly issues: v.SchemaWithPipe<[v.ArraySchema<v.UnknownSchema, undefined>, v.CustomSchema<[unknown, ...unknown[]], undefined>]>;
+        readonly input_credential_index: v.NumberSchema<undefined>;
+        readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+    }, undefined>], undefined>, undefined>, undefined>, v.CustomSchema<[({
+        output: {
+            credential_format: "mso_mdoc";
+            doctype: string;
+            namespaces: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        } | {
+            credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+            vct: string;
+            claims: {
+                [x: string]: Json;
+            };
+        } | {
+            credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims: {
+                [x: string]: Json;
+            };
+        };
+        success: true;
+        typed: true;
+        claim_set_index: number | undefined;
+        input_credential_index: number;
+        issues?: undefined;
+    } | {
+        output: unknown;
+        issues: [unknown, ...unknown[]];
+        success: false;
+        typed: boolean;
+        claim_set_index: number | undefined;
+        input_credential_index: number;
+    } | undefined)[], ...({
+        output: {
+            credential_format: "mso_mdoc";
+            doctype: string;
+            namespaces: {
+                [x: string]: {
+                    [x: string]: unknown;
+                };
+            };
+        } | {
+            credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+            vct: string;
+            claims: {
+                [x: string]: Json;
+            };
+        } | {
+            credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims: {
+                [x: string]: Json;
+            };
+        };
+        success: true;
+        typed: true;
+        claim_set_index: number | undefined;
+        input_credential_index: number;
+        issues?: undefined;
+    } | {
+        output: unknown;
+        issues: [unknown, ...unknown[]];
+        success: false;
+        typed: boolean;
+        claim_set_index: number | undefined;
+        input_credential_index: number;
+    } | undefined)[][]], undefined>]>;
+    type CredentialQueryResult = v.InferOutput<typeof vCredentialQueryResult>;
+    const vModel: v.ObjectSchema<{
+        readonly credentials: v.SchemaWithPipe<[v.ArraySchema<v.VariantSchema<"format", [v.ObjectSchema<{
+            readonly format: v.SchemaWithPipe<[v.LiteralSchema<"mso_mdoc", undefined>, v.DescriptionAction<"mso_mdoc", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+            readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+                readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+            readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.ObjectSchema<{
+                readonly doctype_value: v.SchemaWithPipe<[v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "OPTIONAL. String that specifies an allowed value for the doctype of the requested Verifiable Credential.">]>;
+            }, undefined>, undefined>, v.DescriptionAction<{
+                doctype_value?: string | undefined;
+            } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly format: v.SchemaWithPipe<[v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>, v.DescriptionAction<"vc+sd-jwt" | "dc+sd-jwt", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+            readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+            readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ObjectSchema<{
+                readonly vct_values: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.DescriptionAction<{
+                vct_values?: string[] | undefined;
+            }, "OPTIONAL. An array of strings that specifies allowed values for the type of the requested Verifiable Credential.">]>, undefined>, v.DescriptionAction<{
+                vct_values?: string[] | undefined;
+            } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly format: v.PicklistSchema<["jwt_vc_json", "jwt_vc_json-ld"], undefined>;
+            readonly claims: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>], undefined>, undefined>, v.CustomSchema<[{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]], undefined>, v.DescriptionAction<[{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]], "REQUIRED. A non-empty array of Credential Queries that specify the requested Verifiable Credentials.">]>;
+        readonly credential_matches: v.RecordSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, v.UnionSchema<[v.ObjectSchema<{
+            readonly all: v.SchemaWithPipe<[v.ArraySchema<v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.UndefinedSchema<undefined>, v.ObjectSchema<{
+                readonly success: v.LiteralSchema<true, undefined>;
+                readonly typed: v.LiteralSchema<true, undefined>;
+                readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+                readonly input_credential_index: v.NumberSchema<undefined>;
+                readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+                readonly output: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+                    readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+                    readonly doctype: v.StringSchema<undefined>;
+                    readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+                    readonly vct: v.StringSchema<undefined>;
+                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+                }, undefined>], undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly success: v.LiteralSchema<false, undefined>;
+                readonly typed: v.BooleanSchema<undefined>;
+                readonly output: v.UnknownSchema;
+                readonly issues: v.SchemaWithPipe<[v.ArraySchema<v.UnknownSchema, undefined>, v.CustomSchema<[unknown, ...unknown[]], undefined>]>;
+                readonly input_credential_index: v.NumberSchema<undefined>;
+                readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+            }, undefined>], undefined>, undefined>, v.CustomSchema<[{
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined, ...({
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined)[]], undefined>]>, undefined>, v.CustomSchema<[[{
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined, ...({
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined)[]], ...[{
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined, ...({
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined)[]][]], undefined>]>;
+            readonly success: v.LiteralSchema<true, undefined>;
+            readonly typed: v.LiteralSchema<true, undefined>;
+            readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+            readonly input_credential_index: v.NumberSchema<undefined>;
+            readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+            readonly output: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+                readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+                readonly doctype: v.StringSchema<undefined>;
+                readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+                readonly vct: v.StringSchema<undefined>;
+                readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+                readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+            }, undefined>], undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly success: v.LiteralSchema<false, undefined>;
+            readonly all: v.SchemaWithPipe<[v.ArraySchema<v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.UndefinedSchema<undefined>, v.ObjectSchema<{
+                readonly success: v.LiteralSchema<true, undefined>;
+                readonly typed: v.LiteralSchema<true, undefined>;
+                readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+                readonly input_credential_index: v.NumberSchema<undefined>;
+                readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+                readonly output: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+                    readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+                    readonly doctype: v.StringSchema<undefined>;
+                    readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+                    readonly vct: v.StringSchema<undefined>;
+                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+                }, undefined>], undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly success: v.LiteralSchema<false, undefined>;
+                readonly typed: v.BooleanSchema<undefined>;
+                readonly output: v.UnknownSchema;
+                readonly issues: v.SchemaWithPipe<[v.ArraySchema<v.UnknownSchema, undefined>, v.CustomSchema<[unknown, ...unknown[]], undefined>]>;
+                readonly input_credential_index: v.NumberSchema<undefined>;
+                readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+            }, undefined>], undefined>, undefined>, v.CustomSchema<[{
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined, ...({
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined)[]], undefined>]>, undefined>, v.CustomSchema<[[{
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined, ...({
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined)[]], ...[{
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined, ...({
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                issues?: undefined;
+            } | {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+            } | undefined)[]][]], undefined>]>;
+        }, undefined>], undefined>, undefined>;
+        readonly credential_sets: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly matching_options: v.UnionSchema<[v.UndefinedSchema<undefined>, v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>], undefined>;
+            readonly options: v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>, v.DescriptionAction<[string[], ...string[][]], "REQUIRED. A non-empty array, where each value in the array is a list of Credential Query identifiers representing one set of Credentials that satisfies the use case.">]>;
+            readonly required: v.SchemaWithPipe<[v.OptionalSchema<v.BooleanSchema<undefined>, true>, v.DescriptionAction<boolean, "OPTIONAL. Boolean which indicates whether this set of Credentials is required to satisfy the particular use case at the Verifier. If omitted, the default value is 'true'.">]>;
+            readonly purpose: v.SchemaWithPipe<[v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>, undefined>, v.DescriptionAction<string | number | {
+                [x: string]: unknown;
+            } | undefined, "OPTIONAL. A string, number or object specifying the purpose of the query.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]], undefined>, v.DescriptionAction<[{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]], "OPTIONAL. A non-empty array of credential set queries that specifies additional constraints on which of the requested Verifiable Credentials to return.">]>, undefined>;
+        readonly canBeSatisfied: v.BooleanSchema<undefined>;
+    }, undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Output = v.InferOutput<typeof vModel>;
+    type CredentialMatch = Input['credential_matches'][number];
+    type CredentialMatchRecord = Input['credential_matches'];
+}
+type DcqlQueryResult = DcqlQueryResult.Output;
+
+declare namespace DcqlMdocCredential {
+    const vNamespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    const vModel: v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>;
+    const model: Model<v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>>;
+    type Model = InferModelTypes<typeof model>;
+    type NameSpaces = v.InferOutput<typeof vNamespaces>;
+}
+type DcqlMdocCredential = DcqlMdocCredential.Model['Output'];
+declare namespace DcqlSdJwtVcCredential {
+    const vClaims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    const vModel: v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>;
+    const model: Model<v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>>;
+    type Model = InferModelTypes<typeof model>;
+    type Claims = Model['Output']['claims'];
+}
+type DcqlSdJwtVcCredential = DcqlSdJwtVcCredential.Model['Output'];
+declare namespace DcqlW3cVcCredential {
+    const vClaims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    const vModel: v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>;
+    const model: Model<v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>>;
+    type Model = InferModelTypes<typeof model>;
+    type Claims = Model['Output']['claims'];
+}
+type DcqlW3cVcCredential = DcqlW3cVcCredential.Model['Output'];
+declare namespace DcqlCredential {
+    const vModel: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>], undefined>;
+    const vParseSuccess: v.ObjectSchema<{
+        readonly success: v.LiteralSchema<true, undefined>;
+        readonly typed: v.LiteralSchema<true, undefined>;
+        readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+        readonly input_credential_index: v.NumberSchema<undefined>;
+        readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+        readonly output: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+            readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+            readonly doctype: v.StringSchema<undefined>;
+            readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+            readonly vct: v.StringSchema<undefined>;
+            readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+            readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+        }, undefined>], undefined>;
+    }, undefined>;
+    const vParseFailure: v.ObjectSchema<{
+        readonly success: v.LiteralSchema<false, undefined>;
+        readonly typed: v.BooleanSchema<undefined>;
+        readonly output: v.UnknownSchema;
+        readonly issues: v.SchemaWithPipe<[v.ArraySchema<v.UnknownSchema, undefined>, v.CustomSchema<[unknown, ...unknown[]], undefined>]>;
+        readonly input_credential_index: v.NumberSchema<undefined>;
+        readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+    }, undefined>;
+    const model: Model<v.VariantSchema<"credential_format", [v.ObjectSchema<{
+        readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+        readonly doctype: v.StringSchema<undefined>;
+        readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+        readonly vct: v.StringSchema<undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+        readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+    }, undefined>], undefined>>;
+    type Model = InferModelTypes<typeof model>;
+}
+type DcqlCredential = DcqlCredential.Model['Output'];
+
+/**
+ * The Digital Credentials Query Language (DCQL, pronounced [ˈdakl̩]) is a
+ * JSON-encoded query language that allows the Verifier to request Verifiable
+ * Presentations that match the query. The Verifier MAY encode constraints on the
+ * combinations of credentials and claims that are requested. The Wallet evaluates
+ * the query against the Verifiable Credentials it holds and returns Verifiable
+ * Presentations matching the query.
+ */
+declare namespace DcqlQuery {
+    const vModel: v.ObjectSchema<{
+        readonly credentials: v.SchemaWithPipe<[v.ArraySchema<v.VariantSchema<"format", [v.ObjectSchema<{
+            readonly format: v.SchemaWithPipe<[v.LiteralSchema<"mso_mdoc", undefined>, v.DescriptionAction<"mso_mdoc", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+            readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+                readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+            readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.ObjectSchema<{
+                readonly doctype_value: v.SchemaWithPipe<[v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "OPTIONAL. String that specifies an allowed value for the doctype of the requested Verifiable Credential.">]>;
+            }, undefined>, undefined>, v.DescriptionAction<{
+                doctype_value?: string | undefined;
+            } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly format: v.SchemaWithPipe<[v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>, v.DescriptionAction<"vc+sd-jwt" | "dc+sd-jwt", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+            readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+            readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ObjectSchema<{
+                readonly vct_values: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.DescriptionAction<{
+                vct_values?: string[] | undefined;
+            }, "OPTIONAL. An array of strings that specifies allowed values for the type of the requested Verifiable Credential.">]>, undefined>, v.DescriptionAction<{
+                vct_values?: string[] | undefined;
+            } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly format: v.PicklistSchema<["jwt_vc_json", "jwt_vc_json-ld"], undefined>;
+            readonly claims: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>], undefined>, undefined>, v.CustomSchema<[{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]], undefined>, v.DescriptionAction<[{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]], "REQUIRED. A non-empty array of Credential Queries that specify the requested Verifiable Credentials.">]>;
+        readonly credential_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly options: v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>, v.DescriptionAction<[string[], ...string[][]], "REQUIRED. A non-empty array, where each value in the array is a list of Credential Query identifiers representing one set of Credentials that satisfies the use case.">]>;
+            readonly required: v.SchemaWithPipe<[v.OptionalSchema<v.BooleanSchema<undefined>, true>, v.DescriptionAction<boolean, "OPTIONAL. Boolean which indicates whether this set of Credentials is required to satisfy the particular use case at the Verifier. If omitted, the default value is 'true'.">]>;
+            readonly purpose: v.SchemaWithPipe<[v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>, undefined>, v.DescriptionAction<string | number | {
+                [x: string]: unknown;
+            } | undefined, "OPTIONAL. A string, number or object specifying the purpose of the query.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            options: [string[], ...string[][]];
+            required: boolean;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+            options: [string[], ...string[][]];
+            required: boolean;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]] | undefined, "OPTIONAL. A non-empty array of credential set queries that specifies additional constraints on which of the requested Verifiable Credentials to return.">]>;
+    }, undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Output = v.InferOutput<typeof vModel>;
+    const validate: (dcqlQuery: Output) => void;
+    const query: (dcqlQuery: Output, credentials: DcqlCredential[]) => {
+        credentials: [{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]];
+        credential_matches: {
+            [x: string]: {
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                input_credential_index: number;
+                all: [[{
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined, ...({
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined)[]], ...[{
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined, ...({
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined)[]][]];
+                issues?: undefined;
+            } | {
+                success: false;
+                all: [[{
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined, ...({
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined)[]], ...[{
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined, ...({
+                    output: {
+                        credential_format: "mso_mdoc";
+                        doctype: string;
+                        namespaces: {
+                            [x: string]: {
+                                [x: string]: unknown;
+                            };
+                        };
+                    } | {
+                        credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                        vct: string;
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    } | {
+                        credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                        claims: {
+                            [x: string]: Json;
+                        };
+                    };
+                    success: true;
+                    typed: true;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                    issues?: undefined;
+                } | {
+                    output: unknown;
+                    issues: [unknown, ...unknown[]];
+                    success: false;
+                    typed: boolean;
+                    claim_set_index: number | undefined;
+                    input_credential_index: number;
+                } | undefined)[]][]];
+            };
+        };
+        canBeSatisfied: boolean;
+        credential_sets?: [{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]] | undefined;
+    };
+    const parse: (input: Input) => {
+        credentials: [{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]];
+        credential_sets?: [{
+            options: [string[], ...string[][]];
+            required: boolean;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]] | undefined;
+    };
+}
+type DcqlQuery = DcqlQuery.Output;
+
+declare namespace DcqlPresentationResult {
+    const vModel: v.ObjectSchema<{
+        readonly invalid_matches: v.UnionSchema<[v.RecordSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, v.ObjectSchema<{
+            readonly presentation_id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+            readonly output: v.UnknownSchema;
+            readonly issues: v.SchemaWithPipe<[v.ArraySchema<v.UnknownSchema, undefined>, v.CustomSchema<[unknown, ...unknown[]], undefined>]>;
+            readonly success: v.LiteralSchema<false, undefined>;
+            readonly typed: v.BooleanSchema<undefined>;
+            readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+        }, undefined>, undefined>, v.UndefinedSchema<undefined>], undefined>;
+        readonly valid_matches: v.RecordSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, v.ObjectSchema<{
+            readonly presentation_id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+            readonly output: v.VariantSchema<"credential_format", [v.ObjectSchema<{
+                readonly credential_format: v.LiteralSchema<"mso_mdoc", undefined>;
+                readonly doctype: v.StringSchema<undefined>;
+                readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly credential_format: v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>;
+                readonly vct: v.StringSchema<undefined>;
+                readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly credential_format: v.PicklistSchema<["jwt_vc_json-ld", "jwt_vc_json"], undefined>;
+                readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>;
+            }, undefined>], undefined>;
+            readonly success: v.LiteralSchema<true, undefined>;
+            readonly typed: v.LiteralSchema<true, undefined>;
+            readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
+        }, undefined>, undefined>;
+        readonly credentials: v.SchemaWithPipe<[v.ArraySchema<v.VariantSchema<"format", [v.ObjectSchema<{
+            readonly format: v.SchemaWithPipe<[v.LiteralSchema<"mso_mdoc", undefined>, v.DescriptionAction<"mso_mdoc", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+            readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+                readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+            readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.ObjectSchema<{
+                readonly doctype_value: v.SchemaWithPipe<[v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "OPTIONAL. String that specifies an allowed value for the doctype of the requested Verifiable Credential.">]>;
+            }, undefined>, undefined>, v.DescriptionAction<{
+                doctype_value?: string | undefined;
+            } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly format: v.SchemaWithPipe<[v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>, v.DescriptionAction<"vc+sd-jwt" | "dc+sd-jwt", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+            readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+            readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ObjectSchema<{
+                readonly vct_values: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>, v.DescriptionAction<{
+                vct_values?: string[] | undefined;
+            }, "OPTIONAL. An array of strings that specifies allowed values for the type of the requested Verifiable Credential.">]>, undefined>, v.DescriptionAction<{
+                vct_values?: string[] | undefined;
+            } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly format: v.PicklistSchema<["jwt_vc_json", "jwt_vc_json-ld"], undefined>;
+            readonly claims: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+                readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+                readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+            }, undefined>, undefined>, v.CustomSchema<[{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]], undefined>]>, undefined>;
+            readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+            readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+        }, undefined>], undefined>, undefined>, v.CustomSchema<[{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]], undefined>, v.DescriptionAction<[{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]], "REQUIRED. A non-empty array of Credential Queries that specify the requested Verifiable Credentials.">]>;
+        readonly credential_sets: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly matching_options: v.UnionSchema<[v.UndefinedSchema<undefined>, v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>], undefined>;
+            readonly options: v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>, v.DescriptionAction<[string[], ...string[][]], "REQUIRED. A non-empty array, where each value in the array is a list of Credential Query identifiers representing one set of Credentials that satisfies the use case.">]>;
+            readonly required: v.SchemaWithPipe<[v.OptionalSchema<v.BooleanSchema<undefined>, true>, v.DescriptionAction<boolean, "OPTIONAL. Boolean which indicates whether this set of Credentials is required to satisfy the particular use case at the Verifier. If omitted, the default value is 'true'.">]>;
+            readonly purpose: v.SchemaWithPipe<[v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>, undefined>, v.DescriptionAction<string | number | {
+                [x: string]: unknown;
+            } | undefined, "OPTIONAL. A string, number or object specifying the purpose of the query.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]], undefined>, v.DescriptionAction<[{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]], "OPTIONAL. A non-empty array of credential set queries that specifies additional constraints on which of the requested Verifiable Credentials to return.">]>, undefined>;
+        readonly canBeSatisfied: v.BooleanSchema<undefined>;
+    }, undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Output = v.InferOutput<typeof vModel>;
+    const parse: (input: Input | DcqlQueryResult) => {
+        credentials: [{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]];
+        canBeSatisfied: boolean;
+        invalid_matches: {
+            [x: string]: {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                presentation_id: string;
+            };
+        } | undefined;
+        valid_matches: {
+            [x: string]: {
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                presentation_id: string;
+            };
+        };
+        credential_sets?: [{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]] | undefined;
+    };
+    /**
+     * Query if the presentation record can be satisfied by the provided presentations
+     * considering the dcql query
+     *
+     * @param dcqlQuery
+     * @param dcqlPresentation
+     */
+    const fromDcqlPresentation: (dcqlPresentation: Record<string, DcqlCredentialPresentation>, ctx: {
+        dcqlQuery: DcqlQuery;
+    }) => Output;
+    const validate: (dcqlQueryResult: DcqlPresentationResult) => {
+        credentials: [{
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claims?: [{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                namespace: string;
+                claim_name: string;
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt" | "dc+sd-jwt";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json-ld" | "jwt_vc_json";
+            claims?: [{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }, ...{
+                path: (string | number | null)[];
+                values?: (string | number | boolean)[] | undefined;
+                id?: string | undefined;
+            }[]] | undefined;
+            claim_sets?: [string[], ...string[][]] | undefined;
+        })[]];
+        canBeSatisfied: boolean;
+        invalid_matches: {
+            [x: string]: {
+                output: unknown;
+                issues: [unknown, ...unknown[]];
+                success: false;
+                typed: boolean;
+                claim_set_index: number | undefined;
+                presentation_id: string;
+            };
+        } | undefined;
+        valid_matches: {
+            [x: string]: {
+                output: {
+                    credential_format: "mso_mdoc";
+                    doctype: string;
+                    namespaces: {
+                        [x: string]: {
+                            [x: string]: unknown;
+                        };
+                    };
+                } | {
+                    credential_format: "vc+sd-jwt" | "dc+sd-jwt";
+                    vct: string;
+                    claims: {
+                        [x: string]: Json;
+                    };
+                } | {
+                    credential_format: "jwt_vc_json-ld" | "jwt_vc_json";
+                    claims: {
+                        [x: string]: Json;
+                    };
+                };
+                success: true;
+                typed: true;
+                claim_set_index: number | undefined;
+                presentation_id: string;
+            };
+        };
+        credential_sets?: [{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }, ...{
+            options: [string[], ...string[][]];
+            required: boolean;
+            matching_options: [string[], ...string[][]] | undefined;
+            purpose?: string | number | {
+                [x: string]: unknown;
+            } | undefined;
+        }[]] | undefined;
+    };
+}
+type DcqlPresentationResult = DcqlPresentationResult.Output;
+
+declare namespace DcqlPresentation {
+    const vModel: v.RecordSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<Json, Json, v.BaseIssue<unknown>>, undefined>], undefined>, undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Output = v.InferOutput<typeof vModel>;
+    const parse: (input: Input | string) => {
+        [x: string]: string | {
+            [x: string]: Json;
+        };
+    };
+    const encode: (input: Output) => string;
+}
+type DcqlPresentation = DcqlPresentation.Output;
+
+declare const runDcqlQuery: (dcqlQuery: DcqlQuery.Output, ctx: {
+    credentials: DcqlCredential[];
+    presentation: boolean;
+}) => DcqlQueryResult;
+
+/**
+ * Specifies claims withing a requested Credential.
+ */
+declare namespace DcqlClaimsQuery {
+    const vValue: v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>;
+    const vPath: v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>;
+    const vW3cSdJwtVc: v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+        readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+        readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+    }, undefined>;
+    type W3cAndSdJwtVc = v.InferOutput<typeof vW3cSdJwtVc>;
+    const vMdoc: v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+        readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+        readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+        readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+    }, undefined>;
+    type Mdoc = v.InferOutput<typeof vMdoc>;
+    const vModel: v.UnionSchema<[v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+        readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+        readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+        readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+        readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+        readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+    }, undefined>], undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Out = v.InferOutput<typeof vModel>;
+}
+type DcqlClaimsQuery = DcqlClaimsQuery.Out;
+
+/**
+ * A Credential Query is an object representing a request for a presentation of one Credential.
+ */
+declare namespace DcqlCredentialQuery {
+    const vMdoc: v.ObjectSchema<{
+        readonly format: v.SchemaWithPipe<[v.LiteralSchema<"mso_mdoc", undefined>, v.DescriptionAction<"mso_mdoc", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+        readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+            readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+            readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+            readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+        readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.ObjectSchema<{
+            readonly doctype_value: v.SchemaWithPipe<[v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "OPTIONAL. String that specifies an allowed value for the doctype of the requested Verifiable Credential.">]>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            doctype_value?: string | undefined;
+        } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+        readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+        readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+    }, undefined>;
+    type Mdoc = v.InferOutput<typeof vMdoc>;
+    const vSdJwtVc: v.ObjectSchema<{
+        readonly format: v.SchemaWithPipe<[v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>, v.DescriptionAction<"vc+sd-jwt" | "dc+sd-jwt", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+        readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+            readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+            readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+        readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ObjectSchema<{
+            readonly vct_values: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>, v.DescriptionAction<{
+            vct_values?: string[] | undefined;
+        }, "OPTIONAL. An array of strings that specifies allowed values for the type of the requested Verifiable Credential.">]>, undefined>, v.DescriptionAction<{
+            vct_values?: string[] | undefined;
+        } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+        readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+        readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+    }, undefined>;
+    type SdJwtVc = v.InferOutput<typeof vSdJwtVc>;
+    const vW3cVc: v.ObjectSchema<{
+        readonly format: v.PicklistSchema<["jwt_vc_json", "jwt_vc_json-ld"], undefined>;
+        readonly claims: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+            readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+            readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]], undefined>]>, undefined>;
+        readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+        readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+    }, undefined>;
+    type W3cVc = v.InferOutput<typeof vW3cVc>;
+    const vModel: v.VariantSchema<"format", [v.ObjectSchema<{
+        readonly format: v.SchemaWithPipe<[v.LiteralSchema<"mso_mdoc", undefined>, v.DescriptionAction<"mso_mdoc", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+        readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+            readonly namespace: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the namespace of the data element within the mdoc, e.g., org.iso.18013.5.1.">]>;
+            readonly claim_name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.DescriptionAction<string, "A string that specifies the data element identifier of the data element within the provided namespace in the mdoc, e.g., first_name.">]>;
+            readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            namespace: string;
+            claim_name: string;
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+        readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.ObjectSchema<{
+            readonly doctype_value: v.SchemaWithPipe<[v.OptionalSchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string | undefined, "OPTIONAL. String that specifies an allowed value for the doctype of the requested Verifiable Credential.">]>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            doctype_value?: string | undefined;
+        } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+        readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+        readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly format: v.SchemaWithPipe<[v.PicklistSchema<["vc+sd-jwt", "dc+sd-jwt"], undefined>, v.DescriptionAction<"vc+sd-jwt" | "dc+sd-jwt", "REQUIRED. A string that specifies the format of the requested Verifiable Credential.">]>;
+        readonly claims: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+            readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+            readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]], undefined>]>, undefined>, v.DescriptionAction<[{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]] | undefined, "OPTIONAL. A non-empty array of objects as that specifies claims in the requested Credential.">]>;
+        readonly meta: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ObjectSchema<{
+            readonly vct_values: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>, v.DescriptionAction<{
+            vct_values?: string[] | undefined;
+        }, "OPTIONAL. An array of strings that specifies allowed values for the type of the requested Verifiable Credential.">]>, undefined>, v.DescriptionAction<{
+            vct_values?: string[] | undefined;
+        } | undefined, "OPTIONAL. An object defining additional properties requested by the Verifier that apply to the metadata and validity data of the Credential.">]>;
+        readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+        readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+    }, undefined>, v.ObjectSchema<{
+        readonly format: v.PicklistSchema<["jwt_vc_json", "jwt_vc_json-ld"], undefined>;
+        readonly claims: v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.DescriptionAction<string | undefined, "A string identifying the particular claim. The value MUST be a non-empty string consisting of alphanumeric, underscore (_) or hyphen (-) characters. Within the particular claims array, the same id MUST NOT be present more than once.">]>;
+            readonly path: v.SchemaWithPipe<[v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.NullSchema<undefined>], undefined>, undefined>, v.DescriptionAction<(string | number | null)[], "A non-empty array representing a claims path pointer that specifies the path to a claim within the Verifiable Credential.">]>;
+            readonly values: v.SchemaWithPipe<[v.OptionalSchema<v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<[v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.BooleanSchema<undefined>], undefined>, undefined>, undefined>, v.DescriptionAction<(string | number | boolean)[] | undefined, "An array of strings, integers or boolean values that specifies the expected values of the claim. If the values property is present, the Wallet SHOULD return the claim only if the type and value of the claim both match for at least one of the elements in the array.">]>;
+        }, undefined>, undefined>, v.CustomSchema<[{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }, ...{
+            path: (string | number | null)[];
+            values?: (string | number | boolean)[] | undefined;
+            id?: string | undefined;
+        }[]], undefined>]>, undefined>;
+        readonly id: v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.DescriptionAction<string, "REQUIRED. A string identifying the Credential in the response and, if provided, the constraints in 'credential_sets'.">]>;
+        readonly claim_sets: v.SchemaWithPipe<[v.OptionalSchema<v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>]>, undefined>, v.DescriptionAction<[string[], ...string[][]] | undefined, "OPTIONAL. A non-empty array containing arrays of identifiers for elements in 'claims' that specifies which combinations of 'claims' for the Credential are requested.">]>;
+    }, undefined>], undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Output = v.InferOutput<typeof vModel>;
+    const validate: (credentialQuery: Output) => void;
+}
+type DcqlCredentialQuery = DcqlCredentialQuery.Output;
+
+/**
+ * A Credential Set Query is an object representing
+ * a request for one or more credentials to satisfy a particular use case with the Verifier.
+ */
+declare namespace CredentialSetQuery {
+    const vModel: v.ObjectSchema<{
+        readonly options: v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, undefined>, v.CustomSchema<[string[], ...string[][]], undefined>, v.DescriptionAction<[string[], ...string[][]], "REQUIRED. A non-empty array, where each value in the array is a list of Credential Query identifiers representing one set of Credentials that satisfies the use case.">]>;
+        readonly required: v.SchemaWithPipe<[v.OptionalSchema<v.BooleanSchema<undefined>, true>, v.DescriptionAction<boolean, "OPTIONAL. Boolean which indicates whether this set of Credentials is required to satisfy the particular use case at the Verifier. If omitted, the default value is 'true'.">]>;
+        readonly purpose: v.SchemaWithPipe<[v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>, undefined>, v.DescriptionAction<string | number | {
+            [x: string]: unknown;
+        } | undefined, "OPTIONAL. A string, number or object specifying the purpose of the query.">]>;
+    }, undefined>;
+    type Input = v.InferInput<typeof vModel>;
+    type Output = v.InferOutput<typeof vModel>;
+}
+type CredentialSetQuery = CredentialSetQuery.Output;
+
+export { CredentialSetQuery, DcqlClaimsQuery, DcqlCredential, DcqlCredentialPresentation, DcqlCredentialQuery, DcqlCredentialSetError, DcqlError, DcqlInvalidClaimsQueryIdError, DcqlInvalidPresentationRecordError, DcqlMdocCredential, DcqlMdocPresentation, DcqlMissingClaimSetParseError, DcqlNonUniqueCredentialQueryIdsError, DcqlParseError, DcqlPresentation, DcqlPresentationResult, DcqlPresentationResultError, DcqlQuery, DcqlQueryResult, DcqlSdJwtVcCredential, DcqlSdJwtVcPresentation, DcqlUndefinedClaimSetIdError, DcqlW3cVcCredential, DcqlW3cVcPresentation, getCauseFromUnknown, getDcqlErrorFromUnknown, runDcqlQuery };