@pagopa/io-react-native-wallet 1.1.2 → 1.2.2

package/lib/typescript/credential/presentation/index.d.ts

@@ -1,9 +1,12 @@
 import { startFlowFromQR, type StartFlow } from "./01-start-flow";
 import { evaluateRelyingPartyTrust, type EvaluateRelyingPartyTrust } from "./02-evaluate-rp-trust";
-import { fetchJwksFromUri, fetchJwksFromConfig, type FetchJwks } from "./03-retrieve-jwks";
-import { getRequestObject, type GetRequestObject } from "./04-get-request-object";
-import { sendAuthorizationResponse, type SendAuthorizationResponse } from "./05-send-authorization-response";
+import { getRequestObject, type GetRequestObject } from "./03-get-request-object";
+import { fetchJwksFromRequestObject, fetchJwksFromConfig, type FetchJwks } from "./04-retrieve-rp-jwks";
+import { verifyRequestObjectSignature, type VerifyRequestObjectSignature } from "./05-verify-request-object";
+import { fetchPresentDefinition, type FetchPresentationDefinition } from "./06-fetch-presentation-definition";
+import { evaluateInputDescriptorForSdJwt4VC, type EvaluateInputDescriptorSdJwt4VC } from "./07-evaluate-input-descriptor";
+import { sendAuthorizationResponse, type SendAuthorizationResponse } from "./08-send-authorization-response";
 import * as Errors from "./errors";
-export { startFlowFromQR, evaluateRelyingPartyTrust, fetchJwksFromUri, fetchJwksFromConfig, getRequestObject, sendAuthorizationResponse, Errors, };
-export type { StartFlow, EvaluateRelyingPartyTrust, FetchJwks, GetRequestObject, SendAuthorizationResponse, };
+export { startFlowFromQR, evaluateRelyingPartyTrust, getRequestObject, fetchJwksFromRequestObject, fetchJwksFromConfig, verifyRequestObjectSignature, fetchPresentDefinition, evaluateInputDescriptorForSdJwt4VC, sendAuthorizationResponse, Errors, };
+export type { StartFlow, EvaluateRelyingPartyTrust, GetRequestObject, FetchJwks, VerifyRequestObjectSignature, FetchPresentationDefinition, EvaluateInputDescriptorSdJwt4VC, SendAuthorizationResponse, };
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/credential/presentation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/credential/presentation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EACL,yBAAyB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,SAAS,EACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,yBAAyB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EACL,eAAe,EACf,yBAAyB,EACzB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,yBAAyB,EACzB,MAAM,GACP,CAAC;AACF,YAAY,EACV,SAAS,EACT,yBAAyB,EACzB,SAAS,EACT,gBAAgB,EAChB,yBAAyB,GAC1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/credential/presentation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EACL,yBAAyB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,KAAK,SAAS,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,4BAA4B,EAC5B,KAAK,4BAA4B,EAClC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,sBAAsB,EACtB,KAAK,2BAA2B,EACjC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,kCAAkC,EAClC,KAAK,+BAA+B,EACrC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,yBAAyB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EACL,eAAe,EACf,yBAAyB,EACzB,gBAAgB,EAChB,0BAA0B,EAC1B,mBAAmB,EACnB,4BAA4B,EAC5B,sBAAsB,EACtB,kCAAkC,EAClC,yBAAyB,EACzB,MAAM,GACP,CAAC;AACF,YAAY,EACV,SAAS,EACT,yBAAyB,EACzB,gBAAgB,EAChB,SAAS,EACT,4BAA4B,EAC5B,2BAA2B,EAC3B,+BAA+B,EAC/B,yBAAyB,GAC1B,CAAC"}

package/lib/typescript/credential/presentation/types.d.ts

@@ -8,42 +8,645 @@ export type Presentation = [
     string[],
     CryptoContext
 ];
