@eudiplo/sdk-core 1.14.0-main.070d9f8

package/dist/index.d.mts

@@ -0,0 +1,651 @@
+import { H as HealthControllerCheckResponse, a as HealthControllerCheckError, S as Session } from './types.gen-CxMpZyVO.mjs';
+export { A as AllowListPolicy, b as ApiKeyConfig, c as AppControllerMainData, d as AppControllerMainResponses, e as AttestationBasedPolicy, f as AuthControllerGetGlobalJwksData, g as AuthControllerGetGlobalJwksResponses, h as AuthControllerGetOAuth2TokenData, i as AuthControllerGetOAuth2TokenErrors, j as AuthControllerGetOAuth2TokenResponse, k as AuthControllerGetOAuth2TokenResponses, l as AuthControllerGetOidcDiscoveryData, m as AuthControllerGetOidcDiscoveryResponses, n as AuthenticationMethodAuth, o as AuthenticationMethodNone, p as AuthenticationMethodPresentation, q as AuthenticationUrlConfig, r as AuthorizationResponse, s as AuthorizeControllerAuthorizeData, t as AuthorizeControllerAuthorizeResponses, u as AuthorizeControllerParData, v as AuthorizeControllerParResponse, w as AuthorizeControllerParResponses, x as AuthorizeControllerTokenData, y as AuthorizeControllerTokenResponse, z as AuthorizeControllerTokenResponses, B as AuthorizeQueries, C as CacheControllerClearAllCachesData, D as CacheControllerClearAllCachesResponse, E as CacheControllerClearAllCachesResponses, F as CacheControllerClearStatusListCacheData, G as CacheControllerClearStatusListCacheResponse, I as CacheControllerClearStatusListCacheResponses, J as CacheControllerClearTrustListCacheData, K as CacheControllerClearTrustListCacheResponse, L as CacheControllerClearTrustListCacheResponses, M as CacheControllerGetStatsData, N as CacheControllerGetStatsResponses, O as CertControllerAddCertificateData, P as CertControllerAddCertificateResponse, Q as CertControllerAddCertificateResponses, R as CertControllerDeleteCertificateData, T as CertControllerDeleteCertificateResponses, U as CertControllerExportConfigData, V as CertControllerExportConfigResponse, W as CertControllerExportConfigResponses, X as CertControllerGetCertificateData, Y as CertControllerGetCertificateResponse, Z as CertControllerGetCertificateResponses, _ as CertControllerGetCertificatesData, $ as CertControllerGetCertificatesResponse, a0 as CertControllerGetCertificatesResponses, a1 as CertControllerUpdateCertificateData, a2 as CertControllerUpdateCertificateResponses, a3 as CertEntity, a4 as CertImportDto, a5 as CertResponseDto, a6 as CertUpdateDto, a7 as CertUsageEntity, a8 as ChainedAsConfig, a9 as ChainedAsControllerAuthorizeData, aa as ChainedAsControllerAuthorizeError, ab as ChainedAsControllerAuthorizeErrors, ac as ChainedAsControllerAuthorizeResponses, ad as ChainedAsControllerCallbackData, ae as ChainedAsControllerCallbackError, af as ChainedAsControllerCallbackErrors, ag as ChainedAsControllerCallbackResponses, ah as ChainedAsControllerGetMetadataData, ai as ChainedAsControllerGetMetadataResponses, aj as ChainedAsControllerJwksData, ak as ChainedAsControllerJwksResponses, al as ChainedAsControllerParData, am as ChainedAsControllerParError, an as ChainedAsControllerParErrors, ao as ChainedAsControllerParResponse, ap as ChainedAsControllerParResponses, aq as ChainedAsControllerTokenData, ar as ChainedAsControllerTokenError, as as ChainedAsControllerTokenErrors, at as ChainedAsControllerTokenResponse, au as ChainedAsControllerTokenResponses, av as ChainedAsErrorResponseDto, aw as ChainedAsParRequestDto, ax as ChainedAsParResponseDto, ay as ChainedAsTokenConfig, az as ChainedAsTokenRequestDto, aA as ChainedAsTokenResponseDto, aB as Claim, aC as ClaimsQuery, aD as ClientControllerCreateClientData, aE as ClientControllerCreateClientResponse, aF as ClientControllerCreateClientResponses, aG as ClientControllerDeleteClientData, aH as ClientControllerDeleteClientResponses, aI as ClientControllerGetClientData, aJ as ClientControllerGetClientResponse, aK as ClientControllerGetClientResponses, aL as ClientControllerGetClientSecretData, aM as ClientControllerGetClientSecretResponse, aN as ClientControllerGetClientSecretResponses, aO as ClientControllerGetClientsData, aP as ClientControllerGetClientsResponse, aQ as ClientControllerGetClientsResponses, aR as ClientControllerRotateClientSecretData, aS as ClientControllerRotateClientSecretResponse, aT as ClientControllerRotateClientSecretResponses, aU as ClientControllerUpdateClientData, aV as ClientControllerUpdateClientResponse, aW as ClientControllerUpdateClientResponses, aX as ClientCredentialsDto, aY as ClientEntity, aZ as ClientOptions, a_ as ClientSecretResponseDto, a$ as CompleteDeferredDto, b0 as CreateAccessCertificateDto, b1 as CreateClientDto, b2 as CreateRegistrarConfigDto, b3 as CreateStatusListDto, b4 as CreateTenantDto, b5 as CredentialConfig, b6 as CredentialConfigControllerDeleteIssuanceConfigurationData, b7 as CredentialConfigControllerDeleteIssuanceConfigurationResponses, b8 as CredentialConfigControllerGetConfigByIdData, b9 as CredentialConfigControllerGetConfigByIdResponse, ba as CredentialConfigControllerGetConfigByIdResponses, bb as CredentialConfigControllerGetConfigsData, bc as CredentialConfigControllerGetConfigsResponse, bd as CredentialConfigControllerGetConfigsResponses, be as CredentialConfigControllerStoreCredentialConfigurationData, bf as CredentialConfigControllerStoreCredentialConfigurationResponse, bg as CredentialConfigControllerStoreCredentialConfigurationResponses, bh as CredentialConfigControllerUpdateCredentialConfigurationData, bi as CredentialConfigControllerUpdateCredentialConfigurationResponse, bj as CredentialConfigControllerUpdateCredentialConfigurationResponses, bk as CredentialConfigCreate, bl as CredentialConfigUpdate, bm as CredentialOfferControllerGetOfferData, bn as CredentialOfferControllerGetOfferResponse, bo as CredentialOfferControllerGetOfferResponses, bp as CredentialQuery, bq as CredentialSetQuery, br as Dcql, bs as DeferredControllerCompleteDeferredData, bt as DeferredControllerCompleteDeferredErrors, bu as DeferredControllerCompleteDeferredResponse, bv as DeferredControllerCompleteDeferredResponses, bw as DeferredControllerFailDeferredData, bx as DeferredControllerFailDeferredErrors, by as DeferredControllerFailDeferredResponse, bz as DeferredControllerFailDeferredResponses, bA as DeferredCredentialRequestDto, bB as DeferredOperationResponse, bC as Display, bD as DisplayImage, bE as DisplayInfo, bF as DisplayLogo, bG as EcPublic, bH as EmbeddedDisclosurePolicy, bI as FailDeferredDto, bJ as FileUploadDto, bK as HealthControllerCheckData, bL as HealthControllerCheckErrors, bM as HealthControllerCheckResponses, bN as IaeActionOpenid4VpPresentation, bO as IaeActionRedirectToWeb, bP as ImportTenantDto, bQ as InteractiveAuthorizationCodeResponseDto, bR as InteractiveAuthorizationControllerCompleteWebAuthData, bS as InteractiveAuthorizationControllerCompleteWebAuthErrors, bT as InteractiveAuthorizationControllerCompleteWebAuthResponses, bU as InteractiveAuthorizationControllerInteractiveAuthorizationData, bV as InteractiveAuthorizationControllerInteractiveAuthorizationError, bW as InteractiveAuthorizationControllerInteractiveAuthorizationErrors, bX as InteractiveAuthorizationControllerInteractiveAuthorizationResponse, bY as InteractiveAuthorizationControllerInteractiveAuthorizationResponses, bZ as InteractiveAuthorizationErrorResponseDto, b_ as InteractiveAuthorizationRequestDto, b$ as IssuanceConfig, c0 as IssuanceConfigControllerGetIssuanceConfigurationsData, c1 as IssuanceConfigControllerGetIssuanceConfigurationsResponse, c2 as IssuanceConfigControllerGetIssuanceConfigurationsResponses, c3 as IssuanceConfigControllerStoreIssuanceConfigurationData, c4 as IssuanceConfigControllerStoreIssuanceConfigurationResponse, c5 as IssuanceConfigControllerStoreIssuanceConfigurationResponses, c6 as IssuanceDto, c7 as IssuerMetadataCredentialConfig, c8 as JwksResponseDto, c9 as Key, ca as KeyControllerAddKeyData, cb as KeyControllerAddKeyResponses, cc as KeyControllerDeleteKeyData, cd as KeyControllerDeleteKeyResponses, ce as KeyControllerGetKeyData, cf as KeyControllerGetKeyResponse, cg as KeyControllerGetKeyResponses, ch as KeyControllerGetKeysData, ci as KeyControllerGetKeysResponse, cj as KeyControllerGetKeysResponses, ck as KeyControllerUpdateKeyData, cl as KeyControllerUpdateKeyResponses, cm as KeyEntity, cn as KeyImportDto, co as NoneTrustPolicy, cp as NotificationRequestDto, cq as OfferRequestDto, cr as OfferResponse, cs as Oid4VciControllerCredentialData, ct as Oid4VciControllerCredentialResponse, cu as Oid4VciControllerCredentialResponses, cv as Oid4VciControllerDeferredCredentialData, cw as Oid4VciControllerDeferredCredentialResponses, cx as Oid4VciControllerNonceData, cy as Oid4VciControllerNonceResponses, cz as Oid4VciControllerNotificationsData, cA as Oid4VciControllerNotificationsResponses, cB as Oid4VciMetadataControllerVctData, cC as Oid4VciMetadataControllerVctResponse, cD as Oid4VciMetadataControllerVctResponses, cE as Oid4VpControllerGetPostRequestWithSessionData, cF as Oid4VpControllerGetPostRequestWithSessionResponse, cG as Oid4VpControllerGetPostRequestWithSessionResponses, cH as Oid4VpControllerGetRequestNoRedirectWithSessionData, cI as Oid4VpControllerGetRequestNoRedirectWithSessionResponse, cJ as Oid4VpControllerGetRequestNoRedirectWithSessionResponses, cK as Oid4VpControllerGetRequestWithSessionData, cL as Oid4VpControllerGetRequestWithSessionResponse, cM as Oid4VpControllerGetRequestWithSessionResponses, cN as Oid4VpControllerGetResponseData, cO as Oid4VpControllerGetResponseResponse, cP as Oid4VpControllerGetResponseResponses, cQ as ParResponseDto, cR as PolicyCredential, cS as PresentationAttachment, cT as PresentationConfig, cU as PresentationConfigCreateDto, cV as PresentationConfigUpdateDto, cW as PresentationDuringIssuanceConfig, cX as PresentationManagementControllerConfigurationData, cY as PresentationManagementControllerConfigurationResponse, cZ as PresentationManagementControllerConfigurationResponses, c_ as PresentationManagementControllerDeleteConfigurationData, c$ as PresentationManagementControllerDeleteConfigurationResponses, d0 as PresentationManagementControllerGetConfigurationData, d1 as PresentationManagementControllerGetConfigurationResponse, d2 as PresentationManagementControllerGetConfigurationResponses, d3 as PresentationManagementControllerStorePresentationConfigData, d4 as PresentationManagementControllerStorePresentationConfigResponse, d5 as PresentationManagementControllerStorePresentationConfigResponses, d6 as PresentationManagementControllerUpdateConfigurationData, d7 as PresentationManagementControllerUpdateConfigurationResponse, d8 as PresentationManagementControllerUpdateConfigurationResponses, d9 as PresentationRequest, da as RegistrarConfigEntity, db as RegistrarControllerCreateAccessCertificateData, dc as RegistrarControllerCreateAccessCertificateErrors, dd as RegistrarControllerCreateAccessCertificateResponse, de as RegistrarControllerCreateAccessCertificateResponses, df as RegistrarControllerCreateConfigData, dg as RegistrarControllerCreateConfigErrors, dh as RegistrarControllerCreateConfigResponse, di as RegistrarControllerCreateConfigResponses, dj as RegistrarControllerDeleteConfigData, dk as RegistrarControllerDeleteConfigResponse, dl as RegistrarControllerDeleteConfigResponses, dm as RegistrarControllerGetConfigData, dn as RegistrarControllerGetConfigErrors, dp as RegistrarControllerGetConfigResponse, dq as RegistrarControllerGetConfigResponses, dr as RegistrarControllerUpdateConfigData, ds as RegistrarControllerUpdateConfigErrors, dt as RegistrarControllerUpdateConfigResponse, du as RegistrarControllerUpdateConfigResponses, dv as RegistrationCertificateRequest, dw as RoleDto, dx as RootOfTrustPolicy, dy as SchemaResponse, dz as SessionConfigControllerGetConfigData, dA as SessionConfigControllerGetConfigResponse, dB as SessionConfigControllerGetConfigResponses, dC as SessionConfigControllerResetConfigData, dD as SessionConfigControllerResetConfigResponses, dE as SessionConfigControllerUpdateConfigData, dF as SessionConfigControllerUpdateConfigResponse, dG as SessionConfigControllerUpdateConfigResponses, dH as SessionControllerDeleteSessionData, dI as SessionControllerDeleteSessionResponses, dJ as SessionControllerGetAllSessionsData, dK as SessionControllerGetAllSessionsResponse, dL as SessionControllerGetAllSessionsResponses, dM as SessionControllerGetSessionData, dN as SessionControllerGetSessionResponse, dO as SessionControllerGetSessionResponses, dP as SessionControllerRevokeAllData, dQ as SessionControllerRevokeAllResponses, dR as SessionEventsControllerSubscribeToSessionEventsData, dS as SessionEventsControllerSubscribeToSessionEventsResponses, dT as SessionStorageConfig, dU as StatusListAggregationDto, dV as StatusListConfig, dW as StatusListConfigControllerGetConfigData, dX as StatusListConfigControllerGetConfigResponse, dY as StatusListConfigControllerGetConfigResponses, dZ as StatusListConfigControllerResetConfigData, d_ as StatusListConfigControllerResetConfigResponse, d$ as StatusListConfigControllerResetConfigResponses, e0 as StatusListConfigControllerUpdateConfigData, e1 as StatusListConfigControllerUpdateConfigResponse, e2 as StatusListConfigControllerUpdateConfigResponses, e3 as StatusListControllerGetListData, e4 as StatusListControllerGetListResponse, e5 as StatusListControllerGetListResponses, e6 as StatusListControllerGetStatusListAggregationData, e7 as StatusListControllerGetStatusListAggregationResponse, e8 as StatusListControllerGetStatusListAggregationResponses, e9 as StatusListImportDto, ea as StatusListManagementControllerCreateListData, eb as StatusListManagementControllerCreateListResponse, ec as StatusListManagementControllerCreateListResponses, ed as StatusListManagementControllerDeleteListData, ee as StatusListManagementControllerDeleteListResponse, ef as StatusListManagementControllerDeleteListResponses, eg as StatusListManagementControllerGetListData, eh as StatusListManagementControllerGetListResponse, ei as StatusListManagementControllerGetListResponses, ej as StatusListManagementControllerGetListsData, ek as StatusListManagementControllerGetListsResponse, el as StatusListManagementControllerGetListsResponses, em as StatusListManagementControllerUpdateListData, en as StatusListManagementControllerUpdateListResponse, eo as StatusListManagementControllerUpdateListResponses, ep as StatusListResponseDto, eq as StatusUpdateDto, er as StorageControllerDownloadData, es as StorageControllerDownloadResponses, et as StorageControllerUploadData, eu as StorageControllerUploadResponse, ev as StorageControllerUploadResponses, ew as TenantControllerDeleteTenantData, ex as TenantControllerDeleteTenantResponses, ey as TenantControllerGetTenantData, ez as TenantControllerGetTenantResponse, eA as TenantControllerGetTenantResponses, eB as TenantControllerGetTenantsData, eC as TenantControllerGetTenantsResponse, eD as TenantControllerGetTenantsResponses, eE as TenantControllerInitTenantData, eF as TenantControllerInitTenantResponse, eG as TenantControllerInitTenantResponses, eH as TenantControllerUpdateTenantData, eI as TenantControllerUpdateTenantResponse, eJ as TenantControllerUpdateTenantResponses, eK as TenantEntity, eL as TokenResponse, eM as TransactionData, eN as TrustList, eO as TrustListControllerCreateTrustListData, eP as TrustListControllerCreateTrustListResponse, eQ as TrustListControllerCreateTrustListResponses, eR as TrustListControllerDeleteTrustListData, eS as TrustListControllerDeleteTrustListResponses, eT as TrustListControllerExportTrustListData, eU as TrustListControllerExportTrustListResponse, eV as TrustListControllerExportTrustListResponses, eW as TrustListControllerGetAllTrustListsData, eX as TrustListControllerGetAllTrustListsResponse, eY as TrustListControllerGetAllTrustListsResponses, eZ as TrustListControllerGetTrustListData, e_ as TrustListControllerGetTrustListResponse, e$ as TrustListControllerGetTrustListResponses, f0 as TrustListControllerGetTrustListVersionData, f1 as TrustListControllerGetTrustListVersionResponse, f2 as TrustListControllerGetTrustListVersionResponses, f3 as TrustListControllerGetTrustListVersionsData, f4 as TrustListControllerGetTrustListVersionsResponse, f5 as TrustListControllerGetTrustListVersionsResponses, f6 as TrustListControllerUpdateTrustListData, f7 as TrustListControllerUpdateTrustListResponse, f8 as TrustListControllerUpdateTrustListResponses, f9 as TrustListCreateDto, fa as TrustListPublicControllerGetTrustListJwtData, fb as TrustListPublicControllerGetTrustListJwtResponse, fc as TrustListPublicControllerGetTrustListJwtResponses, fd as TrustListVersion, fe as TrustedAuthorityQuery, ff as UpdateClientDto, fg as UpdateKeyDto, fh as UpdateRegistrarConfigDto, fi as UpdateSessionConfigDto, fj as UpdateStatusListConfigDto, fk as UpdateStatusListDto, fl as UpdateTenantDto, fm as UpstreamOidcConfig, fn as Vct, fo as VerifierOfferControllerGetOfferData, fp as VerifierOfferControllerGetOfferResponse, fq as VerifierOfferControllerGetOfferResponses, fr as WebHookAuthConfigHeader, fs as WebHookAuthConfigNone, ft as WebhookConfig, fu as WellKnownControllerAuthzMetadata0Data, fv as WellKnownControllerAuthzMetadata0Responses, fw as WellKnownControllerAuthzMetadata1Data, fx as WellKnownControllerAuthzMetadata1Responses, fy as WellKnownControllerGetJwks0Data, fz as WellKnownControllerGetJwks0Response, fA as WellKnownControllerGetJwks0Responses, fB as WellKnownControllerGetJwks1Data, fC as WellKnownControllerGetJwks1Response, fD as WellKnownControllerGetJwks1Responses, fE as WellKnownControllerIssuerMetadata0Data, fF as WellKnownControllerIssuerMetadata0Response, fG as WellKnownControllerIssuerMetadata0Responses, fH as WellKnownControllerIssuerMetadata1Data, fI as WellKnownControllerIssuerMetadata1Response, fJ as WellKnownControllerIssuerMetadata1Responses } from './types.gen-CxMpZyVO.mjs';
+export { client } from './api/client.gen.mjs';
+export { Options, appControllerMain, authControllerGetGlobalJwks, authControllerGetOAuth2Token, authControllerGetOidcDiscovery, authorizeControllerAuthorize, authorizeControllerPar, authorizeControllerToken, cacheControllerClearAllCaches, cacheControllerClearStatusListCache, cacheControllerClearTrustListCache, cacheControllerGetStats, certControllerAddCertificate, certControllerDeleteCertificate, certControllerExportConfig, certControllerGetCertificate, certControllerGetCertificates, certControllerUpdateCertificate, chainedAsControllerAuthorize, chainedAsControllerCallback, chainedAsControllerGetMetadata, chainedAsControllerJwks, chainedAsControllerPar, chainedAsControllerToken, clientControllerCreateClient, clientControllerDeleteClient, clientControllerGetClient, clientControllerGetClientSecret, clientControllerGetClients, clientControllerRotateClientSecret, clientControllerUpdateClient, credentialConfigControllerDeleteIssuanceConfiguration, credentialConfigControllerGetConfigById, credentialConfigControllerGetConfigs, credentialConfigControllerStoreCredentialConfiguration, credentialConfigControllerUpdateCredentialConfiguration, credentialOfferControllerGetOffer, deferredControllerCompleteDeferred, deferredControllerFailDeferred, healthControllerCheck, interactiveAuthorizationControllerCompleteWebAuth, interactiveAuthorizationControllerInteractiveAuthorization, issuanceConfigControllerGetIssuanceConfigurations, issuanceConfigControllerStoreIssuanceConfiguration, keyControllerAddKey, keyControllerDeleteKey, keyControllerGetKey, keyControllerGetKeys, keyControllerUpdateKey, oid4VciControllerCredential, oid4VciControllerDeferredCredential, oid4VciControllerNonce, oid4VciControllerNotifications, oid4VciMetadataControllerVct, oid4VpControllerGetPostRequestWithSession, oid4VpControllerGetRequestNoRedirectWithSession, oid4VpControllerGetRequestWithSession, oid4VpControllerGetResponse, presentationManagementControllerConfiguration, presentationManagementControllerDeleteConfiguration, presentationManagementControllerGetConfiguration, presentationManagementControllerStorePresentationConfig, presentationManagementControllerUpdateConfiguration, registrarControllerCreateAccessCertificate, registrarControllerCreateConfig, registrarControllerDeleteConfig, registrarControllerGetConfig, registrarControllerUpdateConfig, sessionConfigControllerGetConfig, sessionConfigControllerResetConfig, sessionConfigControllerUpdateConfig, sessionControllerDeleteSession, sessionControllerGetAllSessions, sessionControllerGetSession, sessionControllerRevokeAll, sessionEventsControllerSubscribeToSessionEvents, statusListConfigControllerGetConfig, statusListConfigControllerResetConfig, statusListConfigControllerUpdateConfig, statusListControllerGetList, statusListControllerGetStatusListAggregation, statusListManagementControllerCreateList, statusListManagementControllerDeleteList, statusListManagementControllerGetList, statusListManagementControllerGetLists, statusListManagementControllerUpdateList, storageControllerDownload, storageControllerUpload, tenantControllerDeleteTenant, tenantControllerGetTenant, tenantControllerGetTenants, tenantControllerInitTenant, tenantControllerUpdateTenant, trustListControllerCreateTrustList, trustListControllerDeleteTrustList, trustListControllerExportTrustList, trustListControllerGetAllTrustLists, trustListControllerGetTrustList, trustListControllerGetTrustListVersion, trustListControllerGetTrustListVersions, trustListControllerUpdateTrustList, trustListPublicControllerGetTrustListJwt, verifierOfferControllerGetOffer, wellKnownControllerAuthzMetadata0, wellKnownControllerAuthzMetadata1, wellKnownControllerGetJwks0, wellKnownControllerGetJwks1, wellKnownControllerIssuerMetadata0, wellKnownControllerIssuerMetadata1 } from './api/index.mjs';
+import './types.gen-DDunhhsd.mjs';
+
+/**
+ * Digital Credential response from the browser API
+ */
+interface DigitalCredentialResponse {
+    data: {
+        response?: string;
+        error?: string;
+        error_description?: string;
+    };
+}
+/**
+ * Result of a DC API presentation
+ */
+interface DcApiPresentationResult {
+    /** The verified credentials from the presentation */
+    credentials?: Array<Record<string, unknown>>;
+    /** The raw response from the verifier */
+    response: unknown;
+    /** Redirect URI if provided by the verifier */
+    redirectUri?: string;
+}
+/**
+ * Options for DC API presentation
+ */
+interface DcApiPresentationOptions {
+    /** Whether to return the full credential data in the response (default: true) */
+    sendResponse?: boolean;
+}
+/**
+ * Check if the Digital Credentials API is available in the current browser
+ */
+declare function isDcApiAvailable(): boolean;
+/**
+ * Configuration options for the EudiploClient
+ */
+interface EudiploClientConfig {
+    /** Base URL of the EUDIPLO server (e.g., 'https://eudiplo.example.com') */
+    baseUrl: string;
+    /** OAuth2 client ID */
+    clientId: string;
+    /** OAuth2 client secret */
+    clientSecret: string;
+    /** Optional: Auto-refresh token before expiry (default: true) */
+    autoRefresh?: boolean;
+    /** Optional: Custom fetch implementation (useful for Cloudflare Workers) */
+    fetch?: typeof fetch;
+}
+/**
+ * Options for session polling
+ */
+interface SessionPollingOptions {
+    /** Polling interval in milliseconds (default: 1000) */
+    interval?: number;
+    /** Maximum time to wait in milliseconds (default: 300000 = 5 minutes) */
+    timeout?: number;
+    /** Callback on each poll */
+    onUpdate?: (session: Session) => void;
+    /** AbortSignal to cancel polling */
+    signal?: AbortSignal;
+}
+/**
+ * Event payload received from SSE subscription
+ */
+interface SessionStatusEvent {
+    /** Session ID */
+    id: string;
+    /** Current session status */
+    status: 'active' | 'fetched' | 'completed' | 'expired' | 'failed';
+    /** Timestamp of the status update */
+    updatedAt: string;
+}
+/**
+ * Options for SSE session subscription
+ */
+interface SessionSubscriptionOptions {
+    /** Callback invoked when session status changes */
+    onStatusChange?: (event: SessionStatusEvent) => void;
+    /** Callback invoked when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback invoked when connection is established */
+    onOpen?: () => void;
+}
+/**
+ * Subscription handle returned by subscribeToSession.
+ * Use to close the SSE connection.
+ */
+interface SessionSubscription {
+    /** Close the SSE connection */
+    close: () => void;
+}
+/**
+ * Simplified options for creating an issuance offer
+ */
+interface IssuanceOfferOptions {
+    /** Credential configuration IDs to issue */
+    credentialConfigurationIds: string[];
+    /** Claims to include in the credentials (keyed by config ID) */
+    claims?: Record<string, Record<string, unknown>>;
+    /** Response type: 'uri' returns the offer URI, 'dc-api' for Digital Credentials API */
+    responseType?: 'uri' | 'dc-api';
+    /** Transaction code for pre-authorized flow */
+    txCode?: string;
+    /** Flow type (default: 'pre_authorized_code') */
+    flow?: 'authorization_code' | 'pre_authorized_code';
+}
+/**
+ * Simplified options for creating a presentation request
+ */
+interface PresentationRequestOptions {
+    /** ID of the presentation configuration */
+    configId: string;
+    /** Response type: 'uri' returns the request URI, 'dc-api' for Digital Credentials API */
+    responseType?: 'uri' | 'dc-api';
+    /** Optional redirect URI after presentation completes */
+    redirectUri?: string;
+}
+/**
+ * Result of creating an offer or request
+ */
+interface OfferResult {
+    /**
+     * URI for same-device flow.
+     * Use when the wallet is on the same device as the browser.
+     * For presentation requests: After presentation, the wallet will redirect the user back to the verifier.
+     * For issuance offers: The wallet opens and receives the credential.
+     */
+    uri: string;
+    /**
+     * URI for cross-device flow (e.g., QR code scanned by another device).
+     * Use when the wallet is on a different device than the browser.
+     * No redirect happens after presentation - poll the session for status updates.
+     *
+     * Only available for presentation requests. For issuance, use `uri` for both flows.
+     */
+    crossDeviceUri?: string;
+    /** Session ID for polling status updates */
+    sessionId: string;
+}
+/**
+ * Framework-agnostic EUDIPLO client for demos and integrations.
+ *
+ * @example
+ * ```typescript
+ * import { EudiploClient } from '@eudiplo/sdk-core';
+ *
+ * const client = new EudiploClient({
+ *   baseUrl: 'https://eudiplo.example.com',
+ *   clientId: 'my-demo',
+ *   clientSecret: 'secret123'
+ * });
+ *
+ * // Create a presentation request for age verification
+ * const { uri, sessionId } = await client.createPresentationRequest({
+ *   configId: 'age-over-18'
+ * });
+ *
+ * // Display QR code with `uri`, then wait for completion
+ * const session = await client.waitForSession(sessionId);
+ * console.log('Verified:', session.credentials);
+ * ```
+ */
+declare class EudiploClient {
+    private readonly config;
+    private accessToken?;
+    private tokenExpiresAt?;
+    private refreshPromise?;
+    constructor(config: EudiploClientConfig);
+    /**
+     * Authenticate and obtain an access token.
+     * Called automatically by other methods, but can be called explicitly.
+     */
+    authenticate(): Promise<void>;
+    private _doAuthenticate;
+    /**
+     * Ensure we have a valid access token, refreshing if necessary.
+     */
+    private ensureAuthenticated;
+    /**
+     * Create a credential issuance offer.
+     *
+     * @example
+     * ```typescript
+     * const { uri, sessionId } = await client.createIssuanceOffer({
+     *   credentialConfigurationIds: ['PID'],
+     *   claims: {
+     *     PID: { given_name: 'John', family_name: 'Doe' }
+     *   }
+     * });
+     * ```
+     */
+    createIssuanceOffer(options: IssuanceOfferOptions): Promise<OfferResult>;
+    /**
+     * Create a presentation request (for verification).
+     *
+     * Returns two URIs:
+     * - `uri`: For same-device flow (wallet on same device, redirect after completion)
+     * - `crossDeviceUri`: For cross-device flow (QR code, no redirect, poll for status)
+     *
+     * @example Same-device flow (wallet app on user's device)
+     * ```typescript
+     * const { uri, sessionId } = await client.createPresentationRequest({
+     *   configId: 'age-over-18',
+     *   redirectUri: 'https://example.com/callback'
+     * });
+     * // Redirect user to uri - wallet will redirect back after completion
+     * window.location.href = uri;
+     * ```
+     *
+     * @example Cross-device flow (QR code scanned by separate device)
+     * ```typescript
+     * const { crossDeviceUri, sessionId } = await client.createPresentationRequest({
+     *   configId: 'age-over-18'
+     * });
+     * // Display crossDeviceUri as QR code, then poll for completion
+     * const session = await client.waitForSession(sessionId);
+     * ```
+     */
+    createPresentationRequest(options: PresentationRequestOptions): Promise<OfferResult>;
+    /**
+     * Get the current health of the EUDIPLO connector.
+     * The status in the response is `ok`/`error`.
+     * The health of the components is listed in the response under `info`/`error`/`details`.
+     * If the EUDIPLO connector itself is unreachable, no components are listed.
+     */
+    getHealth(): Promise<HealthControllerCheckResponse | HealthControllerCheckError>;
+    /**
+     * Get the current status of a session.
+     */
+    getSession(sessionId: string): Promise<Session>;
+    /**
+     * Wait for a session to complete (polling).
+     *
+     * @example
+     * ```typescript
+     * const session = await client.waitForSession(sessionId, {
+     *   interval: 1000,
+     *   timeout: 60000,
+     *   onUpdate: (s) => console.log('Status:', s.status)
+     * });
+     * ```
+     */
+    waitForSession(sessionId: string, options?: SessionPollingOptions): Promise<Session>;
+    /**
+     * Helper to sleep with abort support
+     */
+    private sleep;
+    /**
+     * Subscribe to real-time session status updates via Server-Sent Events.
+     *
+     * This is more efficient than polling and provides instant updates.
+     * The connection remains open until closed or the session reaches a terminal state.
+     *
+     * @example
+     * ```typescript
+     * const subscription = await client.subscribeToSession(sessionId, {
+     *   onStatusChange: (event) => {
+     *     console.log(`Status: ${event.status}`);
+     *     if (['completed', 'expired', 'failed'].includes(event.status)) {
+     *       subscription.close();
+     *     }
+     *   },
+     *   onError: (error) => console.error('SSE error:', error)
+     * });
+     *
+     * // Later, to close the connection:
+     * subscription.close();
+     * ```
+     */
+    subscribeToSession(sessionId: string, options?: SessionSubscriptionOptions): Promise<SessionSubscription>;
+    /**
+     * Subscribe to session and wait for completion via SSE.
+     *
+     * Returns a Promise that resolves when the session completes,
+     * or rejects if it fails/expires.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const finalStatus = await client.waitForSessionWithSse(sessionId);
+     *   console.log('Session completed:', finalStatus);
+     * } catch (error) {
+     *   console.error('Session failed:', error);
+     * }
+     * ```
+     */
+    waitForSessionWithSse(sessionId: string, options?: Pick<SessionSubscriptionOptions, 'onStatusChange'>): Promise<SessionStatusEvent>;
+    /**
+     * Get the current access token (for advanced usage)
+     */
+    getAccessToken(): string | undefined;
+    /**
+     * Get the configured base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Create a presentation request configured for DC API usage.
+     * Returns a session with the signed request object needed for DC API.
+     *
+     * @example
+     * ```typescript
+     * const session = await client.createDcApiPresentationRequest({
+     *   configId: 'age-over-18'
+     * });
+     *
+     * // Use the requestObject with the DC API
+     * const result = await client.submitDcApiPresentation(session);
+     * ```
+     */
+    createDcApiPresentationRequest(options: Omit<PresentationRequestOptions, 'responseType'>): Promise<Session>;
+    /**
+     * Submit a presentation using the Digital Credentials API.
+     * This method handles the browser DC API call and submits the response to the verifier.
+     *
+     * @example
+     * ```typescript
+     * // Check if DC API is available
+     * if (!isDcApiAvailable()) {
+     *   throw new Error('DC API not supported in this browser');
+     * }
+     *
+     * const session = await client.createDcApiPresentationRequest({
+     *   configId: 'age-over-18'
+     * });
+     *
+     * const result = await client.submitDcApiPresentation(session);
+     * console.log('Verified credentials:', result.credentials);
+     * ```
+     */
+    submitDcApiPresentation(session: Session, options?: DcApiPresentationOptions): Promise<DcApiPresentationResult>;
+    /**
+     * Convenience method to create a presentation request and immediately
+     * submit it using the Digital Credentials API.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.verifyWithDcApi({
+     *   configId: 'age-over-18'
+     * });
+     * console.log('Verified:', result.credentials);
+     * ```
+     */
+    verifyWithDcApi(options: Omit<PresentationRequestOptions, 'responseType'>, dcOptions?: DcApiPresentationOptions): Promise<DcApiPresentationResult>;
+}
+/**
+ * Credentials for EUDIPLO authentication
+ */
+interface EudiploCredentials {
+    baseUrl: string;
+    clientId: string;
+    clientSecret: string;
+}
+/**
+ * Options for the verify function
+ */
+interface VerifyOptions extends EudiploCredentials {
+    /** Presentation configuration ID */
+    configId: string;
+    /** Optional redirect URI */
+    redirectUri?: string;
+    /** Polling options */
+    polling?: SessionPollingOptions;
+}
+/**
+ * Options for the issue function
+ */
+interface IssueOptions extends EudiploCredentials {
+    /** Credential configuration IDs */
+    credentialConfigurationIds: string[];
+    /** Claims per credential config */
+    claims?: Record<string, Record<string, unknown>>;
+    /** Transaction code (optional) */
+    txCode?: string;
+    /** Polling options */
+    polling?: SessionPollingOptions;
+}
+/**
+ * Result of a verification or issuance flow
+ */
+interface FlowResult {
+    /** URI for QR code */
+    uri: string;
+    /** Session ID */
+    sessionId: string;
+    /** Wait for the session to complete */
+    waitForCompletion: (options?: SessionPollingOptions) => Promise<Session>;
+    /** Get current session status */
+    getStatus: () => Promise<Session>;
+}
+/**
+ * Create a presentation request for verification.
+ * Returns a URI for QR code and a function to wait for completion.
+ *
+ * @example
+ * ```typescript
+ * import { verify } from '@eudiplo/sdk-core';
+ *
+ * const { uri, waitForCompletion } = await verify({
+ *   baseUrl: 'https://eudiplo.example.com',
+ *   clientId: 'demo',
+ *   clientSecret: 'secret',
+ *   configId: 'age-over-18'
+ * });
+ *
+ * console.log('Scan this:', uri);
+ * const session = await waitForCompletion();
+ * console.log('Verified!', session.credentials);
+ * ```
+ */
+declare function verify(options: VerifyOptions): Promise<FlowResult>;
+/**
+ * Create a credential issuance offer.
+ * Returns a URI for QR code and a function to wait for completion.
+ *
+ * @example
+ * ```typescript
+ * import { issue } from '@eudiplo/sdk-core';
+ *
+ * const { uri, waitForCompletion } = await issue({
+ *   baseUrl: 'https://eudiplo.example.com',
+ *   clientId: 'demo',
+ *   clientSecret: 'secret',
+ *   credentialConfigurationIds: ['PID'],
+ *   claims: {
+ *     PID: { given_name: 'John', family_name: 'Doe' }
+ *   }
+ * });
+ *
+ * console.log('Scan this:', uri);
+ * const session = await waitForCompletion();
+ * ```
+ */
+declare function issue(options: IssueOptions): Promise<FlowResult>;
+/**
+ * One-liner: Verify and wait for result in a single call.
+ *
+ * @example
+ * ```typescript
+ * import { verifyAndWait } from '@eudiplo/sdk-core';
+ *
+ * const session = await verifyAndWait({
+ *   baseUrl: 'https://eudiplo.example.com',
+ *   clientId: 'demo',
+ *   clientSecret: 'secret',
+ *   configId: 'age-over-18',
+ *   onUri: (uri) => showQRCode(uri),
+ *   onUpdate: (s) => console.log('Status:', s.status)
+ * });
+ * ```
+ */
+declare function verifyAndWait(options: VerifyOptions & {
+    /** Called with the URI when available - use to display QR code */
+    onUri: (uri: string) => void;
+}): Promise<Session>;
+/**
+ * One-liner: Issue credential and wait for completion in a single call.
+ *
+ * @example
+ * ```typescript
+ * import { issueAndWait } from '@eudiplo/sdk-core';
+ *
+ * const session = await issueAndWait({
+ *   baseUrl: 'https://eudiplo.example.com',
+ *   clientId: 'demo',
+ *   clientSecret: 'secret',
+ *   credentialConfigurationIds: ['PID'],
+ *   claims: { PID: { given_name: 'John' } },
+ *   onUri: (uri) => showQRCode(uri)
+ * });
+ * ```
+ */
+declare function issueAndWait(options: IssueOptions & {
+    /** Called with the URI when available - use to display QR code */
+    onUri: (uri: string) => void;
+}): Promise<Session>;
+/**
+ * Options for DC API verification
+ */
+interface DcApiVerifyOptions extends EudiploCredentials {
+    /** Presentation configuration ID */
+    configId: string;
+    /** Optional redirect URI */
+    redirectUri?: string;
+    /** Whether to return full credential data (default: true) */
+    sendResponse?: boolean;
+}
+/**
+ * Verify a credential using the Digital Credentials API (browser-native flow).
+ * This is the simplest way to verify credentials when the DC API is available.
+ *
+ * @example
+ * ```typescript
+ * import { verifyWithDcApi, isDcApiAvailable } from '@eudiplo/sdk-core';
+ *
+ * if (isDcApiAvailable()) {
+ *   const result = await verifyWithDcApi({
+ *     baseUrl: 'https://eudiplo.example.com',
+ *     clientId: 'demo',
+ *     clientSecret: 'secret',
+ *     configId: 'age-over-18'
+ *   });
+ *   console.log('Verified!', result.credentials);
+ * } else {
+ *   // Fall back to QR code flow
+ *   const { uri } = await verify({ ... });
+ * }
+ * ```
+ */
+declare function verifyWithDcApi(options: DcApiVerifyOptions): Promise<DcApiPresentationResult>;
+/**
+ * Create a presentation request for DC API and get the session.
+ * Use this when you need more control over the DC API flow.
+ *
+ * @example
+ * ```typescript
+ * import { createDcApiRequest, submitDcApiPresentation, isDcApiAvailable } from '@eudiplo/sdk-core';
+ *
+ * if (isDcApiAvailable()) {
+ *   const { session, submit } = await createDcApiRequest({
+ *     baseUrl: 'https://eudiplo.example.com',
+ *     clientId: 'demo',
+ *     clientSecret: 'secret',
+ *     configId: 'age-over-18'
+ *   });
+ *
+ *   // Show some UI, then submit when user is ready
+ *   const result = await submit();
+ *   console.log('Verified!', result.credentials);
+ * }
+ * ```
+ */
+declare function createDcApiRequest(options: DcApiVerifyOptions): Promise<{
+    session: Session;
+    submit: (dcOptions?: DcApiPresentationOptions) => Promise<DcApiPresentationResult>;
+}>;
+/**
+ * Data returned from server to browser for DC API flow
+ */
+interface DcApiRequestData {
+    /** The signed JWT request object to pass to the DC API */
+    requestObject: string;
+    /** Session ID for tracking */
+    sessionId: string;
+    /** The response_uri where wallet responses should be submitted */
+    responseUri: string;
+}
+/**
+ * Wallet response data from the DC API to send back to server
+ */
+interface DcApiWalletResponse {
+    /** The encrypted VP token response from the wallet */
+    response?: string;
+    /** Error code if the wallet returned an error */
+    error?: string;
+    /** Error description if available */
+    error_description?: string;
+}
+/**
+ * SERVER-SIDE: Create a DC API request and return the data needed by the browser.
+ * Use this on your server where credentials are stored securely.
+ *
+ * @example
+ * ```typescript
+ * // On your server (e.g., Express/Next.js API route)
+ * import { createDcApiRequestForBrowser } from '@eudiplo/sdk-core';
+ *
+ * app.post('/api/start-verification', async (req, res) => {
+ *   const requestData = await createDcApiRequestForBrowser({
+ *     baseUrl: 'https://eudiplo.example.com',
+ *     clientId: process.env.EUDIPLO_CLIENT_ID,     // Safe on server
+ *     clientSecret: process.env.EUDIPLO_SECRET,   // Safe on server
+ *     configId: 'age-over-18',
+ *   });
+ *
+ *   // Send only the safe data to the browser
+ *   res.json(requestData);
+ * });
+ * ```
+ */
+declare function createDcApiRequestForBrowser(options: DcApiVerifyOptions): Promise<DcApiRequestData>;
+/**
+ * BROWSER-SIDE: Call the Digital Credentials API with a request from your server.
+ * This function runs in the browser and invokes the native DC API.
+ *
+ * @example
+ * ```typescript
+ * // In your browser code
+ * import { callDcApi, isDcApiAvailable } from '@eudiplo/sdk-core';
+ *
+ * // Get request data from your server
+ * const requestData = await fetch('/api/start-verification', { method: 'POST' })
+ *   .then(r => r.json());
+ *
+ * if (isDcApiAvailable()) {
+ *   // This calls the browser's native Digital Credentials API
+ *   const walletResponse = await callDcApi(requestData.requestObject);
+ *
+ *   // Send the wallet response back to your server for verification
+ *   const result = await fetch('/api/complete-verification', {
+ *     method: 'POST',
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify({
+ *       sessionId: requestData.sessionId,
+ *       walletResponse,
+ *     }),
+ *   }).then(r => r.json());
+ * }
+ * ```
+ */
+declare function callDcApi(requestObject: string): Promise<DcApiWalletResponse>;
+/**
+ * SERVER-SIDE: Submit the wallet response to EUDIPLO and get verified credentials.
+ * Use this on your server after receiving the wallet response from the browser.
+ *
+ * @example
+ * ```typescript
+ * // On your server
+ * import { submitDcApiWalletResponse } from '@eudiplo/sdk-core';
+ *
+ * app.post('/api/complete-verification', async (req, res) => {
+ *   const { sessionId, walletResponse } = req.body;
+ *
+ *   // You stored the responseUri when creating the request, or pass it from client
+ *   const result = await submitDcApiWalletResponse({
+ *     responseUri: storedResponseUri,  // or from request
+ *     walletResponse,
+ *     sendResponse: true,  // Get verified claims back
+ *   });
+ *
+ *   // result.credentials contains the verified data
+ *   res.json(result);
+ * });
+ * ```
+ */
+declare function submitDcApiWalletResponse(options: {
+    /** The response_uri from the request (from DcApiRequestData.responseUri) */
+    responseUri: string;
+    /** The wallet response from callDcApi() */
+    walletResponse: DcApiWalletResponse;
+    /** Whether to return full credential data (default: true) */
+    sendResponse?: boolean;
+    /** Custom fetch implementation (optional) */
+    fetch?: typeof fetch;
+}): Promise<DcApiPresentationResult>;
+
+export { type DcApiPresentationOptions, type DcApiPresentationResult, type DcApiRequestData, type DcApiVerifyOptions, type DcApiWalletResponse, type DigitalCredentialResponse, EudiploClient, type EudiploClientConfig, type EudiploCredentials, type FlowResult, HealthControllerCheckError, HealthControllerCheckResponse, type IssuanceOfferOptions, type IssueOptions, type OfferResult, type PresentationRequestOptions, Session, type SessionPollingOptions, type SessionStatusEvent, type SessionSubscription, type SessionSubscriptionOptions, type VerifyOptions, callDcApi, createDcApiRequest, createDcApiRequestForBrowser, isDcApiAvailable, issue, issueAndWait, submitDcApiWalletResponse, verify, verifyAndWait, verifyWithDcApi };