@learncard/core 8.4.1 → 8.5.0

package/dist/wallet/plugins/didkey/index.d.ts

@@ -0,0 +1,217 @@
+import { DidKeyPlugin, DependentMethods } from './types';
+import { LearnCard } from '../../../types/wallet';
+export * from './types';
+/**
+ *
+ * @group Plugins
+ */
+export declare const getDidKeyPlugin: <DidMethod extends string>(learnCard: {
+    plugins: any;
+    invoke: DependentMethods<DidMethod>;
+    addPlugin: <NewPlugin extends {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+        _methods?: Record<never, never> | undefined;
+        read?: {} | undefined;
+        store?: {} | undefined;
+        index?: {} | undefined;
+        cache?: {} | undefined;
+        id?: {} | undefined;
+    }>(plugin: NewPlugin) => Promise<{
+        plugins: [...any[], NewPlugin];
+        invoke: any;
+        addPlugin: <NewPlugin_1 extends {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+            _methods?: Record<never, never> | undefined;
+            read?: {} | undefined;
+            store?: {} | undefined;
+            index?: {} | undefined;
+            cache?: {} | undefined;
+            id?: {} | undefined;
+        }>(plugin: NewPlugin_1) => Promise<{
+            plugins: [...any[], NewPlugin, NewPlugin_1];
+            invoke: any;
+            addPlugin: <NewPlugin_2 extends {
+                name: string;
+                displayName?: string | undefined;
+                description?: string | undefined;
+                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                _methods?: Record<never, never> | undefined;
+                read?: {} | undefined;
+                store?: {} | undefined;
+                index?: {} | undefined;
+                cache?: {} | undefined;
+                id?: {} | undefined;
+            }>(plugin: NewPlugin_2) => Promise<{
+                plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2];
+                invoke: any;
+                addPlugin: <NewPlugin_3 extends {
+                    name: string;
+                    displayName?: string | undefined;
+                    description?: string | undefined;
+                    methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                    _methods?: Record<never, never> | undefined;
+                    read?: {} | undefined;
+                    store?: {} | undefined;
+                    index?: {} | undefined;
+                    cache?: {} | undefined;
+                    id?: {} | undefined;
+                }>(plugin: NewPlugin_3) => Promise<{
+                    plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3];
+                    invoke: any;
+                    addPlugin: <NewPlugin_4 extends {
+                        name: string;
+                        displayName?: string | undefined;
+                        description?: string | undefined;
+                        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                        _methods?: Record<never, never> | undefined;
+                        read?: {} | undefined;
+                        store?: {} | undefined;
+                        index?: {} | undefined;
+                        cache?: {} | undefined;
+                        id?: {} | undefined;
+                    }>(plugin: NewPlugin_4) => Promise<{
+                        plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4];
+                        invoke: any;
+                        addPlugin: <NewPlugin_5 extends {
+                            name: string;
+                            displayName?: string | undefined;
+                            description?: string | undefined;
+                            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                            _methods?: Record<never, never> | undefined;
+                            read?: {} | undefined;
+                            store?: {} | undefined;
+                            index?: {} | undefined;
+                            cache?: {} | undefined;
+                            id?: {} | undefined;
+                        }>(plugin: NewPlugin_5) => Promise<{
+                            plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5];
+                            invoke: any;
+                            addPlugin: <NewPlugin_6 extends {
+                                name: string;
+                                displayName?: string | undefined;
+                                description?: string | undefined;
+                                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                _methods?: Record<never, never> | undefined;
+                                read?: {} | undefined;
+                                store?: {} | undefined;
+                                index?: {} | undefined;
+                                cache?: {} | undefined;
+                                id?: {} | undefined;
+                            }>(plugin: NewPlugin_6) => Promise<{
+                                plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6];
+                                invoke: any;
+                                addPlugin: <NewPlugin_7 extends {
+                                    name: string;
+                                    displayName?: string | undefined;
+                                    description?: string | undefined;
+                                    methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                    _methods?: Record<never, never> | undefined;
+                                    read?: {} | undefined;
+                                    store?: {} | undefined;
+                                    index?: {} | undefined;
+                                    cache?: {} | undefined;
+                                    id?: {} | undefined;
+                                }>(plugin: NewPlugin_7) => Promise<{
+                                    plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7];
+                                    invoke: any;
+                                    addPlugin: <NewPlugin_8 extends {
+                                        name: string;
+                                        displayName?: string | undefined;
+                                        description?: string | undefined;
+                                        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                        _methods?: Record<never, never> | undefined;
+                                        read?: {} | undefined;
+                                        store?: {} | undefined;
+                                        index?: {} | undefined;
+                                        cache?: {} | undefined;
+                                        id?: {} | undefined;
+                                    }>(plugin: NewPlugin_8) => Promise<{
+                                        plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7, NewPlugin_8];
+                                        invoke: any;
+                                        addPlugin: <NewPlugin_9 extends {
+                                            name: string;
+                                            displayName?: string | undefined;
+                                            description?: string | undefined;
+                                            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                            _methods?: Record<never, never> | undefined;
+                                            read?: {} | undefined;
+                                            store?: {} | undefined;
+                                            index?: {} | undefined;
+                                            cache?: {} | undefined;
+                                            id?: {} | undefined;
+                                        }>(plugin: NewPlugin_9) => Promise<{
+                                            plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7, NewPlugin_8, NewPlugin_9];
+                                            invoke: any;
+                                            addPlugin: <NewPlugin_10 extends {
+                                                name: string;
+                                                displayName?: string | undefined;
+                                                description?: string | undefined;
+                                                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                                _methods?: Record<never, never> | undefined;
+                                                read?: {} | undefined;
+                                                store?: {} | undefined;
+                                                index?: {} | undefined;
+                                                cache?: {} | undefined;
+                                                id?: {} | undefined;
+                                            }>(plugin: NewPlugin_10) => Promise<any>;
+                                            debug?: {
+                                                (...data: any[]): void;
+                                                (message?: any, ...optionalParams: any[]): void;
+                                            } | undefined;
+                                        }>;
+                                        debug?: {
+                                            (...data: any[]): void;
+                                            (message?: any, ...optionalParams: any[]): void;
+                                        } | undefined;
+                                    }>;
+                                    debug?: {
+                                        (...data: any[]): void;
+                                        (message?: any, ...optionalParams: any[]): void;
+                                    } | undefined;
+                                }>;
+                                debug?: {
+                                    (...data: any[]): void;
+                                    (message?: any, ...optionalParams: any[]): void;
+                                } | undefined;
+                            }>;
+                            debug?: {
+                                (...data: any[]): void;
+                                (message?: any, ...optionalParams: any[]): void;
+                            } | undefined;
+                        }>;
+                        debug?: {
+                            (...data: any[]): void;
+                            (message?: any, ...optionalParams: any[]): void;
+                        } | undefined;
+                    }>;
+                    debug?: {
+                        (...data: any[]): void;
+                        (message?: any, ...optionalParams: any[]): void;
+                    } | undefined;
+                }>;
+                debug?: {
+                    (...data: any[]): void;
+                    (message?: any, ...optionalParams: any[]): void;
+                } | undefined;
+            }>;
+            debug?: {
+                (...data: any[]): void;
+                (message?: any, ...optionalParams: any[]): void;
+            } | undefined;
+        }>;
+        debug?: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        } | undefined;
+    }>;
+    debug?: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    } | undefined;
+}, key: string, defaultDidMethod: DidMethod) => Promise<DidKeyPlugin<DidMethod>>;

