npm - dcql - Versions diffs - 0.2.10 → 0.2.12 - Mend

dcql 0.2.10 → 0.2.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (56) hide show

package/dist/src/dcql-presentation/index.d.ts CHANGED Viewed

@@ -1,3 +1,3 @@
-export * from './m-dcql-presentation-query.js';
-export * from './m-dcql-presentation-record.js';
+export * from './m-dcql-presentation-result.js';
+export * from './m-dcql-presentation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/dcql-presentation/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dcql-presentation/index.ts"],"names":[],"mappings":"AAAA,cAAc,~~gCAAgC~~,CAAC;~~AAC/C~~,cAAc,~~iCAAiC~~,CAAC"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dcql-presentation/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC"}

package/dist/src/dcql-presentation/index.js CHANGED Viewed

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./m-dcql-presentation-query.js"), exports);
-__exportStar(require("./m-dcql-presentation-record.js"), exports);
+__exportStar(require("./m-dcql-presentation-result.js"), exports);
+__exportStar(require("./m-dcql-presentation.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/dcql-presentation/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/dcql-presentation/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,~~iEAA+C~~;~~AAC/C~~,~~kEAAgD~~"}
1	+ {"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/dcql-presentation/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kEAAgD;AAChD,2DAAyC"}

package/dist/src/dcql-presentation/{m-dcql-presentation-query.d.ts → m-dcql-presentation-result.d.ts} RENAMED Viewed

@@ -1,12 +1,19 @@
 import * as v from 'valibot';
 import { DcqlQueryResult } from '../dcql-query-result/m-dcql-query-result.js';
 import type { DcqlQuery } from '../dcql-query/m-dcql-query.js';
-import type { DcqlPresentationRepresentation } from '../u-dcql-credential-representation.js';
-export declare namespace DcqlPresentationQuery {
+import type { DcqlCredentialPresentation } from '../u-dcql-credential-presentation.js';
+export declare namespace DcqlPresentationResult {
     const vModel: v.ObjectSchema<{
-        readonly canBeSatisfied: v.LiteralSchema<true, undefined>;
-        readonly presentation_matches: v.RecordSchema<v.SchemaWithPipe<[v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, v.ObjectSchema<{
-            readonly presentation_index: v.NumberSchema<undefined>;
+        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 success: v.LiteralSchema<false, undefined>;
+            readonly typed: v.BooleanSchema<undefined>;
+            readonly issues: v.SchemaWithPipe<[v.ArraySchema<v.UnknownSchema, undefined>, v.CustomSchema<[unknown, ...unknown[]], 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.UnionSchema<[v.ObjectSchema<{
                 readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
             }, undefined>, v.ObjectSchema<{
@@ -293,195 +300,6 @@ export declare namespace DcqlPresentationQuery {
                 id?: string | undefined;
             }[]] | 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.ArraySchema<v.UnionSchema<[v.UndefinedSchema<undefined>, v.ObjectSchema<{
-                readonly output: v.UnionSchema<[v.ObjectSchema<{
-                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly vct: v.StringSchema<undefined>;
-                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly docType: v.StringSchema<undefined>;
-                    readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
-                }, undefined>], undefined>;
-                readonly success: v.LiteralSchema<true, undefined>;
-                readonly typed: v.LiteralSchema<true, undefined>;
-                readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, never>;
-                readonly credential_index: v.NumberSchema<undefined>;
-                readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<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 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: unknown;
-                success: false;
-                typed: boolean;
-                issues: [unknown, ...unknown[]];
-                claim_set_index: number | undefined;
-                credential_index: number;
-            } | {
-                output: {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                } | {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                    vct: string;
-                } | {
-                    docType: string;
-                    namespaces: {
-                        [x: string]: {
-                            [x: string]: unknown;
-                        };
-                    };
-                };
-                success: true;
-                typed: true;
-                claim_set_index: number | undefined;
-                credential_index: number;
-                issues?: undefined;
-            } | undefined)[], ...({
-                output: unknown;
-                success: false;
-                typed: boolean;
-                issues: [unknown, ...unknown[]];
-                claim_set_index: number | undefined;
-                credential_index: number;
-            } | {
-                output: {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                } | {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                    vct: string;
-                } | {
-                    docType: string;
-                    namespaces: {
-                        [x: string]: {
-                            [x: string]: unknown;
-                        };
-                    };
-                };
-                success: true;
-                typed: true;
-                claim_set_index: number | undefined;
-                credential_index: number;
-                issues?: undefined;
-            } | undefined)[][]], undefined>]>;
-            readonly output: v.UnionSchema<[v.ObjectSchema<{
-                readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly vct: v.StringSchema<undefined>;
-                readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly docType: v.StringSchema<undefined>;
-                readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
-            }, undefined>], undefined>;
-            readonly success: v.LiteralSchema<true, undefined>;
-            readonly typed: v.LiteralSchema<true, undefined>;
-            readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, never>;
-            readonly credential_index: v.NumberSchema<undefined>;
-            readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<undefined>], undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly all: v.SchemaWithPipe<[v.ArraySchema<v.ArraySchema<v.UnionSchema<[v.UndefinedSchema<undefined>, v.ObjectSchema<{
-                readonly output: v.UnionSchema<[v.ObjectSchema<{
-                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly vct: v.StringSchema<undefined>;
-                    readonly claims: v.RecordSchema<v.StringSchema<undefined>, v.GenericSchema<import("../u-dcql.js").Json, import("../u-dcql.js").Json, v.BaseIssue<unknown>>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly docType: v.StringSchema<undefined>;
-                    readonly namespaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
-                }, undefined>], undefined>;
-                readonly success: v.LiteralSchema<true, undefined>;
-                readonly typed: v.LiteralSchema<true, undefined>;
-                readonly issues: v.OptionalSchema<v.UndefinedSchema<undefined>, never>;
-                readonly credential_index: v.NumberSchema<undefined>;
-                readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<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 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: unknown;
-                success: false;
-                typed: boolean;
-                issues: [unknown, ...unknown[]];
-                claim_set_index: number | undefined;
-                credential_index: number;
-            } | {
-                output: {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                } | {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                    vct: string;
-                } | {
-                    docType: string;
-                    namespaces: {
-                        [x: string]: {
-                            [x: string]: unknown;
-                        };
-                    };
-                };
-                success: true;
-                typed: true;
-                claim_set_index: number | undefined;
-                credential_index: number;
-                issues?: undefined;
-            } | undefined)[], ...({
-                output: unknown;
-                success: false;
-                typed: boolean;
-                issues: [unknown, ...unknown[]];
-                claim_set_index: number | undefined;
-                credential_index: number;
-            } | {
-                output: {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                } | {
-                    claims: {
-                        [x: string]: import("../u-dcql.js").Json;
-                    };
-                    vct: string;
-                } | {
-                    docType: string;
-                    namespaces: {
-                        [x: string]: {
-                            [x: string]: unknown;
-                        };
-                    };
-                };
-                success: true;
-                typed: true;
-                claim_set_index: number | undefined;
-                credential_index: number;
-                issues?: undefined;
-            } | undefined)[][]], undefined>]>;
-            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 credential_index: v.NumberSchema<undefined>;
-            readonly claim_set_index: v.UnionSchema<[v.NumberSchema<undefined>, v.UndefinedSchema<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.">]>;
@@ -518,13 +336,10 @@ export declare namespace DcqlPresentationQuery {
                 [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.">]>, never>;
+        readonly canBeSatisfied: v.BooleanSchema<undefined>;
     }, undefined>;
     type Input = v.InferInput<typeof vModel>;
     type Output = v.InferOutput<typeof vModel>;
-    type UnknownResult = (DcqlQueryResult & {
-        canBeSatisfied: false;
-        presentation_matches?: undefined;
-    }) | DcqlPresentationQuery;
     const parse: (input: Input | DcqlQueryResult) => {
         credentials: [{
             id: string;
@@ -621,7 +436,18 @@ export declare namespace DcqlPresentationQuery {
                 id?: string | undefined;
             }[]] | undefined;
         })[]];
-        credential_matches: {
+        canBeSatisfied: boolean;
+        invalid_matches: {
+            [x: string]: {
+                output: unknown;
+                success: false;
+                typed: boolean;
+                issues: [unknown, ...unknown[]];
+                claim_set_index: number | undefined;
+                presentation_id: string;
+            };
+        } | undefined;
+        valid_matches: {
             [x: string]: {
                 output: {
                     claims: {
@@ -643,141 +469,143 @@ export declare namespace DcqlPresentationQuery {
                 success: true;
                 typed: true;
                 claim_set_index: number | undefined;
-                credential_index: number;
-                all: [({
-                    output: unknown;
-                    success: false;
-                    typed: boolean;
-                    issues: [unknown, ...unknown[]];
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                } | {
-                    output: {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                    } | {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                        vct: string;
-                    } | {
-                        docType: string;
-                        namespaces: {
-                            [x: string]: {
-                                [x: string]: unknown;
-                            };
-                        };
-                    };
-                    success: true;
-                    typed: true;
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                    issues?: undefined;
-                } | undefined)[], ...({
-                    output: unknown;
-                    success: false;
-                    typed: boolean;
-                    issues: [unknown, ...unknown[]];
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                } | {
-                    output: {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                    } | {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                        vct: string;
-                    } | {
-                        docType: string;
-                        namespaces: {
-                            [x: string]: {
-                                [x: string]: unknown;
-                            };
-                        };
-                    };
-                    success: true;
-                    typed: true;
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                    issues?: undefined;
-                } | undefined)[][]];
-                issues?: 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";
+            claim_sets?: [string[], ...string[][]] | undefined;
+            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;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt";
+            claim_sets?: [string[], ...string[][]] | undefined;
+            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;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json" | "jwt_vc_json-ld";
+            claim_sets?: [string[], ...string[][]] | undefined;
+            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;
+        }, ...({
+            id: string;
+            format: "mso_mdoc";
+            claim_sets?: [string[], ...string[][]] | undefined;
+            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;
+            meta?: {
+                doctype_value?: string | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "vc+sd-jwt";
+            claim_sets?: [string[], ...string[][]] | undefined;
+            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;
+            meta?: {
+                vct_values?: string[] | undefined;
+            } | undefined;
+        } | {
+            id: string;
+            format: "jwt_vc_json" | "jwt_vc_json-ld";
+            claim_sets?: [string[], ...string[][]] | undefined;
+            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;
+        })[]];
+        canBeSatisfied: boolean;
+        invalid_matches: {
+            [x: string]: {
                 output: unknown;
                 success: false;
                 typed: boolean;
                 issues: [unknown, ...unknown[]];
                 claim_set_index: number | undefined;
-                credential_index: number;
-                all: [({
-                    output: unknown;
-                    success: false;
-                    typed: boolean;
-                    issues: [unknown, ...unknown[]];
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                } | {
-                    output: {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                    } | {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                        vct: string;
-                    } | {
-                        docType: string;
-                        namespaces: {
-                            [x: string]: {
-                                [x: string]: unknown;
-                            };
-                        };
-                    };
-                    success: true;
-                    typed: true;
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                    issues?: undefined;
-                } | undefined)[], ...({
-                    output: unknown;
-                    success: false;
-                    typed: boolean;
-                    issues: [unknown, ...unknown[]];
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                } | {
-                    output: {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                    } | {
-                        claims: {
-                            [x: string]: import("../u-dcql.js").Json;
-                        };
-                        vct: string;
-                    } | {
-                        docType: string;
-                        namespaces: {
-                            [x: string]: {
-                                [x: string]: unknown;
-                            };
-                        };
-                    };
-                    success: true;
-                    typed: true;
-                    claim_set_index: number | undefined;
-                    credential_index: number;
-                    issues?: undefined;
-                } | undefined)[][]];
+                presentation_id: string;
             };
-        };
-        canBeSatisfied: true;
-        presentation_matches: {
+        } | undefined;
+        valid_matches: {
             [x: string]: {
                 output: {
                     claims: {
@@ -799,7 +627,7 @@ export declare namespace DcqlPresentationQuery {
                 success: true;
                 typed: true;
                 claim_set_index: number | undefined;
-                presentation_index: number;
+                presentation_id: string;
             };
         };
         credential_sets?: [{
@@ -818,18 +646,6 @@ export declare namespace DcqlPresentationQuery {
             } | undefined;
         }[]] | undefined;
     };
-    /**
-     * Query if the presentation record can be satisfied by the provided presentations
-     * considering the dcql query
-     *
-     * @param dcqlQuery
-     * @param presentations
-     */
-    const query: (presentations: DcqlPresentationRepresentation[], ctx: {
-        dcqlQuery: DcqlQuery;
-    }) => DcqlPresentationQuery.UnknownResult;
-    const validate: (dcqlQueryResult: DcqlPresentationQuery.UnknownResult) => DcqlPresentationQuery;
-    const fromDcqlQueryResult: (dcqlQueryResult: DcqlQueryResult) => DcqlPresentationQuery;
 }
-export type DcqlPresentationQuery = DcqlPresentationQuery.Output;
-//# sourceMappingURL=m-dcql-presentation-query.d.ts.map
+export type DcqlPresentationResult = DcqlPresentationResult.Output;
+//# sourceMappingURL=m-dcql-presentation-result.d.ts.map

package/dist/src/dcql-presentation/m-dcql-presentation-result.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"m-dcql-presentation-result.d.ts","sourceRoot":"","sources":["../../../src/dcql-presentation/m-dcql-presentation-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAGvF,yBAAiB,sBAAsB,CAAC;IAC/B,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BjB,CAAC;IAEH,KAAY,KAAK,GAAG,CAAC,CAAC,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;IAChD,KAAY,MAAM,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,CAAC;IAE3C,MAAM,KAAK,UAAW,KAAK,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEnD,CAAC;IAEF;;;;;;OAMG;IACI,MAAM,oBAAoB,qBACb,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,OACvD;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,KAC5B,MAyEF,CAAC;IAEK,MAAM,QAAQ,oBAAqB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAS/D,CAAC;CACH;AACD,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,CAAC,MAAM,CAAC"}