@learncard/core 7.0.3 → 8.0.1

package/dist/core.d.ts

@@ -2,6 +2,7 @@
 
 /// <reference types="node" />
 
+import { CeramicClient } from '@ceramicnetwork/http-client';
 import { StreamID } from '@ceramicnetwork/streamid';
 import { ModelAliases } from '@glazed/types';
 
@@ -4663,8 +4664,7 @@ declare const VerificationItemValidator: z.ZodObject<{
 	check: string;
 }>;
 export declare type VerificationItem = z.infer<typeof VerificationItemValidator>;
-/** @group IDXPlugin */
-export declare type IDXCredential<Metadata extends Record<string, any> = Record<never, never>> = {
+export declare type CredentialRecord<Metadata extends Record<string, any> = Record<never, never>> = {
 	id: string;
 	uri: string;
 	[key: string]: any;
@@ -4689,6 +4689,177 @@ declare const JWKValidator: z.ZodObject<{
 	d: string;
 }>;
 export declare type JWK = z.infer<typeof JWKValidator>;
+export declare type InitFunction<Args extends Record<string, any> = Record<string, any>, Config extends keyof LearnCardConfig | undefined = keyof LearnCardConfig, ReturnValue extends LearnCard<any, any> = LearnCard<any, any>> = {
+	args: Args & (undefined extends Config ? {} : Partial<Pick<LearnCardConfig, NonNullable<Config>>>);
+	returnValue: ReturnValue;
+};
+export declare type GenericInitFunction<InitFunctions extends InitFunction<any, any, any>[]> = {
+	args: InitFunctions[number]["args"];
+	returnValue: Promise<InitFunctions[number]["returnValue"]>;
+};
+export declare type DiscriminatedUnionize<T extends object = {}, K extends string = "type"> = {
+	[Key in keyof T]: {
+		[Key2 in K]: Key;
+	} & T[Key];
+}[keyof T];
+export declare type OmitNevers<T extends Record<string, any>> = Omit<T, {
+	[Index in keyof T]: [
+		T[Index]
+	] extends [
+		never
+	] ? Index : never;
+}[keyof T]>;
+export declare type CacheStrategy = "cache-only" | "cache-first" | "skip-cache";
+export declare type PlaneOptions = {
+	cache?: CacheStrategy;
+};
+export declare type ControlPlane = "read" | "store" | "index" | "cache" | "id";
+export declare type FilterForPlane<Plugins extends Plugin[], Plane extends ControlPlane> = {
+	[Index in keyof Plugins]: undefined extends Plugins[Index][Plane] ? never : Plugins[Index]["name"];
+}[number];
+export declare type GetPlanesForPlugins<Plugins extends Plugin[]> = any[] extends Plugins ? never : {
+	[Index in keyof Plugins]: {
+		[Key in ControlPlane]: undefined extends Plugins[Index][Key] ? never : Key;
+	}[ControlPlane];
+}[number];
+export declare type GetPlaneProviders<Plugins extends Plugin[], Plane extends ControlPlane> = any[] extends Plugins ? any : {
+	[Index in keyof Plugins]: undefined extends Plugins[Index][Plane] ? never : OmitNevers<{
+		[Name in Plugins[number]["name"]]: Name extends Plugins[Index]["name"] ? {
+			name: Name;
+			displayName?: string;
+			description?: string;
+		} : never;
+	}>;
+}[number];
+export declare type ReadPlane = {
+	get: (uri?: string, options?: PlaneOptions) => Promise<VC | undefined>;
+};
+export declare type PluginReadPlane = ReadPlane;
+export declare type LearnCardReadPlane<Plugins extends Plugin[]> = ReadPlane & {
+	providers: GetPlaneProviders<Plugins, "read">;
+};
+export declare type StorePlane = {
+	upload: (vc: VC, options?: PlaneOptions) => Promise<string>;
+	uploadMany?: (vcs: VC[], options?: PlaneOptions) => Promise<string[]>;
+};
+export declare type PluginStorePlane = StorePlane;
+export declare type LearnCardStorePlane<Plugins extends Plugin[]> = Record<FilterForPlane<Plugins, "store">, StorePlane> & {
+	providers: GetPlaneProviders<Plugins, "store">;
+};
+export declare type IndexPlane = {
+	get: <Metadata extends Record<string, any> = Record<never, never>>(query?: Record<string, any>, options?: PlaneOptions) => Promise<CredentialRecord<Metadata>[]>;
+	add: <Metadata extends Record<string, any> = Record<never, never>>(obj: CredentialRecord<Metadata>, options?: PlaneOptions) => Promise<boolean>;
+	update: (id: string, updates: Record<string, any>, options?: PlaneOptions) => Promise<boolean>;
+	remove: (id: string, options?: PlaneOptions) => Promise<boolean>;
+};
+export declare type PluginIndexPlane = IndexPlane;
+export declare type LearnCardIndexPlane<Plugins extends Plugin[]> = {
+	all: Pick<IndexPlane, "get">;
+	providers: GetPlaneProviders<Plugins, "index">;
+} & Record<FilterForPlane<Plugins, "index">, IndexPlane>;
+export declare type CachePlane = {
+	getIndex: <Metadata extends Record<string, any> = Record<never, never>>(name: string, query: Record<string, any>) => Promise<CredentialRecord<Metadata>[] | undefined>;
+	setIndex: <Metadata extends Record<string, any> = Record<never, never>>(name: string, query: Record<string, any>, value: CredentialRecord<Metadata>[]) => Promise<boolean>;
+	flushIndex: () => Promise<boolean>;
+	getVc: (uri: string) => Promise<VC | undefined>;
+	setVc: (uri: string, value: VC | undefined) => Promise<boolean>;
+	flushVc: () => Promise<boolean>;
+};
+export declare type PluginCachePlane = CachePlane;
+export declare type LearnCardCachePlane<Plugins extends Plugin[]> = CachePlane & {
+	providers: GetPlaneProviders<Plugins, "cache">;
+};
+export declare type IdPlane = {
+	did: (method?: string, options?: PlaneOptions) => string;
+	keypair: (algorithm?: string, options?: PlaneOptions) => JWK;
+};
+export declare type PluginIdPlane = IdPlane;
+export declare type LearnCardIdPlane<Plugins extends Plugin[]> = IdPlane & {
+	providers: GetPlaneProviders<Plugins, "id">;
+};
+/** @group Utility Types */
+export declare type Last<T extends any[]> = T extends [
+	...any[],
+	infer R
+] ? R : never;
+/** @group Utility Types */
+export declare type RemoveLast<T extends any[]> = T extends [
+	...infer R,
+	any
+] ? R : [
+];
+/** @group Utility Types */
+export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/** @group Utility Types */
+export declare type MergeObjects<Objects extends Record<string, any>[]> = undefined extends Objects[2] ? Omit<Objects[0], keyof Objects[1]> & Objects[1] : Omit<MergeObjects<RemoveLast<Objects>>, keyof Last<Objects>> & Last<Objects>;
+export declare type GenerateLearnCard<NewControlPlanes extends ControlPlane = never, NewMethods extends Record<string, (...args: any[]) => any> = Record<never, never>, ControlPlanes extends ControlPlane = never, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>> = LearnCard<any, [
+	ControlPlanes
+] extends [
+	1 & ControlPlanes
+] ? NewControlPlanes : [
+	NewControlPlanes
+] extends [
+	1 & NewControlPlanes
+] ? ControlPlanes : ControlPlanes | NewControlPlanes, NewMethods & Methods>;
+export declare type AddImplicitLearnCardArgument<Functions extends Record<string, (...args: any[]) => any> = Record<never, never>, ControlPlanes extends ControlPlane = never, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>, DependentControlPlanes extends ControlPlane = never, DependentMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = {
+	[Key in keyof Functions]: <T extends GenerateLearnCard<ControlPlanes, Methods, DependentControlPlanes, DependentMethods>>(learnCard: T, ...args: Parameters<Functions[Key]>) => ReturnType<Functions[Key]>;
+};
+/** @group Universal Wallets */
+export declare type GetPluginMethods<Plugins extends Plugin[]> = undefined extends Plugins[1] ? NonNullable<Plugins[0]["_methods"]> : UnionToIntersection<NonNullable<MergeObjects<{
+	[Key in keyof Plugins]: NonNullable<Plugins[Key]["_methods"]>;
+}>>>;
+/** @group Universal Wallets */
+export declare type Plugin<Name extends string = string, ControlPlanes extends ControlPlane = any, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>, DependentControlPlanes extends ControlPlane = never, DependentMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = {
+	name: Name;
+	displayName?: string;
+	description?: string;
+	methods: AddImplicitLearnCardArgument<Methods, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+	_methods?: Methods;
+	read?: {};
+	store?: {};
+	index?: {};
+	cache?: {};
+	id?: {};
+} & ([
+	ControlPlanes
+] extends [
+	1 & ControlPlanes
+] ? {} : ("read" extends ControlPlanes ? {
+	read: AddImplicitLearnCardArgument<PluginReadPlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ("store" extends ControlPlanes ? {
+	store: AddImplicitLearnCardArgument<PluginStorePlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ("index" extends ControlPlanes ? {
+	index: AddImplicitLearnCardArgument<PluginIndexPlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ("cache" extends ControlPlanes ? {
+	cache: AddImplicitLearnCardArgument<PluginCachePlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ("id" extends ControlPlanes ? {
+	id: AddImplicitLearnCardArgument<PluginIdPlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}));
+/** @group Universal Wallets */
+export declare type LearnCard<Plugins extends Plugin[] = [
+], ControlPlanes extends ControlPlane = GetPlanesForPlugins<Plugins>, PluginMethods = GetPluginMethods<Plugins>> = {
+	plugins: Plugins;
+	invoke: PluginMethods;
+	addPlugin: <NewPlugin extends Plugin>(plugin: NewPlugin) => Promise<LearnCard<[
+		...Plugins,
+		NewPlugin
+	]>>;
+	debug?: typeof console.log;
+} & ([
+	ControlPlanes
+] extends [
+	1 & ControlPlanes
+] ? {} : ("read" extends ControlPlanes ? {
+	read: LearnCardReadPlane<Plugins>;
+} : {}) & ("store" extends ControlPlanes ? {
+	store: LearnCardStorePlane<Plugins>;
+} : {}) & ("index" extends ControlPlanes ? {
+	index: LearnCardIndexPlane<Plugins>;
+} : {}) & ("cache" extends ControlPlanes ? {
+	cache: LearnCardCachePlane<Plugins>;
+} : {}) & ("id" extends ControlPlanes ? {
+	id: LearnCardIdPlane<Plugins>;
+} : {}));
 /** @group DIDKit Plugin */
 export declare 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 */
@@ -4721,48 +4892,89 @@ export declare type DidkitPluginMethods = {
 	contextLoader: (url: string) => Promise<Record<string, any>>;
 	resolveDid: (did: string, inputMetadata?: InputMetadata) => Promise<Record<string, any>>;
 };
+/** @group DIDKit Plugin */
+export declare type DIDKitPlugin = Plugin<"DIDKit", any, DidkitPluginMethods>;
 /** @group DidKey Plugin */
 export declare type Algorithm = "ed25519" | "secp256k1";
 /** @group DidKey Plugin */
-export declare type DependentMethods<T extends string> = {
+export declare type DependentMethods<DidMethod extends string> = {
 	generateEd25519KeyFromBytes: (bytes: Uint8Array) => JWK;
 	generateSecp256k1KeyFromBytes: (bytes: Uint8Array) => JWK;
-	keyToDid: (type: T, keypair: JWK) => string;
+	keyToDid: (method: DidMethod, keypair: JWK) => string;
 };
 /** @group DidKey Plugin */
 export declare type DidKeyPluginMethods<DidMethod extends string> = {
-	getSubjectDid: (type: DidMethod) => string;
-	getSubjectKeypair: (type?: Algorithm) => JWK;
+	getSubjectDid: (method?: DidMethod) => string;
+	getSubjectKeypair: (algorithm?: Algorithm) => JWK;
 	getKey: () => string;
 };
-/** @group Ethereum Plugin */
-export declare type EthereumPluginMethods = {
-	getEthereumAddress: () => string;
-	getBalance: (symbolOrAddress?: string) => Promise<string>;
-	getBalanceForAddress: (walletAddress: string, symbolOrAddress?: string) => Promise<string>;
-	transferTokens: (tokenSymbolOrAddress: string, amount: number, toAddress: string) => Promise<string>;
-	getGasPrice: () => Promise<string>;
-	getCurrentNetwork: () => providers.Networkish;
-	changeNetwork: (network: providers.Networkish) => void;
-	addInfuraProjectId: (infuraProjectIdToAdd: string) => void;
+/** @group DidKey Plugin */
+export declare type DidKeyPlugin<DidMethod extends string = string> = Plugin<"DID Key", "id", DidKeyPluginMethods<DidMethod>, any, DependentMethods<DidMethod>>;
+/** @group VC Plugin */
+export declare type VCPluginDependentMethods = {
+	getSubjectDid: (type: "key") => string;
+	getSubjectKeypair: () => JWK;
+	keyToVerificationMethod: (type: string, keypair: JWK) => 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, options?: ProofOptions) => Promise<VerificationCheck>;
 };
-/** @group Ethereum Plugin */
-export declare type EthereumConfig = {
-	infuraProjectId?: string;
-	network?: providers.Networkish;
+/** @group VC Plugin */
+export declare type VCPluginMethods = {
+	issueCredential: (credential: UnsignedVC, signingOptions?: Partial<ProofOptions>) => Promise<VC>;
+	verifyCredential: (credential: VC, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+	issuePresentation: (credential: UnsignedVP, signingOptions?: Partial<ProofOptions>) => Promise<VP>;
+	verifyPresentation: (presentation: VP, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+	getTestVc: (subject?: string) => UnsignedVC;
+	getTestVp: (credential?: VC) => Promise<UnsignedVP>;
 };
-/** @group Ethereum Plugin */
-export declare type Token = {
-	chainId: number;
-	address: string;
-	name: string;
-	symbol: string;
-	decimals: number;
-	logoURI: string;
-	extensions: any;
+/** @group VC Plugin */
+export declare type VCDependentLearnCard = LearnCard<any, "id", VCPluginDependentMethods>;
+/** @group VC Plugin */
+export declare type VCImplicitLearnCard = LearnCard<any, "id", VCPluginMethods & VCPluginDependentMethods>;
+/** @group VC Plugin */
+export declare type VerifyExtension = {
+	verifyCredential: (credential: VC) => Promise<VerificationCheck>;
 };
-/** @group Ethereum Plugin */
-export declare type TokenList = Token[];
+/** @group VC Plugin */
+export declare type VCPlugin = Plugin<"VC", any, VCPluginMethods, "id", VCPluginDependentMethods>;
+/** @group VC Templates Plugin */
+export declare type VcTemplates = {
+	basic: {
+		did?: string;
+		subject?: string;
+		issuanceDate?: string;
+	};
+	achievement: {
+		did?: string;
+		subject?: string;
+		name?: string;
+		achievementName?: string;
+		description?: string;
+		criteriaNarrative?: string;
+		issuanceDate?: string;
+	};
+};
+/** @group VC Templates Plugin */
+export declare type NewCredentialFunction = (args?: DiscriminatedUnionize<VcTemplates>) => UnsignedVC;
+/** @group VC Templates Plugin */
+export declare type VCTemplatePluginDependentMethods = {
+	getSubjectDid?: (type: "key") => string;
+};
+/** @group VC Templates Plugin */
+export declare type VCTemplatePluginMethods = {
+	newCredential: NewCredentialFunction;
+	newPresentation: (credential: VC, args?: {
+		did?: string;
+	}) => Promise<UnsignedVP>;
+};
+/** @group VC Templates Plugin */
+export declare type VCTemplatePlugin = Plugin<"VC Templates", any, VCTemplatePluginMethods, "id", VCTemplatePluginDependentMethods>;
+/**
+ * @group Plugins
+ */
+export declare const getVCTemplatesPlugin: () => VCTemplatePlugin;
 /** @group VC Resolution Plugin */
 export declare type LC_URI<URI extends string = ""> = string | URI;
 /** @group VC Resolution Plugin */
@@ -4773,71 +4985,58 @@ export declare type VCResolutionPluginMethods = {
 export declare type ResolutionExtension<URI extends string> = {
 	resolveCredential: (uri?: LC_URI<URI>) => Promise<VC | undefined>;
 };
-export declare type Last<T extends any[]> = T extends [
-	...any[],
-	infer R
-] ? R : never;
-export declare type RemoveLast<T extends any[]> = T extends [
-	...infer R,
-	any
-] ? R : [
-];
-/** @group Utility Types */
-export declare type MergeObjects<Objects extends Record<string, any>[]> = undefined extends Objects[2] ? Omit<Objects[0], keyof Objects[1]> & Objects[1] : Omit<MergeObjects<RemoveLast<Objects>>, keyof Last<Objects>> & Last<Objects>;
-/** @group Universal Wallets */
-export declare type Plugin<Name extends string, PublicMethods extends Record<string, (...args: any[]) => any> = Record<never, never>, DependentMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = {
-	name?: Name;
-	pluginMethods: {
-		[Key in keyof PublicMethods]: <T extends Wallet<any, PublicMethods & DependentMethods>>(wallet: T, ...args: Parameters<PublicMethods[Key]>) => ReturnType<PublicMethods[Key]>;
-	};
-};
-/** @group Universal Wallets */
-export declare type PublicFieldsObj<PluginMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = {
-	pluginMethods: PluginMethods;
-};
-/** @group Universal Wallets */
-export declare type Wallet<PluginNames extends string = "", PluginMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = PublicFieldsObj<PluginMethods> & {
-	contents: any[];
-	plugins: Plugin<PluginNames, Record<string, (...args: any[]) => any>>[];
-	add: (content: any) => Promise<Wallet<PluginNames, PluginMethods>>;
-	remove: (contentId: string) => Promise<Wallet<PluginNames, PluginMethods>>;
-	addPlugin: <Name extends string, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>>(plugin: Plugin<Name, Methods>) => Promise<Wallet<"" extends PluginNames ? Name : PluginNames | Name, Record<never, never> extends PluginMethods ? Methods : MergeObjects<[
-		PluginMethods,
-		Methods
-	]>>>;
-};
-/** @group IDXPlugin */
-export declare type CeramicIDXArgs = {
-	modelData: ModelAliases;
-	credentialAlias: string;
+export declare type VCResolutionPluginType = Plugin<"VC Resolution", any, VCResolutionPluginMethods>;
+/**
+ * @group Plugins
+ */
+export declare const VCResolutionPlugin: VCResolutionPluginType;
+/** @group CeramicPlugin */
+export declare type CeramicArgs = {
 	ceramicEndpoint: string;
 	defaultContentFamily: string;
 };
-/** @group IDXPlugin */
+/** @group CeramicPlugin */
 export declare type CeramicURI = `lc:ceramic:${string}`;
-/** @group IDXPlugin */
+/** @group CeramicPlugin */
 export declare const CeramicURIValidator: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-/** @group IDXPlugin */
-export declare type IDXPluginMethods<URI extends string = ""> = {
-	getCredentialsListFromIdx: <Metadata extends Record<string, any> = Record<never, never>>(alias?: string) => Promise<CredentialsList<Metadata>>;
+/** @group CeramicPlugin */
+export declare type CeramicPluginMethods<URI extends string = ""> = {
 	publishContentToCeramic: (cred: any) => Promise<CeramicURI>;
 	readContentFromCeramic: (streamId: string) => Promise<any>;
+	getCeramicClient: () => CeramicClient;
+} & ResolutionExtension<URI | CeramicURI>;
+/** @group CeramicPlugin */
+export declare type CeramicPluginDependentMethods<URI extends string = ""> = {
+	getKey: () => string;
+} & ResolutionExtension<URI>;
+/** @group CeramicPlugin */
+export declare type CeramicPlugin = Plugin<"Ceramic", "read" | "store", CeramicPluginMethods>;
+/** @group IDXPlugin */
+export declare type IDXArgs = {
+	modelData: ModelAliases;
+	credentialAlias: string;
+};
+/** @group IDXPlugin */
+export declare 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: IDXCredential<Metadata>) => Promise<CeramicURI>;
+	addVerifiableCredentialInIdx: <Metadata extends Record<string, any> = Record<never, never>>(cred: CredentialRecord<Metadata>) => Promise<string>;
 	removeVerifiableCredentialInIdx: (title: string) => Promise<StreamID>;
-} & ResolutionExtension<URI | CeramicURI>;
+};
 /** @group IDXPlugin */
 export declare type IDXPluginDependentMethods<URI extends string = ""> = {
-	getKey: () => string;
+	getCeramicClient: () => CeramicClient;
 } & ResolutionExtension<URI>;
 /** @group IDXPlugin */
 export declare type CredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
-	credentials: Array<IDXCredential<Metadata>>;
+	credentials: Array<CredentialRecord<Metadata>>;
 };
 /** @group IDXPlugin */
 export declare const CredentialsListValidator: z.ZodType<CredentialsList>;
 /** @group IDXPlugin */
+export declare type IDXPlugin = Plugin<"IDX", "index", IDXPluginMethods, "read", IDXPluginDependentMethods>;
+/** @group IDXPlugin */
 export declare type BackwardsCompatIDXCredential<Metadata extends Record<string, any> = Record<never, never>> = {
 	[key: string]: any;
 	id: string;
@@ -4848,35 +5047,45 @@ export declare type BackwardsCompatIDXCredential<Metadata extends Record<string,
 export declare const BackwardsCompatIDXCredentialValidator: z.ZodType<BackwardsCompatIDXCredential>;
 /** @group IDXPlugin */
 export declare type BackwardsCompatCredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
-	credentials: Array<IDXCredential<Metadata> | BackwardsCompatIDXCredential<Metadata>>;
+	credentials: Array<CredentialRecord<Metadata> | BackwardsCompatIDXCredential<Metadata>>;
 };
 /** @group IDXPlugin */
 export declare const BackwardsCompatCredentialsListValidator: z.ZodType<BackwardsCompatCredentialsList>;
-/** @group VC Plugin */
-export declare type VCPluginDependentMethods = {
-	getSubjectDid: (type: "key") => string;
-	getSubjectKeypair: () => JWK;
-	keyToVerificationMethod: (type: string, keypair: JWK) => 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, options?: ProofOptions) => Promise<VerificationCheck>;
+/**
+ * @group Plugins
+ */
+export declare const getVCPlugin: (learnCard: VCDependentLearnCard) => VCPlugin;
+export declare type ExpirationPlugin = Plugin<"Expiration", any, VerifyExtension>;
+/** @group Ethereum Plugin */
+export declare type EthereumPluginMethods = {
+	getEthereumAddress: () => string;
+	getBalance: (symbolOrAddress?: string) => Promise<string>;
+	getBalanceForAddress: (walletAddress: string, symbolOrAddress?: string) => Promise<string>;
+	transferTokens: (tokenSymbolOrAddress: string, amount: number, toAddress: string) => Promise<string>;
+	getGasPrice: () => Promise<string>;
+	getCurrentNetwork: () => providers.Networkish;
+	changeNetwork: (network: providers.Networkish) => void;
+	addInfuraProjectId: (infuraProjectIdToAdd: string) => void;
 };
-/** @group VC Plugin */
-export declare type VCPluginMethods = {
-	issueCredential: (credential: UnsignedVC, signingOptions?: Partial<ProofOptions>) => Promise<VC>;
-	verifyCredential: (credential: VC, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
-	issuePresentation: (credential: UnsignedVP, signingOptions?: Partial<ProofOptions>) => Promise<VP>;
-	verifyPresentation: (presentation: VP, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
-	getTestVc: (subject?: string) => UnsignedVC;
-	getTestVp: (credential?: VC) => Promise<UnsignedVP>;
+/** @group Ethereum Plugin */
+export declare type EthereumConfig = {
+	infuraProjectId?: string;
+	network?: providers.Networkish;
 };
-/** @group VC Plugin */
-export declare type VCImplicitWallet = Wallet<string, VCPluginMethods & VCPluginDependentMethods>;
-/** @group VC Plugin */
-export declare type VerifyExtension = {
-	verifyCredential: (credential: VC) => Promise<VerificationCheck>;
+/** @group Ethereum Plugin */
+export declare type Token = {
+	chainId: number;
+	address: string;
+	name: string;
+	symbol: string;
+	decimals: number;
+	logoURI: string;
+	extensions: any;
 };
+/** @group Ethereum Plugin */
+export declare type TokenList = Token[];
+/** @group Ethereum Plugin */
+export declare type EthereumPlugin = Plugin<"Ethereum", any, EthereumPluginMethods, "id">;
 /** @group VPQR Plugin */
 export declare type VpqrPluginMethods = {
 	vpFromQrCode: (text: string) => Promise<VP>;
@@ -4886,6 +5095,7 @@ export declare type VpqrPluginMethods = {
 export declare type VpqrPluginDependentMethods = {
 	contextLoader: (url: string) => Promise<Record<string, any>>;
 };
+export declare type VpqrPlugin = Plugin<"Vpqr", any, VpqrPluginMethods, any, VpqrPluginDependentMethods>;
 /** @group CHAPI Plugin */
 export declare type WebCredential = {
 	new (dataType: string, data: VP, options?: {
@@ -4969,49 +5179,12 @@ export declare type CHAPIPluginMethods = {
 	}>;
 	storePresentationViaChapi: (presentation: UnsignedVP | VP) => Promise<Credential | undefined>;
 };
+/** @group CHAPI Plugin */
+export declare type CHAPIPlugin = Plugin<"CHAPI", any, CHAPIPluginMethods, any, CHAPIPluginDependentMethods>;
 /**
  * @group Plugins
  */
-export declare const getCHAPIPlugin: () => Promise<Plugin<"CHAPI", CHAPIPluginMethods, CHAPIPluginDependentMethods>>;
-export declare type InitFunction<Args extends Record<string, any> = Record<string, any>, Config extends keyof LearnCardConfig = keyof LearnCardConfig, ReturnValue extends LearnCard<any, any> = LearnCard<any, any>> = {
-	args: Args & Partial<Pick<LearnCardConfig, Config>>;
-	returnValue: ReturnValue;
-};
-export declare type GenericInitFunction<InitFunctions extends InitFunction<any, any, any>[]> = {
-	args: InitFunctions[number]["args"];
-	returnValue: Promise<InitFunctions[number]["returnValue"]>;
-};
-export declare type DiscriminatedUnionize<T extends object = {}, K extends string = "type"> = {
-	[Key in keyof T]: {
-		[Key2 in K]: Key;
-	} & T[Key];
-}[keyof T];
-/** @group VC Templates Plugin */
-export declare type VcTemplates = {
-	basic: {
-		did?: string;
-		subject?: string;
-		issuanceDate?: string;
-	};
-	achievement: {
-		did?: string;
-		subject?: string;
-		name?: string;
-		achievementName?: string;
-		description?: string;
-		criteriaNarrative?: string;
-		issuanceDate?: string;
-	};
-};
-/** @group VC Templates Plugin */
-export declare type NewCredentialFunction = (args?: DiscriminatedUnionize<VcTemplates>) => UnsignedVC;
-/** @group VC Templates Plugin */
-export declare type VCTemplatePluginMethods = {
-	newCredential: NewCredentialFunction;
-	newPresentation: (credential: VC, args?: {
-		did?: string;
-	}) => Promise<UnsignedVP>;
-};
+export declare const getCHAPIPlugin: () => Promise<CHAPIPlugin>;
 /** @group VC-API Plugin */
 export declare type APIOptions = {
 	created?: string;
@@ -5028,422 +5201,755 @@ export declare type VCAPIPluginMethods = {
 	getTestVc: (subject?: string) => UnsignedVC;
 	getTestVp: (credential?: VC) => Promise<UnsignedVP>;
 };
+/** @group VC-API Plugin */
+export declare type VCAPIPlugin = Plugin<"VC API", "id", VCAPIPluginMethods>;
 /**
  *
  * @group Plugins
  */
-export declare const getDidKitPlugin: (input?: InitInput | Promise<InitInput>) => Promise<Plugin<"DIDKit", DidkitPluginMethods>>;
-/**
- *
- * @group Plugins
- */
-export declare const getDidKeyPlugin: <DidMethod extends string>(wallet: Wallet<string, DependentMethods<DidMethod>>, key: string) => Promise<Plugin<"DID Key", DidKeyPluginMethods<DidMethod>, Record<never, never>>>;
-/**
- * @group Plugins
- */
-export declare const getVCPlugin: (wallet: Wallet<string, VCPluginDependentMethods>) => Plugin<"VC", VCPluginMethods, VCPluginDependentMethods>;
-/**
- * @group Plugins
- */
-export declare const getIDXPlugin: <URI extends string = "">(wallet: Wallet<any, IDXPluginDependentMethods<URI>>, { modelData, credentialAlias, ceramicEndpoint, defaultContentFamily }: CeramicIDXArgs) => Promise<Plugin<"IDX", IDXPluginMethods<URI>, Record<never, never>>>;
-/**
- * @group Plugins
- */
-export declare const ExpirationPlugin: (wallet: Wallet<any, VerifyExtension>) => Plugin<"Expiration", VerifyExtension>;
-/**
- * @group Plugins
- */
-export declare const getEthereumPlugin: (initWallet: Wallet<string, {
-	getSubjectDid: (type: DidMethod) => string;
-	getSubjectKeypair: (type?: Algorithm) => JWK;
-}>, config: EthereumConfig) => Plugin<"Ethereum", EthereumPluginMethods>;
-/**
- * @group Plugins
- */
-export declare const getVpqrPlugin: (wallet: Wallet<string, VpqrPluginDependentMethods>) => Plugin<"Vpqr", VpqrPluginMethods>;
-/**
- * Wallet holder's did
- *
- * @group LearnCard Methods
- */
-export declare type Did = (type?: DidMethod) => string;
-/**
- * Wallet holder's ed25519 key pair
- *
- * @group LearnCard Methods
- */
-export declare type Keypair = (type?: Algorithm) => {
-	kty: string;
-	crv: string;
-	x: string;
-	y?: string;
-	d: string;
+export declare const getDidKitPlugin: (input?: InitInput | Promise<InitInput>) => Promise<DIDKitPlugin>;
+export declare type VerifyCredential = {
+	(vc: VC, options?: Partial<ProofOptions>): Promise<VerificationCheck>;
+	(vc: VC, options: Partial<ProofOptions>, prettify: true): Promise<VerificationItem[]>;
 };
-/**
- * Generates a new Unsigned VC from a template
- *
- * @group LearnCard Methods
- */
-export declare type NewCredential = NewCredentialFunction;
-/**
- * Wraps a VC in a simple Presentation
- *
- * @group LearnCard Methods
- */
-export declare type NewPresentation = (credential: VC, args?: {
-	did?: string;
-}) => Promise<UnsignedVP>;
-/**
- * Signs an unsigned Verifiable Credential, returning the signed VC
- *
- * @group LearnCard Methods
- */
-export declare type IssueCredential = (credential: UnsignedVC, signingOptions?: Partial<ProofOptions>) => Promise<VC>;
-/**
- * Verifies a signed Verifiable Credential
- *
- * Empty error/warnings arrays means verification was successful
- *
- * @group LearnCard Methods
- */
-export declare type VerifyCredential = (credential: VC, options?: Partial<ProofOptions>) => Promise<VerificationItem[]>;
-/**
- * Signs an unsigned Verifiable Presentation, returning the signed VP
- *
- * @group LearnCard Methods
- */
-export declare type IssuePresentation = (presentation: UnsignedVP, signingOptions?: Partial<ProofOptions>) => Promise<VP>;
-/**
- * Verifies a signed Verifiable Presentation
- *
- * Empry error/warnings arrays means verification was successful
- *
- * @group LearnCard Methods
- */
-export declare type VerifyPresentation = (presentation: VP, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
-/**
- * Returns the credential marked with `title` from IDX
- *
- * @group LearnCard Methods
- */
-export declare type GetCredential = (title: string) => Promise<VC | undefined>;
-/**
- * Returns all credentials from IDX
- *
- * @group LearnCard Methods
- */
-export declare type GetCredentials = () => Promise<VC[]>;
-/**
- * Returns all credentials from IDX
- *
- * @group LearnCard Methods
- */
-export declare type GetCredentialsList = <Metadata extends Record<string, any> = Record<never, never>>() => Promise<IDXCredential<Metadata>[]>;
-/**
- * Publishes a credential to Ceramic, returning the credential's Ceramic URI
- *
- * This URI may then be shared/persisted/resolved to gain access to the credential
- *
- * Resolving a URI can be done by passing the URI to `resolveCredential`
- *
- * @group LearnCard Methods
- */
-export declare type PublishCredential = (credential: VC) => Promise<CeramicURI>;
-/**
- * Adds a URI pointing to a credential (such as the one returned by `publishCredential`)
- * to IDX with a bespoke ID
- *
- * The credential may then be retrieved using `getCredential` and passing in that bespoke ID,
- * or by using `getCredentials`/`getCredentialsList` to get a list of all credentials that have been added to IDX
- *
- * @group LearnCard Methods
- */
-export declare type AddCredential = <Metadata extends Record<string, any> = Record<never, never>>(credential: IDXCredential<Metadata>) => Promise<void>;
-/**
- * Removes a credential from IDX by passing in its bespoke ID
- *
- * @group LearnCard Methods
- */
-export declare type RemoveCredential = (id: string) => Promise<void>;
-/**
- * Resolves a did to its did document
- *
- * @group LearnCard Methods
- */
-export declare type ResolveDid = (did: string, inputMetadata?: InputMetadata) => Promise<Record<string, any>>;
-/**
- * Resolves a stream ID, returning its contents
- *
- * @group LearnCard Methods
- */
-export declare type ReadFromCeramic = (streamId: string) => Promise<any>;
-/**
- * Resolves a LearnCard URI (e.g. lc:ceramic:1234561)
- *
- * This can be given the return value of `publishCredential` to gain access to the credential
- * that was published
- *
- * @group LearnCard Methods
- */
-export declare type ResolveCredential = (URI?: string | "" | `lc:ceramic:${string}`) => Promise<VC | undefined>;
-/**
- * Returns an example credential, optionally allowing a subject's did to be passed in
- *
- * You can use this to test out implementations that use this library!
- *
- * @group LearnCard Methods
- */
-export declare type GetTestVc = (subject?: string) => UnsignedVC;
-/**
- * Wraps a crednetial in an exmaple presentaion. If no credential is provided, a new one will be
- * generated using getTestVc
- *
- * You can use this to test out implementations that use this library!
- *
- * @group LearnCard Methods
- */
-export declare type GetTestVp = (credential?: VC) => Promise<UnsignedVP>;
-/**
- * Returns Ethereum public address
- *
- * @group LearnCard Methods
- */
-export declare type GetEthereumAddress = () => string;
-/**
- * Get the balance of an ERC20 token
- *   Defaults to ETH if symbolOrAddress is not provided
- *
- * @group LearnCard Methods
- */
-export declare type GetBalance = (symbolOrAddress?: string) => Promise<string>;
-/**
- * Get the balance of an ERC20 token for a given address
- *   Defaults to ETH if symbolOrAddress is not provided
- *
- * @group LearnCard Methods
- */
-export declare type GetBalanceForAddress = (walletAddress: string, symbolOrAddress?: string) => Promise<string>;
-/**
- * Transfer tokens to a given address
- *
- * @group LearnCard Methods
- */
-export declare type TransferTokens = (tokenSymbolOrAddress: string, amount: number, toAddress: string) => Promise<string>;
-/**
- * Get the gas price of the current network
- *
- * @group LearnCard Methods
- */
-export declare type GetGasPrice = () => Promise<string>;
-/**
- * Get your current Ethereum network
- *
- * @group LearnCard Methods
- */
-export declare type GetCurrentNetwork = () => ethers.providers.Networkish;
-/**
- * Change your Ethereum network
- *
- * @group LearnCard Methods
- */
-export declare type ChangeNetwork = (network: ethers.providers.Networkish) => void;
-/**
- * Add an infura project id to an existing wallet.
- * Really only useful for testing with the CLI right now...
- *
- * @group LearnCard Methods
- */
-export declare type AddInfuraProjectId = (infuraProjectIdToAdd: string) => void;
-/**
- * Returns a Verifiable Presentation (VP) from a QR code base-64 image data string containing a VP compressed by CBOR-LD.
- *
- * @group LearnCard Methods
- */
-export declare type VpFromQrCode = (text: string) => Promise<VP>;
-/**
- * Returns a QR-embeddable base-64 image data string from a Verifiable Presentation, compressed using CBOR-LD.
- *
- * @group LearnCard Methods
- */
-export declare type VpToQrCode = (vp: VP) => Promise<string>;
-/**
- * Sets up CHAPI
- *
- * @group LearnCard Methods
- */
-export declare type InstallChapiHandler = () => Promise<void>;
-/**
- * Activates CHAPI
- *
- * @group LearnCard Methods
- */
-export declare type ActivateChapiHandler = (args: {
-	mediatorOrigin?: string;
-	get?: (event: CredentialRequestEvent) => Promise<HandlerResponse>;
-	store?: (event: CredentialStoreEvent) => Promise<HandlerResponse>;
-}) => Promise<void>;
-/**
- * Receives a CHAPI Event
- *
- * @group LearnCard Methods
- */
-export declare type ReceiveChapiEvent = () => Promise<CredentialRequestEvent | CredentialStoreEvent>;
-/**
- * Stores a VP via CHAPI
- *
- * @group LearnCard Methods
- */
-export declare type StorePresentationViaChapi = (presentation: VP) => Promise<Credential | undefined>;
-/**
- * Stores a Credential via CHAPI using DIDAuth
- *
- * @group LearnCard Methods
- */
-export declare type StoreCredentialViaChapiDidAuth = (credential: UnsignedVC) => Promise<{
-	success: true;
-} | {
-	success: false;
-	reason: "did not auth" | "auth failed verification" | "did not store";
-}>;
-/**
- * @group LearnCard Methods
- */
-export declare type AllLearnCardMethods = {
-	did: Did;
-	keypair: Keypair;
-	newCredential: NewCredential;
-	newPresentation: NewPresentation;
-	issueCredential: IssueCredential;
+/** @group LearnCard Plugin */
+export declare type LearnCardPluginDependentMethods = {
+	verifyCredential: (vc: VC, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+};
+/** @group LearnCard Plugin */
+export declare type LearnCardPluginMethods = {
 	verifyCredential: VerifyCredential;
-	issuePresentation: IssuePresentation;
-	verifyPresentation: VerifyPresentation;
-	getCredential: GetCredential;
-	getCredentials: GetCredentials;
-	getCredentialsList: GetCredentialsList;
-	publishCredential: PublishCredential;
-	addCredential: AddCredential;
-	removeCredential: RemoveCredential;
-	resolveDid: ResolveDid;
-	readFromCeramic: ReadFromCeramic;
-	resolveCredential: ResolveCredential;
-	getTestVc: GetTestVc;
-	getTestVp: GetTestVp;
-	getEthereumAddress: GetEthereumAddress;
-	getBalance: GetBalance;
-	getBalanceForAddress: GetBalanceForAddress;
-	transferTokens: TransferTokens;
-	getGasPrice: GetGasPrice;
-	getCurrentNetwork: GetCurrentNetwork;
-	changeNetwork: ChangeNetwork;
-	addInfuraProjectId: AddInfuraProjectId;
-	vpFromQrCode: VpFromQrCode;
-	vpToQrCode: VpToQrCode;
-	installChapiHandler: InstallChapiHandler;
-	activateChapiHandler: ActivateChapiHandler;
-	receiveChapiEvent: ReceiveChapiEvent;
-	storePresentationViaChapi: StorePresentationViaChapi;
-	storeCredentialViaChapiDidAuth: StoreCredentialViaChapiDidAuth;
 };
-/** @group Universal Wallets */
-export declare type LearnCardRawWallet = Wallet<"DIDKit" | "DID Key" | "VC" | "VC Templates" | "VC Resolution" | "IDX" | "Expiration" | "Ethereum" | "Vpqr" | "CHAPI", MergeObjects<[
-	DidKeyPluginMethods<DidMethod>,
-	VCPluginMethods,
-	VCTemplatePluginMethods,
-	VCResolutionPluginMethods,
-	IDXPluginMethods,
-	EthereumPluginMethods,
-	VpqrPluginMethods,
-	CHAPIPluginMethods
-]>>;
-/**
- * @group LearnCard
- */
-export declare type LearnCard<Methods extends keyof AllLearnCardMethods = keyof AllLearnCardMethods, RawWallet extends Wallet<any, any> = LearnCardRawWallet> = {
-	/** Raw IoE wallet instance. You shouldn't need to drop down to this level! */
-	_wallet: RawWallet;
-} & Pick<AllLearnCardMethods, Methods>;
-/**
- * @group LearnCard
- */
-export declare type EmptyLearnCard = LearnCard<"newCredential" | "newPresentation" | "verifyCredential" | "verifyPresentation" | "resolveDid" | "installChapiHandler" | "activateChapiHandler" | "receiveChapiEvent" | "storePresentationViaChapi" | "storeCredentialViaChapiDidAuth", Wallet<"DIDKit" | "Expiration" | "VC Templates" | "CHAPI", MergeObjects<[
-	DidkitPluginMethods,
-	VerifyExtension,
-	VCTemplatePluginMethods,
-	CHAPIPluginMethods
-]>>>;
-/**
- * @group LearnCard
- */
-export declare type VCAPILearnCard = LearnCard<"did" | "newCredential" | "newPresentation" | "issueCredential" | "verifyCredential" | "issuePresentation" | "verifyPresentation" | "getTestVc" | "getTestVp" | "installChapiHandler" | "activateChapiHandler" | "receiveChapiEvent" | "storePresentationViaChapi" | "storeCredentialViaChapiDidAuth", Wallet<"VC API" | "Expiration" | "VC Templates" | "CHAPI", MergeObjects<[
-	VCAPIPluginMethods,
-	VerifyExtension,
-	VCTemplatePluginMethods,
-	CHAPIPluginMethods
-]>>>;
+/** @group LearnCard Plugin */
+export declare type LearnCardPlugin = Plugin<"LearnCard", any, LearnCardPluginMethods, any, LearnCardPluginDependentMethods>;
 /** @group LearnCard */
 export declare type LearnCardConfig = {
-	ceramicIdx: CeramicIDXArgs;
+	ceramicIdx: CeramicArgs & IDXArgs;
 	didkit: InitInput | Promise<InitInput>;
-	defaultContents: any[];
 	ethereumConfig: EthereumConfig;
+	debug?: typeof console.log;
 };
 /** @group Init Functions */
-export declare type EmptyWallet = InitFunction<{}, "didkit", EmptyLearnCard>;
+export declare type EmptyLearnCard = InitFunction<{}, "didkit" | "debug", LearnCard<[
+	DIDKitPlugin,
+	ExpirationPlugin,
+	VCTemplatePlugin,
+	CHAPIPlugin,
+	LearnCardPlugin
+]>>;
 /** @group Init Functions */
-export declare type WalletFromKey = InitFunction<{
+export declare type LearnCardFromSeed = InitFunction<{
 	seed: string;
-}, keyof LearnCardConfig, LearnCard>;
+}, keyof LearnCardConfig, LearnCard<[
+	DIDKitPlugin,
+	DidKeyPlugin<DidMethod>,
+	VCPlugin,
+	VCTemplatePlugin,
+	VCResolutionPluginType,
+	CeramicPlugin,
+	IDXPlugin,
+	ExpirationPlugin,
+	EthereumPlugin,
+	VpqrPlugin,
+	CHAPIPlugin,
+	LearnCardPlugin
+]>>;
 /** @group Init Functions */
-export declare type WalletFromVcApi = InitFunction<{
+export declare type LearnCardFromVcApi = InitFunction<{
 	vcApi: true | string;
 	did?: string;
-}, "defaultContents", VCAPILearnCard>;
+}, "debug", LearnCard<[
+	VCAPIPlugin,
+	ExpirationPlugin,
+	VCTemplatePlugin,
+	CHAPIPlugin,
+	LearnCardPlugin
+]>>;
+/** @group Init Functions */
+export declare type CustomLearnCard = InitFunction<{
+	custom: true;
+}, "debug", LearnCard<[
+]>>;
 /** @group Init Functions */
 export declare type InitLearnCard = GenericInitFunction<[
-	EmptyWallet,
-	WalletFromKey,
-	WalletFromVcApi
+	EmptyLearnCard,
+	LearnCardFromSeed,
+	LearnCardFromVcApi,
+	CustomLearnCard
 ]>;
+/**
+ * Generates a custom LearnCard with no plugins added
+ *
+ * @group Init Functions
+ */
+export declare const customLearnCard: ({ debug }?: Partial<CustomLearnCard["args"]>) => Promise<CustomLearnCard["returnValue"]>;
 /**
  * Generates an empty wallet with no key material
  *
  * @group Init Functions
  */
-export declare const emptyWallet: ({ didkit }?: EmptyWallet["args"]) => Promise<EmptyWallet["returnValue"]>;
+export declare const emptyLearnCard: ({ didkit, debug }?: EmptyLearnCard["args"]) => Promise<EmptyLearnCard["returnValue"]>;
 /**
  * Generates a LearnCard Wallet from a 64 character seed string
  *
  * @group Init Functions
  */
-export declare const walletFromKey: (key: string, { ceramicIdx, didkit, defaultContents, ethereumConfig, }?: Partial<LearnCardConfig>) => Promise<LearnCard>;
+export declare const learnCardFromSeed: (seed: string, { ceramicIdx, didkit, ethereumConfig, debug, }?: Partial<LearnCardConfig>) => Promise<LearnCardFromSeed["returnValue"]>;
 /**
  * Generates a LearnCard Wallet from a 64 character seed string
  *
  * @group Init Functions
  */
-export declare const walletFromApiUrl: (url: string, did?: string, { defaultContents }?: Partial<LearnCardConfig>) => Promise<WalletFromVcApi["returnValue"]>;
+export declare const learnCardFromApiUrl: ({ url, did, debug, }: {
+	url: string;
+	did?: string | undefined;
+	debug?: {
+		(...data: any[]): void;
+		(message?: any, ...optionalParams: any[]): void;
+	} | undefined;
+}) => Promise<LearnCardFromVcApi["returnValue"]>;
 /**
  * Generates an Empty Wallet
  *
  * @group Init Functions
  */
-export declare function initLearnCard(config?: EmptyWallet["args"]): Promise<EmptyWallet["returnValue"]>;
+export declare function initLearnCard(config?: EmptyLearnCard["args"]): Promise<EmptyLearnCard["returnValue"]>;
 /**
  * Generates a full wallet from a 32 byte seed
  *
  * @group Init Functions
  */
-export declare function initLearnCard(config: WalletFromKey["args"]): Promise<WalletFromKey["returnValue"]>;
+export declare function initLearnCard(config: LearnCardFromSeed["args"]): Promise<LearnCardFromSeed["returnValue"]>;
 /**
  * Generates a wallet that can sign VCs/VPs from a VC API
  *
  * @group Init Functions
  */
-export declare function initLearnCard(config: WalletFromVcApi["args"]): Promise<WalletFromVcApi["returnValue"]>;
+export declare function initLearnCard(config: LearnCardFromVcApi["args"]): Promise<LearnCardFromVcApi["returnValue"]>;
+/**
+ * Generates a custom wallet with no plugins added
+ *
+ * @group Init Functions
+ */
+export declare function initLearnCard(config: CustomLearnCard["args"]): Promise<CustomLearnCard["returnValue"]>;
 /** @group Universal Wallets */
-export declare const generateWallet: <PluginNames extends string, PluginMethods extends Record<string, (...args: any[]) => any> = Record<never, never>>(contents?: any[], _wallet?: Partial<Wallet<any, PluginMethods>>) => Promise<Wallet<PluginNames, PluginMethods>>;
+export declare const generateLearnCard: <Plugins extends {
+	name: string;
+	displayName?: string | undefined;
+	description?: string | undefined;
+	methods: 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;
+}[] = [
+], ControlPlanes extends GetPlanesForPlugins<Plugins> = GetPlanesForPlugins<Plugins>, PluginMethods extends GetPluginMethods<Plugins> = GetPluginMethods<Plugins>>(_learnCard?: Partial<LearnCard<Plugins, ControlPlanes, PluginMethods>>) => Promise<LearnCard<Plugins, ControlPlanes, PluginMethods>>;
+/**
+ * @group Plugins
+ */
+export declare const getCeramicPlugin: <URI extends string = "">(learnCard: {
+	plugins: any;
+	invoke: CeramicPluginDependentMethods<URI>;
+	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;
+}, { ceramicEndpoint, defaultContentFamily }: CeramicArgs) => Promise<CeramicPlugin>;
+/**
+ *
+ * @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>>;
+/**
+ * @group Plugins
+ */
+export declare const getEthereumPlugin: (initLearnCard: LearnCard<any, "id">, config: EthereumConfig) => EthereumPlugin;
+/**
+ * @group Plugins
+ */
+export declare const expirationPlugin: (learnCard: LearnCard<any, any, VerifyExtension>) => ExpirationPlugin;
+/**
+ * @group Plugins
+ */
+export declare const getIDXPlugin: <URI extends string = "">(learnCard: LearnCard<any, "read", IDXPluginDependentMethods<URI>>, { modelData, credentialAlias }: IDXArgs) => Promise<IDXPlugin>;
+export declare type TestCachePlugin = Plugin<"Test Cache", "cache">;
+export declare const getTestCache: () => TestCachePlugin;
+/**
+ * @group Plugins
+ */
+export declare const getVCAPIPlugin: ({ url, did, }: {
+	url: string;
+	did?: string;
+}) => Promise<VCAPIPlugin>;
+/**
+ * @group Plugins
+ */
+export declare const getVpqrPlugin: (learnCard: LearnCard<any, any, VpqrPluginDependentMethods>) => VpqrPlugin;
 export * from "@wallet/init";
-export { Wallet, Plugin } from "types/wallet";
+export { LearnCard, Plugin } from "types/wallet";
 export * from "types/LearnCard";
 export * from "@wallet/base";
 export * from "@wallet/plugins";