package/dist/wallet/plugins/didkey/types.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from '../../../types/wallet';
+import { JWK } from '@learncard/types';
+/** @group DidKey Plugin */
+export type Algorithm = 'ed25519' | 'secp256k1';
+/** @group DidKey Plugin */
+export type DependentMethods<DidMethod extends string> = {
+    generateEd25519KeyFromBytes: (bytes: Uint8Array) => JWK;
+    generateSecp256k1KeyFromBytes: (bytes: Uint8Array) => JWK;
+    keyToDid: (method: DidMethod, keypair: JWK) => string;
+};
+/** @group DidKey Plugin */
+export type DidKeyPluginMethods<DidMethod extends string> = {
+    getSubjectDid: (method?: DidMethod) => string;
+    getSubjectKeypair: (algorithm?: Algorithm) => JWK;
+    getKey: () => string;
+};
+/** @group DidKey Plugin */
+export type DidKeyPlugin<DidMethod extends string = string> = Plugin<'DID Key', 'id', DidKeyPluginMethods<DidMethod>, any, DependentMethods<DidMethod>>;

package/dist/wallet/plugins/didkit/index.d.ts

@@ -0,0 +1,8 @@
+import { InitInput } from '../../../didkit/index';
+import { DIDKitPlugin } from './types';
+export * from './types';
+/**
+ *
+ * @group Plugins
+ */
+export declare const getDidKitPlugin: (input?: InitInput | Promise<InitInput>) => Promise<DIDKitPlugin>;

