@sphereon/ssi-sdk.siopv2-oid4vp-op-auth 0.33.1-next.3 → 0.33.1-next.73

package/dist/index.d.ts

@@ -1,12 +1,559 @@
+import { TKeyType, IIdentifier, IAgentContext, IDIDManager, IResolver, IPluginMethodMap, IDataStoreORM, IKeyManager, ICredentialIssuer, ICredentialVerifier, TAgent, IAgentPlugin } from '@veramo/core';
+import { PresentationSignCallback, OPBuilder, OP, VerifiedAuthorizationRequest, URI, PresentationDefinitionWithLocation, RPRegistrationMetadataPayload, ResponseMode, SupportedVersion, VerifyJwtCallback, DcqlResponseOpts, VPTokenLocation, VerifiablePresentationTypeFormat } from '@sphereon/did-auth-siop';
+import { CheckLinkedDomain, ResolveOpts } from '@sphereon/did-auth-siop-adapter';
+import { DIDDocument } from '@sphereon/did-uni-client';
+import { SelectResults, VerifiablePresentationResult } from '@sphereon/pex';
+import { ManagedIdentifierOptsOrResult, IIdentifierResolution } from '@sphereon/ssi-sdk-ext.identifier-resolution';
+import { JwsPayload, IJwtService } from '@sphereon/ssi-sdk-ext.jwt-service';
+import { UniqueDigitalCredential, ICredentialStore } from '@sphereon/ssi-sdk.credential-store';
+import { CredentialRole, FindDigitalCredentialArgs, ICredentialLocaleBranding, Party, DidAuthConfig, Identity } from '@sphereon/ssi-sdk.data-store';
+import { IPDManager } from '@sphereon/ssi-sdk.pd-manager';
+import { ISDJwtPlugin } from '@sphereon/ssi-sdk.sd-jwt';
+import { HasherSync, OriginalVerifiableCredential, PresentationSubmission, W3CVerifiablePresentation } from '@sphereon/ssi-types';
+import { VerifyCallback } from '@sphereon/wellknown-dids-client';
+import { EventEmitter } from 'events';
+import { Interpreter, State, StateMachine, BaseActionObject, ServiceMap, ResolveTypegenMeta, TypegenDisabled } from 'xstate';
+import { IContactManager } from '@sphereon/ssi-sdk.contact-manager';
+import { IIssuanceBranding } from '@sphereon/ssi-sdk.issuance-branding';
+import { DcqlQuery } from 'dcql';
+import { ICredentialValidation } from '@sphereon/ssi-sdk.credential-validation';
+import { Format } from '@sphereon/pex-models';
+import { ProofOptions, LinkHandlerAdapter } from '@sphereon/ssi-sdk.core';
+import { JwtIssuer, JwtHeader, SigningAlgo } from '@sphereon/oid4vc-common';
+import { _ExtendedIKey } from '@veramo/utils';
+import { SupportedDidMethodEnum } from '@sphereon/ssi-sdk-ext.did-utils';
+import { IMachineStatePersistence, SerializableState } from '@sphereon/ssi-sdk.xstate-machine-persistence';
+
+declare function createOID4VPPresentationSignCallback({ presentationSignCallback, idOpts, domain, fetchRemoteContexts, challenge, format, context, skipDidResolution, }: {
+    presentationSignCallback?: PresentationSignCallback;
+    idOpts: ManagedIdentifierOptsOrResult;
+    domain?: string;
+    challenge?: string;
+    fetchRemoteContexts?: boolean;
+    skipDidResolution?: boolean;
+    format?: Format;
+    context: IRequiredContext;
+}): Promise<PresentationSignCallback>;
+declare function createOPBuilder({ opOptions, idOpts, context, }: {
+    opOptions: IOPOptions;
+    idOpts?: ManagedIdentifierOptsOrResult;
+    context: IRequiredContext;
+}): Promise<OPBuilder>;
+declare function createJwtCallbackWithIdOpts(idOpts: ManagedIdentifierOptsOrResult, context: IRequiredContext): (jwtIssuer: JwtIssuer, jwt: {
+    header: JwtHeader;
+    payload: JwsPayload;
+}) => Promise<string>;
+declare function createJwtCallbackWithOpOpts(opOpts: IOPOptions, context: IRequiredContext): (jwtIssuer: JwtIssuer, jwt: {
+    header: JwtHeader;
+    payload: JwsPayload;
+}) => Promise<string>;
+declare function createOP({ opOptions, idOpts, context, }: {
+    opOptions: IOPOptions;
+    idOpts?: ManagedIdentifierOptsOrResult;
+    context: IRequiredContext;
+}): Promise<OP>;
+declare function getSigningAlgo(type: TKeyType): SigningAlgo;
+
+declare class OpSession {
+    readonly ts: number;
+    readonly id: string;
+    readonly options: IOPOptions;
+    readonly context: IRequiredContext;
+    private readonly requestJwtOrUri;
+    private verifiedAuthorizationRequest?;
+    private _nonce?;
+    private _state?;
+    private readonly _providedPresentationDefinitions?;
+    private constructor();
+    static init(options: Required<IOpSessionArgs>): Promise<OpSession>;
+    getAuthorizationRequest(): Promise<VerifiedAuthorizationRequest>;
+    getAuthorizationRequestURI(): Promise<URI>;
+    get nonce(): string;
+    get state(): string;
+    clear(): OpSession;
+    getSupportedDIDMethods(didPrefix?: boolean): Promise<string[]>;
+    private getAgentDIDMethodsSupported;
+    private getSubjectSyntaxTypesSupported;
+    private getRPDIDMethodsSupported;
+    getSupportedIdentifiers(opts?: {
+        createInCaseNoDIDFound?: boolean;
+    }): Promise<IIdentifier[]>;
+    getSupportedDIDs(): Promise<string[]>;
+    getRedirectUri(): Promise<string>;
+    hasPresentationDefinitions(): Promise<boolean>;
+    getPresentationDefinitions(): Promise<Array<PresentationDefinitionWithLocation> | undefined>;
+    getOID4VP(args: IOpSessionGetOID4VPArgs): Promise<OID4VP>;
+    private createPresentationVerificationCallback;
+    private createJarmResponseCallback;
+    sendAuthorizationResponse(args: IOpsSendSiopAuthorizationResponseArgs): Promise<Response>;
+    private countVCsInAllVPs;
+}
+
+declare class OID4VP {
+    private readonly session;
+    private readonly allIdentifiers;
+    private readonly hasher?;
+    private constructor();
+    static init(session: OpSession, allIdentifiers: string[], hasher?: HasherSync): Promise<OID4VP>;
+    getPresentationDefinitions(): Promise<PresentationDefinitionWithLocation[] | undefined>;
+    private getPresentationExchange;
+    createVerifiablePresentations(credentialRole: CredentialRole, credentialsWithDefinitions: VerifiableCredentialsWithDefinition[], opts?: {
+        forceNoCredentialsInVP?: boolean;
+        restrictToFormats?: Format;
+        restrictToDIDMethods?: string[];
+        proofOpts?: ProofOptions;
+        idOpts?: ManagedIdentifierOptsOrResult;
+        skipDidResolution?: boolean;
+        holderDID?: string;
+        subjectIsHolder?: boolean;
+        hasher?: HasherSync;
+        applyFilter?: boolean;
+    }): Promise<VerifiablePresentationWithDefinition[]>;
+    createVerifiablePresentation(credentialRole: CredentialRole, selectedVerifiableCredentials: VerifiableCredentialsWithDefinition, opts?: {
+        forceNoCredentialsInVP?: boolean;
+        restrictToFormats?: Format;
+        restrictToDIDMethods?: string[];
+        proofOpts?: ProofOptions;
+        idOpts?: ManagedIdentifierOptsOrResult;
+        skipDidResolution?: boolean;
+        holder?: string;
+        subjectIsHolder?: boolean;
+        applyFilter?: boolean;
+        hasher?: HasherSync;
+    }): Promise<VerifiablePresentationWithDefinition>;
+    filterCredentialsAgainstAllDefinitions(credentialRole: CredentialRole, opts?: {
+        filterOpts?: {
+            verifiableCredentials?: UniqueDigitalCredential[];
+            filter?: FindDigitalCredentialArgs;
+        };
+        holderDIDs?: string[];
+        restrictToFormats?: Format;
+        restrictToDIDMethods?: string[];
+    }): Promise<VerifiableCredentialsWithDefinition[]>;
+    filterCredentials(credentialRole: CredentialRole, presentationDefinition: PresentationDefinitionWithLocation, opts?: {
+        filterOpts?: {
+            verifiableCredentials?: (UniqueDigitalCredential | OriginalVerifiableCredential)[];
+            filter?: FindDigitalCredentialArgs;
+        };
+        holderDIDs?: string[];
+        restrictToFormats?: Format;
+        restrictToDIDMethods?: string[];
+    }): Promise<VerifiableCredentialsWithDefinition>;
+    filterCredentialsWithSelectionStatus(credentialRole: CredentialRole, presentationDefinition: PresentationDefinitionWithLocation, opts?: {
+        filterOpts?: {
+            verifiableCredentials?: OriginalVerifiableCredential[];
+            filter?: FindDigitalCredentialArgs;
+        };
+        holderDIDs?: string[];
+        restrictToFormats?: Format;
+        restrictToDIDMethods?: string[];
+    }): Promise<SelectResults>;
+    private getCredentials;
+}
+
+type ErrorDetails = {
+    title: string;
+    message: string;
+    detailsTitle?: string;
+    detailsMessage?: string;
+    stack?: string;
+};
+
+type DidAuthSiopOpAuthenticatorOptions = {
+    presentationSignCallback?: PresentationSignCallback;
+    customApprovals?: Record<string, (verifiedAuthorizationRequest: VerifiedAuthorizationRequest, sessionId: string) => Promise<void>>;
+    onContactIdentityCreated?: (args: OnContactIdentityCreatedArgs) => Promise<void>;
+    onIdentifierCreated?: (args: OnIdentifierCreatedArgs) => Promise<void>;
+    hasher?: HasherSync;
+};
+type GetMachineArgs = {
+    url: string | URL;
+    idOpts?: ManagedIdentifierOptsOrResult;
+    stateNavigationListener?: (siopv2Machine: Siopv2MachineInterpreter, state: Siopv2MachineState, navigation?: any) => Promise<void>;
+};
+type CreateConfigArgs = {
+    url: string;
+};
+type CreateConfigResult = Omit<DidAuthConfig, 'stateId' | 'idOpts'>;
+type GetSiopRequestArgs = {
+    didAuthConfig?: Omit<DidAuthConfig, 'identifier'>;
+    url: string;
+};
+type RetrieveContactArgs = Pick<Siopv2MachineContext, 'url' | 'authorizationRequestData'>;
+type AddIdentityArgs = Pick<Siopv2MachineContext, 'contact' | 'authorizationRequestData'>;
+type SendResponseArgs = {
+    didAuthConfig?: Omit<DidAuthConfig, 'identifier'>;
+    authorizationRequestData?: Siopv2AuthorizationRequestData;
+    selectedCredentials: Array<UniqueDigitalCredential>;
+    idOpts?: ManagedIdentifierOptsOrResult;
+    isFirstParty?: boolean;
+};
+type GetSelectableCredentialsArgs = Pick<Siopv2MachineContext, 'authorizationRequestData'>;
+declare enum Siopv2HolderEvent {
+    CONTACT_IDENTITY_CREATED = "contact_identity_created",
+    IDENTIFIER_CREATED = "identifier_created"
+}
+declare enum SupportedLanguage {
+    ENGLISH = "en",
+    DUTCH = "nl"
+}
+type Siopv2AuthorizationResponseData = {
+    body?: string | Record<string, any>;
+    url?: string;
+    queryParams?: Record<string, any>;
+};
+type Siopv2AuthorizationRequestData = {
+    correlationId: string;
+    registrationMetadataPayload: RPRegistrationMetadataPayload;
+    issuer?: string;
+    name?: string;
+    uri?: URL;
+    clientId?: string;
+    presentationDefinitions?: PresentationDefinitionWithLocation[];
+    dcqlQuery?: DcqlQuery;
+};
+type SelectableCredentialsMap = Map<string, Array<SelectableCredential>>;
+type SelectableCredential = {
+    credential: UniqueDigitalCredential;
+    credentialBranding: Array<ICredentialLocaleBranding>;
+    issuerParty?: Party;
+    subjectParty?: Party;
+};
+type OnContactIdentityCreatedArgs = {
+    contactId: string;
+    identity: Identity;
+};
+type OnIdentifierCreatedArgs = {
+    identifier: IIdentifier;
+};
+type RequiredContext = IAgentContext<IContactManager & IDidAuthSiopOpAuthenticator & IDIDManager & IResolver & IIdentifierResolution & ICredentialStore & IIssuanceBranding>;
+
+type Siopv2MachineContext = {
+    url: string;
+    idOpts?: ManagedIdentifierOptsOrResult;
+    didAuthConfig?: Omit<DidAuthConfig, 'identifier'>;
+    authorizationRequestData?: Siopv2AuthorizationRequestData;
+    authorizationResponseData?: Siopv2AuthorizationResponseData;
+    verifiedAuthorizationRequest?: VerifiedAuthorizationRequest;
+    contact?: Party;
+    hasContactConsent: boolean;
+    contactAlias: string;
+    selectableCredentialsMap?: SelectableCredentialsMap;
+    selectedCredentials: Array<UniqueDigitalCredential>;
+    isFirstParty?: boolean;
+    error?: ErrorDetails;
+};
+declare enum Siopv2MachineStates {
+    createConfig = "createConfig",
+    getSiopRequest = "getSiopRequest",
+    getSelectableCredentials = "getSelectableCredentials",
+    retrieveContact = "retrieveContact",
+    transitionFromSetup = "transitionFromSetup",
+    addContact = "addContact",
+    addContactIdentity = "addContactIdentity",
+    selectCredentials = "selectCredentials",
+    sendResponse = "sendResponse",
+    handleError = "handleError",
+    aborted = "aborted",
+    declined = "declined",
+    error = "error",
+    done = "done"
+}
+declare enum Siopv2MachineAddContactStates {
+    idle = "idle",
+    executing = "executing",
+    next = "next"
+}
+type Siopv2MachineInterpreter = Interpreter<Siopv2MachineContext, any, Siopv2MachineEventTypes, {
+    value: any;
+    context: Siopv2MachineContext;
+}, any>;
+type Siopv2MachineState = State<Siopv2MachineContext, Siopv2MachineEventTypes, any, {
+    value: any;
+    context: Siopv2MachineContext;
+}, any>;
+type Siopv2StateMachine = StateMachine<Siopv2MachineContext, any, Siopv2MachineEventTypes, {
+    value: any;
+    context: Siopv2MachineContext;
+}, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, Siopv2MachineEventTypes, BaseActionObject, ServiceMap>>;
+type CreateSiopv2MachineOpts = {
+    url: string | URL;
+    idOpts?: ManagedIdentifierOptsOrResult;
+    machineId?: string;
+};
+type Siopv2MachineInstanceOpts = {
+    services?: any;
+    guards?: any;
+    subscription?: () => void;
+    requireCustomNavigationHook?: boolean;
+    stateNavigationListener?: (siopv2Machine: Siopv2MachineInterpreter, state: Siopv2MachineState, navigation?: any) => Promise<void>;
+} & CreateSiopv2MachineOpts;
+declare enum Siopv2MachineEvents {
+    NEXT = "NEXT",
+    PREVIOUS = "PREVIOUS",
+    DECLINE = "DECLINE",
+    SET_CONTACT_ALIAS = "SET_CONTACT_ALIAS",
+    SET_CONTACT_CONSENT = "SET_CONTACT_CONSENT",
+    CREATE_CONTACT = "CREATE_CONTACT",
+    SET_SELECTED_CREDENTIALS = "SET_SELECTED_CREDENTIALS"
+}
+declare enum Siopv2MachineGuards {
+    hasNoContactGuard = "Siopv2HasNoContactGuard",
+    createContactGuard = "Siopv2CreateContactGuard",
+    hasContactGuard = "Siopv2HasContactGuard",
+    hasAuthorizationRequestGuard = "Siopv2HasAuthorizationRequestGuard",
+    hasSelectableCredentialsAndContactGuard = "Siopv2HasSelectableCredentialsAndContactGuard",
+    hasSelectedRequiredCredentialsGuard = "Siopv2HasSelectedRequiredCredentialsGuard",
+    siopOnlyGuard = "Siopv2IsSiopOnlyGuard",
+    siopWithOID4VPGuard = "Siopv2IsSiopWithOID4VPGuard"
+}
+declare enum Siopv2MachineServices {
+    getSiopRequest = "getSiopRequest",
+    getSelectableCredentials = "getSelectableCredentials",
+    retrieveContact = "retrieveContact",
+    addContactIdentity = "addContactIdentity",
+    sendResponse = "sendResponse",
+    createConfig = "createConfig"
+}
+type Siopv2MachineEventTypes = NextEvent | PreviousEvent | DeclineEvent | CreateContactEvent | ContactConsentEvent | ContactAliasEvent | SelectCredentialsEvent;
+type NextEvent = {
+    type: Siopv2MachineEvents.NEXT;
+};
+type PreviousEvent = {
+    type: Siopv2MachineEvents.PREVIOUS;
+};
+type DeclineEvent = {
+    type: Siopv2MachineEvents.DECLINE;
+};
+type ContactConsentEvent = {
+    type: Siopv2MachineEvents.SET_CONTACT_CONSENT;
+    data: boolean;
+};
+type ContactAliasEvent = {
+    type: Siopv2MachineEvents.SET_CONTACT_ALIAS;
+    data: string;
+};
+type CreateContactEvent = {
+    type: Siopv2MachineEvents.CREATE_CONTACT;
+    data: Party;
+};
+type SelectCredentialsEvent = {
+    type: Siopv2MachineEvents.SET_SELECTED_CREDENTIALS;
+    data: Array<UniqueDigitalCredential>;
+};
+type Siopv2Machine$1 = {
+    interpreter: Siopv2MachineInterpreter;
+};
+
+declare const LOGGER_NAMESPACE = "sphereon:siopv2-oid4vp:op-auth";
+interface IDidAuthSiopOpAuthenticator extends IPluginMethodMap {
+    siopGetOPSession(args: IGetSiopSessionArgs, context: IRequiredContext): Promise<OpSession>;
+    siopRegisterOPSession(args: Omit<IOpSessionArgs, 'context'>, context: IRequiredContext): Promise<OpSession>;
+    siopRemoveOPSession(args: IRemoveSiopSessionArgs, context: IRequiredContext): Promise<boolean>;
+    siopRegisterOPCustomApproval(args: IRegisterCustomApprovalForSiopArgs, context: IRequiredContext): Promise<void>;
+    siopRemoveOPCustomApproval(args: IRemoveCustomApprovalForSiopArgs, context: IRequiredContext): Promise<boolean>;
+    siopGetMachineInterpreter(args: GetMachineArgs, context: RequiredContext): Promise<Siopv2Machine$1>;
+    siopCreateConfig(args: CreateConfigArgs): Promise<CreateConfigResult>;
+    siopGetSiopRequest(args: GetSiopRequestArgs, context: RequiredContext): Promise<Siopv2AuthorizationRequestData>;
+    siopRetrieveContact(args: RetrieveContactArgs, context: RequiredContext): Promise<Party | undefined>;
+    siopAddIdentity(args: AddIdentityArgs, context: RequiredContext): Promise<void>;
+    siopSendResponse(args: SendResponseArgs, context: RequiredContext): Promise<Siopv2AuthorizationResponseData>;
+    siopGetSelectableCredentials(args: GetSelectableCredentialsArgs, context: RequiredContext): Promise<SelectableCredentialsMap>;
+}
+interface IOpSessionArgs {
+    sessionId?: string;
+    requestJwtOrUri: string | URI;
+    providedPresentationDefinitions?: Array<PresentationDefinitionWithLocation>;
+    identifierOptions?: ManagedIdentifierOptsOrResult;
+    context: IRequiredContext;
+    op?: IOPOptions;
+}
+interface IAuthRequestDetails {
+    rpDIDDocument?: DIDDocument;
+    id: string;
+    verifiablePresentationMatches: IPresentationWithDefinition[];
+    alsoKnownAs?: string[];
+}
+interface IPresentationWithDefinition {
+    location: VPTokenLocation;
+    definition: PresentationDefinitionWithLocation;
+    format: VerifiablePresentationTypeFormat;
+    presentation: W3CVerifiablePresentation;
+}
+interface IGetSiopSessionArgs {
+    sessionId: string;
+}
+interface IRemoveSiopSessionArgs {
+    sessionId: string;
+}
+interface IRegisterCustomApprovalForSiopArgs {
+    key: string;
+    customApproval: (verifiedAuthorizationRequest: VerifiedAuthorizationRequest, sessionId: string) => Promise<void>;
+}
+interface IRemoveCustomApprovalForSiopArgs {
+    key: string;
+}
+interface IOpsSendSiopAuthorizationResponseArgs {
+    responseSignerOpts: ManagedIdentifierOptsOrResult;
+    presentationSubmission?: PresentationSubmission;
+    verifiablePresentations?: W3CVerifiablePresentation[];
+    dcqlResponse?: DcqlResponseOpts;
+    hasher?: HasherSync;
+    isFirstParty?: boolean;
+}
+declare enum events {
+    DID_SIOP_AUTHENTICATED = "didSiopAuthenticated"
+}
+type IRequiredContext = IAgentContext<IDataStoreORM & IResolver & IDIDManager & IKeyManager & IIdentifierResolution & ICredentialIssuer & ICredentialValidation & ICredentialVerifier & ICredentialStore & IPDManager & ISDJwtPlugin & IJwtService>;
+interface IOPOptions {
+    responseMode?: ResponseMode;
+    supportedVersions?: SupportedVersion[];
+    expiresIn?: number;
+    checkLinkedDomains?: CheckLinkedDomain;
+    skipDidResolution?: boolean;
+    eventEmitter?: EventEmitter;
+    supportedDIDMethods?: string[];
+    verifyJwtCallback?: VerifyJwtCallback;
+    wellknownDIDVerifyCallback?: VerifyCallback;
+    presentationSignCallback?: PresentationSignCallback;
+    resolveOpts?: ResolveOpts;
+    hasher?: HasherSync;
+}
+interface VerifiableCredentialsWithDefinition {
+    definition: PresentationDefinitionWithLocation;
+    credentials: (UniqueDigitalCredential | OriginalVerifiableCredential)[];
+}
+interface VerifiablePresentationWithDefinition extends VerifiablePresentationResult {
+    definition: PresentationDefinitionWithLocation;
+    verifiableCredentials: OriginalVerifiableCredential[];
+    idOpts: ManagedIdentifierOptsOrResult;
+}
+interface IOpSessionGetOID4VPArgs {
+    allIdentifiers?: string[];
+    hasher?: HasherSync;
+}
+interface IOID4VPArgs {
+    session: OpSession;
+    allIdentifiers?: string[];
+    hasher?: HasherSync;
+}
+interface IGetPresentationExchangeArgs {
+    verifiableCredentials: OriginalVerifiableCredential[];
+    allIdentifiers?: string[];
+    hasher?: HasherSync;
+}
+type Json = string | number | boolean | null | {
+    [key: string]: Json;
+} | Json[];
+declare const DEFAULT_JWT_PROOF_TYPE = "JwtProof2020";
+
+declare const DID_PREFIX = "did";
+type CreateOrGetIdentifierOpts = {
+    method: SupportedDidMethodEnum;
+    createOpts?: CreateIdentifierCreateOpts;
+};
+type CreateIdentifierCreateOpts = {
+    kms?: string;
+    alias?: string;
+    options?: IdentifierProviderOpts;
+};
+type IdentifierProviderOpts = {
+    type?: TKeyType;
+    use?: string;
+    [x: string]: any;
+};
+type KeyOpts = {
+    didMethod: SupportedDidMethodEnum;
+    keyType: TKeyType;
+    codecName?: string;
+    kid?: string;
+    identifier: IIdentifier;
+};
+type GetIdentifierArgs = {
+    keyOpts: KeyOpts;
+    context: RequiredContext;
+};
+type IdentifierWithKey = {
+    identifier: IIdentifier;
+    key: _ExtendedIKey;
+    kid: string;
+};
+type GetAuthenticationKeyArgs = {
+    identifier: IIdentifier;
+    context: RequiredContext;
+};
+type CreateIdentifierArgs = {
+    context: RequiredContext;
+    opts?: CreateIdentifierOpts;
+};
+type CreateIdentifierOpts = {
+    method: SupportedDidMethodEnum;
+    createOpts?: CreateIdentifierCreateOpts;
+};
+type DidAgents = TAgent<IResolver & IDIDManager>;
+type SuitableCredentialAgents = TAgent<IContactManager & ICredentialStore & IIssuanceBranding>;
+
+declare const didAuthSiopOpAuthenticatorMethods: Array<string>;
+declare class DidAuthSiopOpAuthenticator implements IAgentPlugin {
+    readonly schema: any;
+    readonly methods: IDidAuthSiopOpAuthenticator;
+    private readonly sessions;
+    private readonly customApprovals;
+    private readonly presentationSignCallback?;
+    private readonly onContactIdentityCreated?;
+    private readonly onIdentifierCreated?;
+    private readonly eventEmitter?;
+    private readonly hasher?;
+    constructor(options?: DidAuthSiopOpAuthenticatorOptions);
+    onEvent(event: any, context: RequiredContext): Promise<void>;
+    private siopGetOPSession;
+    private siopRegisterOPSession;
+    private siopRemoveOPSession;
+    private siopRegisterOPCustomApproval;
+    private siopRemoveOPCustomApproval;
+    private siopGetMachineInterpreter;
+    private siopCreateConfig;
+    private siopGetSiopRequest;
+    private determineCorrelationId;
+    private siopRetrieveContact;
+    private siopAddContactIdentity;
+    private siopSendResponse;
+    private hasMDocCredentials;
+    private isMDocCredential;
+    private hasSdJwtCredentials;
+    private isSdJwtCredential;
+    private retrieveEncodedCredential;
+    private siopGetSelectableCredentials;
+}
+
+declare class Siopv2Machine {
+    static newInstance(opts: Siopv2MachineInstanceOpts): {
+        interpreter: Siopv2MachineInterpreter;
+    };
+}
+
+declare const OID4VPCallbackStateListener: (callbacks?: Map<Siopv2MachineStates, (machine: Siopv2MachineInterpreter, state: Siopv2MachineState, opts?: any) => Promise<void>>) => (oid4vciMachine: Siopv2MachineInterpreter, state: Siopv2MachineState) => Promise<void>;
+
+declare class Siopv2OID4VPLinkHandler extends LinkHandlerAdapter {
+    private readonly context;
+    private readonly stateNavigationListener;
+    private readonly noStateMachinePersistence;
+    private readonly idOpts?;
+    constructor(args: Pick<GetMachineArgs, 'stateNavigationListener'> & {
+        protocols?: Array<string | RegExp>;
+        context: IAgentContext<IDidAuthSiopOpAuthenticator & IMachineStatePersistence>;
+        noStateMachinePersistence?: boolean;
+        idOpts?: ManagedIdentifierOptsOrResult;
+    });
+    handle(url: string | URL, opts?: {
+        machineState?: SerializableState;
+        idOpts?: ManagedIdentifierOptsOrResult;
+    }): Promise<void>;
+}
+
 /**
  * @public
  */
 declare const schema: any;