+export type InputDescriptor = z.infer<typeof InputDescriptor>;
+export declare const InputDescriptor: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    purpose: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    constraints: z.ZodObject<{
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodString, "many">;
+            id: z.ZodOptional<z.ZodString>;
+            purpose: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodAny>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+            intent_to_retain: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string[];
+            id?: string | undefined;
+            purpose?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+            optional?: boolean | undefined;
+            intent_to_retain?: boolean | undefined;
+        }, {
+            path: string[];
+            id?: string | undefined;
+            purpose?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+            optional?: boolean | undefined;
+            intent_to_retain?: boolean | undefined;
+        }>, "many">>;
+        limit_disclosure: z.ZodOptional<z.ZodEnum<["required", "preferred"]>>;
+    }, "strip", z.ZodTypeAny, {
+        fields?: {
+            path: string[];
+            id?: string | undefined;
+            purpose?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+            optional?: boolean | undefined;
+            intent_to_retain?: boolean | undefined;
+        }[] | undefined;
+        limit_disclosure?: "required" | "preferred" | undefined;
+    }, {
+        fields?: {
+            path: string[];
+            id?: string | undefined;
+            purpose?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+            optional?: boolean | undefined;
+            intent_to_retain?: boolean | undefined;
+        }[] | undefined;
+        limit_disclosure?: "required" | "preferred" | undefined;
+    }>;
+    group: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    constraints: {
+        fields?: {
+            path: string[];
+            id?: string | undefined;
+            purpose?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+            optional?: boolean | undefined;
+            intent_to_retain?: boolean | undefined;
+        }[] | undefined;
+        limit_disclosure?: "required" | "preferred" | undefined;
+    };
+    name?: string | undefined;
+    purpose?: string | undefined;
+    format?: Record<string, any> | undefined;
+    group?: string | undefined;
+}, {
+    id: string;
+    constraints: {
+        fields?: {
+            path: string[];
+            id?: string | undefined;
+            purpose?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+            optional?: boolean | undefined;
+            intent_to_retain?: boolean | undefined;
+        }[] | undefined;
+        limit_disclosure?: "required" | "preferred" | undefined;
+    };
+    name?: string | undefined;
+    purpose?: string | undefined;
+    format?: Record<string, any> | undefined;
+    group?: string | undefined;
+}>;
+export type PresentationDefinition = z.infer<typeof PresentationDefinition>;
+export declare const PresentationDefinition: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    purpose: z.ZodOptional<z.ZodString>;
+    input_descriptors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        purpose: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        constraints: z.ZodObject<{
+            fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodArray<z.ZodString, "many">;
+                id: z.ZodOptional<z.ZodString>;
+                purpose: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                filter: z.ZodOptional<z.ZodAny>;
+                optional: z.ZodOptional<z.ZodBoolean>;
+                intent_to_retain: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }, {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }>, "many">>;
+            limit_disclosure: z.ZodOptional<z.ZodEnum<["required", "preferred"]>>;
+        }, "strip", z.ZodTypeAny, {
+            fields?: {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }[] | undefined;
+            limit_disclosure?: "required" | "preferred" | undefined;
+        }, {
+            fields?: {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }[] | undefined;
+            limit_disclosure?: "required" | "preferred" | undefined;
+        }>;
+        group: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        constraints: {
+            fields?: {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }[] | undefined;
+            limit_disclosure?: "required" | "preferred" | undefined;
+        };
+        name?: string | undefined;
+        purpose?: string | undefined;
+        format?: Record<string, any> | undefined;
+        group?: string | undefined;
+    }, {
+        id: string;
+        constraints: {
+            fields?: {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }[] | undefined;
+            limit_disclosure?: "required" | "preferred" | undefined;
+        };
+        name?: string | undefined;
+        purpose?: string | undefined;
+        format?: Record<string, any> | undefined;
+        group?: string | undefined;
+    }>, "many">;
+    submission_requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        purpose: z.ZodOptional<z.ZodString>;
+        rule: z.ZodString;
+        from: z.ZodOptional<z.ZodString>;
+        from_nested: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            purpose: z.ZodOptional<z.ZodString>;
+            rule: z.ZodString;
+            from: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            rule: string;
+            from: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+        }, {
+            rule: string;
+            from: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+        }>, "many">>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        rule: string;
+        name?: string | undefined;
+        purpose?: string | undefined;
+        from?: string | undefined;
+        from_nested?: {
+            rule: string;
+            from: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+        }[] | undefined;
+        count?: number | undefined;
+    }, {
+        rule: string;
+        name?: string | undefined;
+        purpose?: string | undefined;
+        from?: string | undefined;
+        from_nested?: {
+            rule: string;
+            from: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+        }[] | undefined;
+        count?: number | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    input_descriptors: {
+        id: string;
+        constraints: {
+            fields?: {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }[] | undefined;
+            limit_disclosure?: "required" | "preferred" | undefined;
+        };
+        name?: string | undefined;
+        purpose?: string | undefined;
+        format?: Record<string, any> | undefined;
+        group?: string | undefined;
+    }[];
+    name?: string | undefined;
+    purpose?: string | undefined;
+    submission_requirements?: {
+        rule: string;
+        name?: string | undefined;
+        purpose?: string | undefined;
+        from?: string | undefined;
+        from_nested?: {
+            rule: string;
+            from: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+        }[] | undefined;
+        count?: number | undefined;
+    }[] | undefined;
+}, {
+    id: string;
+    input_descriptors: {
+        id: string;
+        constraints: {
+            fields?: {
+                path: string[];
+                id?: string | undefined;
+                purpose?: string | undefined;
+                name?: string | undefined;
+                filter?: any;
+                optional?: boolean | undefined;
+                intent_to_retain?: boolean | undefined;
+            }[] | undefined;
+            limit_disclosure?: "required" | "preferred" | undefined;
+        };
+        name?: string | undefined;
+        purpose?: string | undefined;
+        format?: Record<string, any> | undefined;
+        group?: string | undefined;
+    }[];
+    name?: string | undefined;
+    purpose?: string | undefined;
+    submission_requirements?: {
+        rule: string;
+        name?: string | undefined;
+        purpose?: string | undefined;
+        from?: string | undefined;
+        from_nested?: {
+            rule: string;
+            from: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+        }[] | undefined;
+        count?: number | undefined;
+    }[] | undefined;
+}>;
 export type RequestObject = z.infer<typeof RequestObject>;
 export declare const RequestObject: z.ZodObject<{
     iss: z.ZodOptional<z.ZodString>;
-    iat: z.ZodNumber;
+    iat: z.ZodOptional<z.ZodNumber>;
     exp: z.ZodOptional<z.ZodNumber>;
     state: z.ZodString;
     nonce: z.ZodString;
     response_uri: z.ZodString;
     response_type: z.ZodLiteral<"vp_token">;
-    response_mode: z.ZodLiteral<"direct_post.jwt">;
+    response_mode: z.ZodEnum<["direct_post.jwt", "direct_post"]>;
     client_id: z.ZodString;
     client_id_scheme: z.ZodString;
-    scope: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    presentation_definition: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        purpose: z.ZodOptional<z.ZodString>;
+        input_descriptors: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            purpose: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            constraints: z.ZodObject<{
+                fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    path: z.ZodArray<z.ZodString, "many">;
+                    id: z.ZodOptional<z.ZodString>;
+                    purpose: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    filter: z.ZodOptional<z.ZodAny>;
+                    optional: z.ZodOptional<z.ZodBoolean>;
+                    intent_to_retain: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }, {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }>, "many">>;
+                limit_disclosure: z.ZodOptional<z.ZodEnum<["required", "preferred"]>>;
+            }, "strip", z.ZodTypeAny, {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            }, {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            }>;
+            group: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            constraints: {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            };
+            name?: string | undefined;
+            purpose?: string | undefined;
+            format?: Record<string, any> | undefined;
+            group?: string | undefined;
+        }, {
+            id: string;
+            constraints: {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            };
+            name?: string | undefined;
+            purpose?: string | undefined;
+            format?: Record<string, any> | undefined;
+            group?: string | undefined;
+        }>, "many">;
+        submission_requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            purpose: z.ZodOptional<z.ZodString>;
+            rule: z.ZodString;
+            from: z.ZodOptional<z.ZodString>;
+            from_nested: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                purpose: z.ZodOptional<z.ZodString>;
+                rule: z.ZodString;
+                from: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }, {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }>, "many">>;
+            count: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            rule: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+            from?: string | undefined;
+            from_nested?: {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }[] | undefined;
+            count?: number | undefined;
+        }, {
+            rule: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+            from?: string | undefined;
+            from_nested?: {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }[] | undefined;
+            count?: number | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        input_descriptors: {
+            id: string;
+            constraints: {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            };
+            name?: string | undefined;
+            purpose?: string | undefined;
+            format?: Record<string, any> | undefined;
+            group?: string | undefined;
+        }[];
+        name?: string | undefined;
+        purpose?: string | undefined;
+        submission_requirements?: {
+            rule: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+            from?: string | undefined;
+            from_nested?: {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }[] | undefined;
+            count?: number | undefined;
+        }[] | undefined;
+    }, {
+        id: string;
+        input_descriptors: {
+            id: string;
+            constraints: {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            };
+            name?: string | undefined;
+            purpose?: string | undefined;
+            format?: Record<string, any> | undefined;
+            group?: string | undefined;
+        }[];
+        name?: string | undefined;
+        purpose?: string | undefined;
+        submission_requirements?: {
+            rule: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+            from?: string | undefined;
+            from_nested?: {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }[] | undefined;
+            count?: number | undefined;
+        }[] | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     state: string;
     nonce: string;
-    scope: string;
-    iat: number;
     response_type: "vp_token";
-    response_mode: "direct_post.jwt";
+    response_mode: "direct_post.jwt" | "direct_post";
     client_id: string;
     response_uri: string;
     client_id_scheme: string;
     iss?: string | undefined;
+    iat?: number | undefined;
     exp?: number | undefined;
+    scope?: string | undefined;
+    presentation_definition?: {
+        id: string;
+        input_descriptors: {
+            id: string;
+            constraints: {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            };
+            name?: string | undefined;
+            purpose?: string | undefined;
+            format?: Record<string, any> | undefined;
+            group?: string | undefined;
+        }[];
+        name?: string | undefined;
+        purpose?: string | undefined;
+        submission_requirements?: {
+            rule: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+            from?: string | undefined;
+            from_nested?: {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }[] | undefined;
+            count?: number | undefined;
+        }[] | undefined;
+    } | undefined;
 }, {
     state: string;
     nonce: string;
-    scope: string;
-    iat: number;
     response_type: "vp_token";
-    response_mode: "direct_post.jwt";
+    response_mode: "direct_post.jwt" | "direct_post";
     client_id: string;
     response_uri: string;
     client_id_scheme: string;
     iss?: string | undefined;
+    iat?: number | undefined;
     exp?: number | undefined;
+    scope?: string | undefined;
+    presentation_definition?: {
+        id: string;
+        input_descriptors: {
+            id: string;
+            constraints: {
+                fields?: {
+                    path: string[];
+                    id?: string | undefined;
+                    purpose?: string | undefined;
+                    name?: string | undefined;
+                    filter?: any;
+                    optional?: boolean | undefined;
+                    intent_to_retain?: boolean | undefined;
+                }[] | undefined;
+                limit_disclosure?: "required" | "preferred" | undefined;
+            };
+            name?: string | undefined;
+            purpose?: string | undefined;
+            format?: Record<string, any> | undefined;
+            group?: string | undefined;
+        }[];
+        name?: string | undefined;
+        purpose?: string | undefined;
+        submission_requirements?: {
+            rule: string;
+            name?: string | undefined;
+            purpose?: string | undefined;
+            from?: string | undefined;
+            from_nested?: {
+                rule: string;
+                from: string;
+                name?: string | undefined;
+                purpose?: string | undefined;
+            }[] | undefined;
+            count?: number | undefined;
+        }[] | undefined;
+    } | undefined;
 }>;
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/credential/presentation/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credential/presentation/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACO,MAAM;IACzB,MAAM,EAAE;IACsC,aAAa;CACzE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYxB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credential/presentation/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACO,MAAM;IACzB,MAAM,EAAE;IACsC,aAAa;CACzE,CAAC;AAmBF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1B,CAAC;AAqBH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaxB,CAAC"}