package/dist/wallet/plugins/didkit/types.d.ts

@@ -0,0 +1,40 @@
+import { JWK, UnsignedVC, UnsignedVP, VC, VP, VerificationCheck } from '@learncard/types';
+import type { DIDResolutionResult } from 'dids';
+import { Plugin } from '../../../types/wallet';
+/** @group DIDKit Plugin */
+export type DidMethod = 'key' | 'tz' | 'ethr' | `pkh:${'tz' | 'tezos' | 'sol' | 'solana' | 'eth' | 'celo' | 'poly' | 'btc' | 'doge' | 'eip155' | 'bip122'}` | `pkh:eip155:${string}` | `pkh:bip122:${string}`;
+/** @group DIDKit Plugin */
+export type ProofOptions = {
+    type?: string;
+    verificationMethod?: string;
+    proofPurpose?: string;
+    proofFormat?: string;
+    created?: string;
+    challenge?: string;
+    domain?: string;
+    checks?: ('Proof' | 'JWS' | 'CredentialStatus')[];
+};
+/** @group DIDKit Plugin */
+export type InputMetadata = {
+    accept?: string;
+    versionId?: string;
+    versionTime?: string;
+    noCache?: boolean;
+};
+/** @group DIDKit Plugin */
+export type DidkitPluginMethods = {
+    generateEd25519KeyFromBytes: (bytes: Uint8Array) => JWK;
+    generateSecp256k1KeyFromBytes: (bytes: Uint8Array) => JWK;
+    keyToDid: (type: DidMethod, keypair: JWK) => string;
+    keyToVerificationMethod: (type: string, keypair: JWK) => Promise<string>;
+    didToVerificationMethod: (did: string) => Promise<string>;
+    issueCredential: (credential: UnsignedVC, options: ProofOptions, keypair: JWK) => Promise<VC>;
+    verifyCredential: (credential: VC, options?: ProofOptions) => Promise<VerificationCheck>;
+    issuePresentation: (presentation: UnsignedVP, options: ProofOptions, keypair: JWK) => Promise<VP>;
+    verifyPresentation: (presentation: VP | string, options?: ProofOptions) => Promise<VerificationCheck>;
+    contextLoader: (url: string) => Promise<Record<string, any>>;
+    resolveDid: (did: string, inputMetadata?: InputMetadata) => Promise<Record<string, any>>;
+    didResolver: (did: string, inputMetadata?: InputMetadata) => Promise<DIDResolutionResult>;
+};
+/** @group DIDKit Plugin */
+export type DIDKitPlugin = Plugin<'DIDKit', any, DidkitPluginMethods>;

package/dist/wallet/plugins/expiration/index.d.ts

@@ -0,0 +1,7 @@
+import { VerifyExtension } from '../vc';
+import { LearnCard } from '../../../types/wallet';
+import { ExpirationPlugin } from './types';
+/**
+ * @group Plugins
+ */
+export declare const expirationPlugin: (learnCard: LearnCard<any, any, VerifyExtension>) => ExpirationPlugin;

package/dist/wallet/plugins/expiration/types.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '../../../types/wallet';
+import { VerifyExtension } from '../vc';
+export type ExpirationPlugin = Plugin<'Expiration', any, VerifyExtension>;

package/dist/wallet/plugins/idx/idx.d.ts

@@ -0,0 +1,6 @@
+import { IDXPlugin, IDXPluginDependentMethods, IDXArgs } from './types';
+import { LearnCard } from '../../../types/wallet';
+/**
+ * @group Plugins
+ */
+export declare const getIDXPlugin: <URI extends string = "">(learnCard: LearnCard<any, "read", IDXPluginDependentMethods<URI>>, { modelData, credentialAlias }: IDXArgs) => Promise<IDXPlugin>;

package/dist/wallet/plugins/idx/index.d.ts

@@ -0,0 +1,4 @@
+import { getIDXPlugin } from './idx';
+export { getIDXPlugin } from './idx';
+export * from './types';
+export default getIDXPlugin;

package/dist/wallet/plugins/idx/types.d.ts