-export { schema };
-export { DidAuthSiopOpAuthenticator, didAuthSiopOpAuthenticatorMethods } from './agent/DidAuthSiopOpAuthenticator';
-export { Siopv2Machine } from './machine/Siopv2Machine';
-export * from './machine/CallbackStateListener';
-export * from './session';
-export * from './types';
-export * from './link-handler';
-//# sourceMappingURL=index.d.ts.map
+
+export { type AddIdentityArgs, type ContactAliasEvent, type ContactConsentEvent, type CreateConfigArgs, type CreateConfigResult, type CreateContactEvent, type CreateIdentifierArgs, type CreateIdentifierCreateOpts, type CreateIdentifierOpts, type CreateOrGetIdentifierOpts, type CreateSiopv2MachineOpts, DEFAULT_JWT_PROOF_TYPE, DID_PREFIX, type DeclineEvent, type DidAgents, DidAuthSiopOpAuthenticator, type DidAuthSiopOpAuthenticatorOptions, type ErrorDetails, type GetAuthenticationKeyArgs, type GetIdentifierArgs, type GetMachineArgs, type GetSelectableCredentialsArgs, type GetSiopRequestArgs, type IAuthRequestDetails, type IDidAuthSiopOpAuthenticator, type IGetPresentationExchangeArgs, type IGetSiopSessionArgs, type IOID4VPArgs, type IOPOptions, type IOpSessionArgs, type IOpSessionGetOID4VPArgs, type IOpsSendSiopAuthorizationResponseArgs, type IPresentationWithDefinition, type IRegisterCustomApprovalForSiopArgs, type IRemoveCustomApprovalForSiopArgs, type IRemoveSiopSessionArgs, type IRequiredContext, type IdentifierProviderOpts, type IdentifierWithKey, type Json, type KeyOpts, LOGGER_NAMESPACE, type NextEvent, OID4VP, OID4VPCallbackStateListener, type OnContactIdentityCreatedArgs, type OnIdentifierCreatedArgs, OpSession, type PreviousEvent, type RequiredContext, type RetrieveContactArgs, type SelectCredentialsEvent, type SelectableCredential, type SelectableCredentialsMap, type SendResponseArgs, type Siopv2AuthorizationRequestData, type Siopv2AuthorizationResponseData, Siopv2HolderEvent, Siopv2Machine, Siopv2MachineAddContactStates, type Siopv2MachineContext, type Siopv2MachineEventTypes, Siopv2MachineEvents, Siopv2MachineGuards, type Siopv2MachineInstanceOpts, type Siopv2MachineInterpreter, Siopv2MachineServices, type Siopv2MachineState, Siopv2MachineStates, Siopv2OID4VPLinkHandler, type Siopv2StateMachine, type SuitableCredentialAgents, SupportedLanguage, type VerifiableCredentialsWithDefinition, type VerifiablePresentationWithDefinition, createJwtCallbackWithIdOpts, createJwtCallbackWithOpOpts, createOID4VPPresentationSignCallback, createOP, createOPBuilder, didAuthSiopOpAuthenticatorMethods, events, getSigningAlgo, schema };