@@ -0,0 +1,54 @@
+import { ModelAliases } from '@glazed/types';
+import { z } from 'zod';
+import { StreamID } from '@ceramicnetwork/streamid';
+import { Plugin } from '../../../types/wallet';
+import { VC, CredentialRecord } from '@learncard/types';
+import { ResolutionExtension } from '../vc-resolution';
+import { CeramicClient } from '@ceramicnetwork/http-client';
+/** @group IDXPlugin */
+export type IDXIndexObject<IDXMetadata extends Record<string, any>, Metadata extends Record<string, any>> = {
+    credentials: CredentialRecord<Metadata>[];
+} & IDXMetadata;
+/** @group IDXPlugin */
+export type IDXArgs = {
+    modelData: ModelAliases;
+    credentialAlias: string;
+};
+/** @group IDXPlugin */
+export type IDXPluginMethods = {
+    getCredentialsListFromIdx: <Metadata extends Record<string, any> = Record<never, never>>(alias?: string) => Promise<CredentialRecord<Metadata>[]>;
+    getVerifiableCredentialFromIdx: (id: string) => Promise<VC | undefined>;
+    getVerifiableCredentialsFromIdx: () => Promise<VC[]>;
+    addVerifiableCredentialInIdx: <Metadata extends Record<string, any> = Record<never, never>>(cred: CredentialRecord<Metadata>) => Promise<string>;
+    removeVerifiableCredentialInIdx: (title: string) => Promise<StreamID>;
+    removeAllVerifiableCredentialsInIdx: () => Promise<StreamID>;
+    getIDXIndex: <IDXMetadata extends Record<string, any>, Metadata extends Record<string, any>>() => Promise<IDXIndexObject<IDXMetadata, Metadata> | null>;
+    setIDXIndex: <IDXMetadata extends Record<string, any>, Metadata extends Record<string, any>>(index: IDXIndexObject<IDXMetadata, Metadata>) => Promise<StreamID>;
+};
+/** @group IDXPlugin */
+export type IDXPluginDependentMethods<URI extends string = ''> = {
+    getCeramicClient: () => CeramicClient;
+} & ResolutionExtension<URI>;
+/** @group IDXPlugin */
+export type CredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
+    credentials: Array<CredentialRecord<Metadata>>;
+};
+/** @group IDXPlugin */
+export declare const CredentialsListValidator: z.ZodType<CredentialsList>;
+/** @group IDXPlugin */
+export type IDXPlugin = Plugin<'IDX', 'index', IDXPluginMethods, 'read', IDXPluginDependentMethods>;
+/** @group IDXPlugin */
+export type BackwardsCompatIDXCredential<Metadata extends Record<string, any> = Record<never, never>> = {
+    [key: string]: any;
+    id: string;
+    title: string;
+    storageType?: 'ceramic';
+} & Metadata;
+/** @group IDXPlugin */
+export declare const BackwardsCompatIDXCredentialValidator: z.ZodType<BackwardsCompatIDXCredential>;
+/** @group IDXPlugin */
+export type BackwardsCompatCredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
+    credentials: Array<CredentialRecord<Metadata> | BackwardsCompatIDXCredential<Metadata>>;
+};
+/** @group IDXPlugin */
+export declare const BackwardsCompatCredentialsListValidator: z.ZodType<BackwardsCompatCredentialsList>;

package/dist/wallet/plugins/index.d.ts

@@ -0,0 +1,14 @@
+export * from './ceramic';
+export * from './chapi';
+export * from './didkey';
+export * from './didkit';
+export * from './EthereumPlugin';
+export * from './expiration';
+export * from './idx';
+export * from './test-cache';
+export * from './test-storage';
+export * from './vc';
+export * from './vc-api';
+export * from './vc-resolution';
+export * from './vc-templates';
+export * from './vpqr';

package/dist/wallet/plugins/learn-card/index.d.ts

@@ -0,0 +1,7 @@
+import { LearnCard } from '../../../types/wallet';
+import { LearnCardPluginDependentMethods, LearnCardPlugin } from './types';
+export * from './types';
+/**
+ * @group Plugins
+ */
+export declare const getLearnCardPlugin: (learnCard: LearnCard<any, any, LearnCardPluginDependentMethods>) => LearnCardPlugin;

package/dist/wallet/plugins/learn-card/types.d.ts

@@ -0,0 +1,17 @@
+import { VC, VerificationCheck, VerificationItem } from '@learncard/types';
+import { Plugin } from '../../../types/wallet';
+import { ProofOptions } from '../didkit';
+export type VerifyCredential = {
+    (vc: VC, options?: Partial<ProofOptions>): Promise<VerificationCheck>;
+    (vc: VC, options: Partial<ProofOptions>, prettify: true): Promise<VerificationItem[]>;
+};
+/** @group LearnCard Plugin */
+export type LearnCardPluginDependentMethods = {
+    verifyCredential: (vc: VC, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+};
+/** @group LearnCard Plugin */
+export type LearnCardPluginMethods = {
+    verifyCredential: VerifyCredential;
+};
+/** @group LearnCard Plugin */
+export type LearnCardPlugin = Plugin<'LearnCard', any, LearnCardPluginMethods, any, LearnCardPluginDependentMethods>;

package/dist/wallet/plugins/learn-card/verify.d.ts

@@ -0,0 +1,215 @@
+import { VC, VerificationCheck, VerificationItem } from '@learncard/types';
+import { LearnCard } from '../../../types/wallet';
+import { ProofOptions } from '../didkit';
+export declare const verifyCredential: (learnCard: {
+    plugins: any;
+    invoke: {
+        verifyCredential: (credential: VC, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+    };
+    addPlugin: <NewPlugin extends {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+        _methods?: Record<never, never> | undefined;
+        read?: {} | undefined;
+        store?: {} | undefined;
+        index?: {} | undefined;
+        cache?: {} | undefined;
+        id?: {} | undefined;
+    }>(plugin: NewPlugin) => Promise<{
+        plugins: [...any[], NewPlugin];
+        invoke: any;
+        addPlugin: <NewPlugin_1 extends {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+            _methods?: Record<never, never> | undefined;
+            read?: {} | undefined;
+            store?: {} | undefined;
+            index?: {} | undefined;
+            cache?: {} | undefined;
+            id?: {} | undefined;
+        }>(plugin: NewPlugin_1) => Promise<{
+            plugins: [...any[], NewPlugin, NewPlugin_1];
+            invoke: any;
+            addPlugin: <NewPlugin_2 extends {
+                name: string;
+                displayName?: string | undefined;
+                description?: string | undefined;
+                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                _methods?: Record<never, never> | undefined;
+                read?: {} | undefined;
+                store?: {} | undefined;
+                index?: {} | undefined;
+                cache?: {} | undefined;
+                id?: {} | undefined;
+            }>(plugin: NewPlugin_2) => Promise<{
+                plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2];
+                invoke: any;
+                addPlugin: <NewPlugin_3 extends {
+                    name: string;
+                    displayName?: string | undefined;
+                    description?: string | undefined;
+                    methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                    _methods?: Record<never, never> | undefined;
+                    read?: {} | undefined;
+                    store?: {} | undefined;
+                    index?: {} | undefined;
+                    cache?: {} | undefined;
+                    id?: {} | undefined;
+                }>(plugin: NewPlugin_3) => Promise<{
+                    plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3];
+                    invoke: any;
+                    addPlugin: <NewPlugin_4 extends {
+                        name: string;
+                        displayName?: string | undefined;
+                        description?: string | undefined;
+                        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                        _methods?: Record<never, never> | undefined;
+                        read?: {} | undefined;
+                        store?: {} | undefined;
+                        index?: {} | undefined;
+                        cache?: {} | undefined;
+                        id?: {} | undefined;
+                    }>(plugin: NewPlugin_4) => Promise<{
+                        plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4];
+                        invoke: any;
+                        addPlugin: <NewPlugin_5 extends {
+                            name: string;
+                            displayName?: string | undefined;
+                            description?: string | undefined;
+                            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                            _methods?: Record<never, never> | undefined;
+                            read?: {} | undefined;
+                            store?: {} | undefined;
+                            index?: {} | undefined;
+                            cache?: {} | undefined;
+                            id?: {} | undefined;
+                        }>(plugin: NewPlugin_5) => Promise<{
+                            plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5];
+                            invoke: any;
+                            addPlugin: <NewPlugin_6 extends {
+                                name: string;
+                                displayName?: string | undefined;
+                                description?: string | undefined;
+                                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                _methods?: Record<never, never> | undefined;
+                                read?: {} | undefined;
+                                store?: {} | undefined;
+                                index?: {} | undefined;
+                                cache?: {} | undefined;
+                                id?: {} | undefined;
+                            }>(plugin: NewPlugin_6) => Promise<{
+                                plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6];
+                                invoke: any;
+                                addPlugin: <NewPlugin_7 extends {
+                                    name: string;
+                                    displayName?: string | undefined;
+                                    description?: string | undefined;
+                                    methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                    _methods?: Record<never, never> | undefined;
+                                    read?: {} | undefined;
+                                    store?: {} | undefined;
+                                    index?: {} | undefined;
+                                    cache?: {} | undefined;
+                                    id?: {} | undefined;
+                                }>(plugin: NewPlugin_7) => Promise<{
+                                    plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7];
+                                    invoke: any;
+                                    addPlugin: <NewPlugin_8 extends {
+                                        name: string;
+                                        displayName?: string | undefined;
+                                        description?: string | undefined;
+                                        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                        _methods?: Record<never, never> | undefined;
+                                        read?: {} | undefined;
+                                        store?: {} | undefined;
+                                        index?: {} | undefined;
+                                        cache?: {} | undefined;
+                                        id?: {} | undefined;
+                                    }>(plugin: NewPlugin_8) => Promise<{
+                                        plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7, NewPlugin_8];
+                                        invoke: any;
+                                        addPlugin: <NewPlugin_9 extends {
+                                            name: string;
+                                            displayName?: string | undefined;
+                                            description?: string | undefined;
+                                            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                            _methods?: Record<never, never> | undefined;
+                                            read?: {} | undefined;
+                                            store?: {} | undefined;
+                                            index?: {} | undefined;
+                                            cache?: {} | undefined;
+                                            id?: {} | undefined;
+                                        }>(plugin: NewPlugin_9) => Promise<{
+                                            plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7, NewPlugin_8, NewPlugin_9];
+                                            invoke: any;
+                                            addPlugin: <NewPlugin_10 extends {
+                                                name: string;
+                                                displayName?: string | undefined;
+                                                description?: string | undefined;
+                                                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                                _methods?: Record<never, never> | undefined;
+                                                read?: {} | undefined;
+                                                store?: {} | undefined;
+                                                index?: {} | undefined;
+                                                cache?: {} | undefined;
+                                                id?: {} | undefined;
+                                            }>(plugin: NewPlugin_10) => Promise<any>;
+                                            debug?: {
+                                                (...data: any[]): void;
+                                                (message?: any, ...optionalParams: any[]): void;
+                                            } | undefined;
+                                        }>;
+                                        debug?: {
+                                            (...data: any[]): void;
+                                            (message?: any, ...optionalParams: any[]): void;
+                                        } | undefined;
+                                    }>;
+                                    debug?: {
+                                        (...data: any[]): void;
+                                        (message?: any, ...optionalParams: any[]): void;
+                                    } | undefined;
+                                }>;
+                                debug?: {
+                                    (...data: any[]): void;
+                                    (message?: any, ...optionalParams: any[]): void;
+                                } | undefined;
+                            }>;
+                            debug?: {
+                                (...data: any[]): void;
+                                (message?: any, ...optionalParams: any[]): void;
+                            } | undefined;
+                        }>;
+                        debug?: {
+                            (...data: any[]): void;
+                            (message?: any, ...optionalParams: any[]): void;
+                        } | undefined;
+                    }>;
+                    debug?: {
+                        (...data: any[]): void;
+                        (message?: any, ...optionalParams: any[]): void;
+                    } | undefined;
+                }>;
+                debug?: {
+                    (...data: any[]): void;
+                    (message?: any, ...optionalParams: any[]): void;
+                } | undefined;
+            }>;
+            debug?: {
+                (...data: any[]): void;
+                (message?: any, ...optionalParams: any[]): void;
+            } | undefined;
+        }>;
+        debug?: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        } | undefined;
+    }>;
+    debug?: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    } | undefined;
+}) => (_learnCard: LearnCard<any, any, any>, credential: VC, options?: Partial<ProofOptions>, prettify?: boolean) => Promise<VerificationItem[] | VerificationCheck>;

package/dist/wallet/plugins/test-cache/index.d.ts

@@ -0,0 +1,2 @@
+import { TestCachePlugin } from './types';
+export declare const getTestCache: () => TestCachePlugin;

package/dist/wallet/plugins/test-cache/types.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../../types/wallet';
+export type TestCachePlugin = Plugin<'Test Cache', 'cache'>;

package/dist/wallet/plugins/test-index/index.d.ts

@@ -0,0 +1,2 @@
+import { TestIndexPlugin } from './types';
+export declare const getTestIndex: () => TestIndexPlugin;

package/dist/wallet/plugins/test-index/types.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../../types/wallet';
+export type TestIndexPlugin = Plugin<'Test Index', 'index'>;