@softactivate/adk 1.1.0

package/dist/types/artifacts/file_artifact_service.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from './base_artifact_service.js';
+/**
+ * Service for managing artifacts stored on the local filesystem.
+ *
+ * Stores filesystem-backed artifacts beneath a configurable root directory.
+ *
+ * Storage layout matches the cloud and in-memory services:
+ * root/
+ * └── users/
+ *     └── {userId}/
+ *         ├── sessions/
+ *         │   └── {sessionId}/
+ *         │       └── artifacts/
+ *         │           └── {artifactPath}/  // derived from filename
+ *         │               └── versions/
+ *         │                   └── {version}/
+ *         │                       ├── {originalFilename}
+ *         │                       └── metadata.json
+ *         └── artifacts/
+ *             └── {artifactPath}/...
+ *
+ * Artifact paths are derived from the provided filenames: separators create
+ * nested directories, and path traversal is rejected to keep the layout
+ * portable across filesystems. `{artifactPath}` therefore mirrors the
+ * sanitized, scope-relative path derived from each filename.
+ */
+export declare class FileArtifactService implements BaseArtifactService {
+    private readonly rootDir;
+    constructor(rootDirOrUri: string);
+    saveArtifact({ userId, sessionId, filename, artifact, customMetadata, }: SaveArtifactRequest): Promise<number>;
+    loadArtifact({ userId, sessionId, filename, version, }: LoadArtifactRequest): Promise<Part | undefined>;
+    listArtifactKeys({ userId, sessionId, }: ListArtifactKeysRequest): Promise<string[]>;
+    deleteArtifact({ userId, sessionId, filename, }: DeleteArtifactRequest): Promise<void>;
+    listVersions({ userId, sessionId, filename, }: ListVersionsRequest): Promise<number[]>;
+    listArtifactVersions({ userId, sessionId, filename, }: ListVersionsRequest): Promise<ArtifactVersion[]>;
+    getArtifactVersion({ userId, sessionId, filename, version, }: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
+}
+export declare function assertSafeSegment(value: string, label: string): void;
+export declare function assertInsideRoot(resolvedPath: string, rootDir: string, label: string): void;
+export declare function getUserRoot(rootDir: string, userId: string): string;
+export declare function getSessionArtifactsDir(baseRoot: string, sessionId: string): string;

package/dist/types/artifacts/gcs_artifact_service.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from './base_artifact_service.js';
+export declare class GcsArtifactService implements BaseArtifactService {
+    private readonly bucket;
+    constructor(bucket: string);
+    saveArtifact(request: SaveArtifactRequest): Promise<number>;
+    loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
+    listArtifactKeys(request: ListArtifactKeysRequest): Promise<string[]>;
+    deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
+    listVersions(request: ListVersionsRequest): Promise<number[]>;
+    listArtifactVersions(request: ListVersionsRequest): Promise<ArtifactVersion[]>;
+    getArtifactVersion(request: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
+}

package/dist/types/artifacts/in_memory_artifact_service.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from './base_artifact_service.js';
+export declare function isInMemoryConnectionString(uri: string): boolean;
+/**
+ * An in-memory implementation of the ArtifactService.
+ */
+export declare class InMemoryArtifactService implements BaseArtifactService {
+    private readonly artifacts;
+    saveArtifact({ appName, userId, sessionId, filename, artifact, customMetadata, }: SaveArtifactRequest): Promise<number>;
+    loadArtifact({ appName, userId, sessionId, filename, version, }: LoadArtifactRequest): Promise<Part | undefined>;
+    listArtifactKeys({ appName, userId, sessionId, }: ListArtifactKeysRequest): Promise<string[]>;
+    deleteArtifact({ appName, userId, sessionId, filename, }: DeleteArtifactRequest): Promise<void>;
+    listVersions({ appName, userId, sessionId, filename, }: ListVersionsRequest): Promise<number[]>;
+    listArtifactVersions({ appName, userId, sessionId, filename, }: ListVersionsRequest): Promise<ArtifactVersion[]>;
+    getArtifactVersion({ appName, userId, sessionId, filename, version, }: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
+}

package/dist/types/artifacts/registry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseArtifactService } from './base_artifact_service.js';
+export declare function getArtifactServiceFromUri(uri: string): BaseArtifactService;

package/dist/types/auth/auth_credential.d.ts

@@ -0,0 +1,244 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents the secret token value for HTTP authentication, like user name,
+ * password, oauth token, etc.
+ */
+export interface HttpCredentials {
+    username?: string;
+    password?: string;
+    token?: string;
+}
+/**
+ * The credentials and metadata for HTTP authentication.
+ */
+export interface HttpAuth {
+    /**
+     * The name of the HTTP Authorization scheme to be used in the Authorization
+     * header as defined in RFC7235. The values used SHOULD be registered in the
+     * IANA Authentication Scheme registry.
+     * Examples: 'basic', 'bearer'
+     */
+    scheme: string;
+    credentials: HttpCredentials;
+    /**
+     * Additional HTTP headers to include in the request.
+     */
+    additionalHeaders?: Record<string, string>;
+}
+/**
+ * Represents credential value and its metadata for a OAuth2 credential.
+ */
+export interface OAuth2Auth {
+    clientId?: string;
+    clientSecret?: string;
+    /**
+     * tool or adk can generate the authUri with the state info thus client can
+     * verify the state
+     */
+    authUri?: string;
+    nonce?: string;
+    state?: string;
+    codeVerifier?: string;
+    /**
+     * tool or adk can decide the redirect_uri if they don't want client to decide
+     */
+    redirectUri?: string;
+    authResponseUri?: string;
+    authCode?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    idToken?: string;
+    expiresAt?: number;
+    expiresIn?: number;
+    audience?: string;
+    tokenEndpointAuthMethod?: string;
+}
+/**
+ * Represents Google Service Account configuration.
+ * @example
+ * config = {
+ *   type: "service_account",
+ *   projectId: "your_project_id",
+ *   privateKeyId: "your_private_key_id",
+ *   privateKey: "-----BEGIN PRIVATE KEY-----...",
+ *   clientEmail: "...@....iam.gserviceaccount.com",
+ *   clientId: "your_client_id",
+ *   authUri: "https://accounts.google.com/o/oauth2/auth",
+ *   tokenUri: "https://oauth2.googleapis.com/token",
+ *   authProviderX509CertUrl: "https://www.googleapis.com/oauth2/v1/certs",
+ *   clientX509CertUrl: "https://www.googleapis.com/robot/v1/metadata/x509/...",
+ *   universeDomain: "googleapis.com",
+ * }
+ */
+export interface ServiceAccountCredential {
+    /**
+     * The type should be 'service_account'.
+     */
+    type: 'service_account';
+    /**
+     * The project ID of the Google Cloud project.
+     */
+    projectId: string;
+    /**
+     * The ID of the private key.
+     */
+    privateKeyId: string;
+    /**
+     * The private key value.
+     */
+    privateKey: string;
+    /**
+     * The client email.
+     */
+    clientEmail: string;
+    /**
+     * The client ID.
+     */
+    clientId: string;
+    /**
+     * The authorization URI.
+     */
+    authUri: string;
+    /**
+     * The token URI.
+     */
+    tokenUri: string;
+    /**
+     * URL for auth provider's X.509 cert.
+     */
+    authProviderX509CertUrl: string;
+    /**
+     * URL for the client's X.509 cert.
+     */
+    clientX509CertUrl: string;
+    /**
+     * The universe domain.
+     */
+    universeDomain: string;
+}
+/**
+ * Represents Google Service Account configuration.
+ */
+export interface ServiceAccount {
+    serviceAccountCredential?: ServiceAccountCredential;
+    scopes?: string[];
+    useDefaultCredential?: boolean;
+    /**
+     * If true, get an ID token instead of an access token.
+     */
+    useIdToken?: boolean;
+    /**
+     * The audience for the ID token. Required if useIdToken is true.
+     */
+    audience?: string;
+}
+export declare enum AuthCredentialTypes {
+    /**
+     * API Key credential:
+     * @see {@link https://swagger.io/docs/specification/v3_0/authentication/api-keys/}
+     */
+    API_KEY = "apiKey",
+    /**
+     * Credentials for HTTP Auth schemes:
+     * @see {@link https://www.iana.org/assignments/http-authschemes/http-auth-schemes.xhtml}
+     */
+    HTTP = "http",
+    /**
+     * OAuth2 credentials:
+     * @see {@link https://swagger.io/docs/specification/v3_0/authentication/oauth2/}
+     */
+    OAUTH2 = "oauth2",
+    /**
+     * Open ID Connect credentials:
+     * @see {@link https://swagger.io/docs/specification/v3_0/authentication/openid-connect-discovery/}
+     */
+    OPEN_ID_CONNECT = "openIdConnect",
+    /**
+     * Service Account credentials:
+     * @see {@link https://cloud.google.com/iam/docs/service-account-creds}
+     */
+    SERVICE_ACCOUNT = "serviceAccount"
+}
+/**
+ * Data class representing an authentication credential.
+ *
+ * To exchange for the actual credential, please use
+ * CredentialExchanger.exchangeCredential().
+ *
+ * @example
+ * // API Key Auth
+ * const authCredential: AuthCredential = {
+ *   authType: AuthCredentialTypes.API_KEY,
+ *   apiKey: "your_api_key",
+ * };
+ *
+ * @example
+ * // HTTP Auth
+ * const authCredential: AuthCredential = {
+ *   authType: AuthCredentialTypes.HTTP,
+ *   http: {
+ *     scheme: "basic",
+ *     credentials: {
+ *       username: "user",
+ *       password: "password",
+ *     },
+ *   }
+ * }
+ *
+ * @example
+ * // OAuth2 Bearer Token in HTTP Header
+ * const authCredential: AuthCredential = {
+ *   authType: AuthCredentialTypes.HTTP,
+ *   http: {
+ *     scheme: "bearer",
+ *     credentials: {
+ *       token: "your_access_token",
+ *     },
+ *   }
+ * }
+ *
+ * @example
+ * // OAuth2 Auth with Authorization Code Flow
+ * const authCredential: AuthCredential = {
+ *   authType: AuthCredentialTypes.OAUTH2,
+ *   oauth2: {
+ *     clientId: "your_client_id",
+ *     clientSecret: "your_client_secret",
+ *   }
+ * }
+ *
+ * @example:
+ * // Open ID Connect Auth
+ * const authCredential: AuthCredential = {
+ *   authType: AuthCredentialTypes.OPEN_ID_CONNECT,
+ *   oauth2: {
+ *     clientId: "1234",
+ *     clientSecret: "secret",
+ *     redirectUri: "https://example.com",
+ *     scopes: ["scope1", "scope2"],
+ *   }
+ * }
+ *
+ * @example:
+ * // Auth with resource reference
+ * const authCredential: AuthCredential = {
+ *   authType: AuthCredentialTypes.API_KEY,
+ *   resourceRef: "projects/1234/locations/us-central1/resources/resource1"
+ * }
+ */
+export interface AuthCredential {
+    authType: AuthCredentialTypes;
+    /**
+     * Resource reference for the credential.
+     * This will be supported in the future.
+     */
+    resourceRef?: string;
+    apiKey?: string;
+    http?: HttpAuth;
+    serviceAccount?: ServiceAccount;
+    oauth2?: OAuth2Auth;
+}

package/dist/types/auth/auth_handler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { State } from '../sessions/state.js';
+import { AuthCredential } from './auth_credential.js';
+import { AuthConfig } from './auth_tool.js';
+/**
+ * A handler that handles the auth flow in Agent Development Kit to help
+ * orchestrates the credential request and response flow (e.g. OAuth flow)
+ * This class should only be used by Agent Development Kit.
+ */
+export declare class AuthHandler {
+    private readonly authConfig;
+    constructor(authConfig: AuthConfig);
+    getAuthResponse(state: State): AuthCredential | undefined;
+    parseAndStoreAuthResponse(state: State): Promise<void>;
+    generateAuthRequest(): AuthConfig;
+    /**
+     * Generates an response containing the auth uri for user to sign in.
+     *
+     * @return An AuthCredential object containing the auth URI and state.
+     * @throws Error: If the authorization endpoint is not configured in the
+     *     auth scheme.
+     */
+    generateAuthUri(): AuthCredential | undefined;
+}

package/dist/types/auth/auth_preprocessor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseLlmRequestProcessor } from '../agents/processors/base_llm_processor.js';
+import { Event } from '../events/event.js';
+export declare class AuthPreprocessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext): AsyncGenerator<Event, void, void>;
+}
+export declare const AUTH_PREPROCESSOR: AuthPreprocessor;

package/dist/types/auth/auth_provider_registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthScheme } from './auth_schemes.js';
+import { BaseAuthProvider } from './base_auth_provider.js';
+/**
+ * Registry for auth provider instances.
+ */
+export declare class AuthProviderRegistry {
+    private readonly providers;
+    /**
+     * Register a provider instance for an auth scheme type.
+     *
+     * @param authSchemeType The auth scheme type (e.g., 'oauth2', 'apiKey').
+     * @param providerInstance The provider instance to register.
+     */
+    register(authSchemeType: string, providerInstance: BaseAuthProvider): void;
+    /**
+     * Get the provider instance for an auth scheme.
+     *
+     * @param authScheme The auth scheme to get provider for.
+     * @returns The provider instance if registered, undefined otherwise.
+     */
+    getProvider(authScheme: AuthScheme): BaseAuthProvider | undefined;
+}

package/dist/types/auth/auth_schemes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+type Oauth2Flow = OpenAPIV3.OAuth2SecurityScheme['flows'];
+/**
+ * OpenIdConnectWithConfig extends OpenIdSecurityScheme with additional
+ * configuration options.
+ */
+export interface OpenIdConnectWithConfig extends OpenAPIV3.OpenIdSecurityScheme {
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    userinfoEndpoint?: string;
+    revocationEndpoint?: string;
+    tokenEndpointAuthMethodsSupported?: string[];
+    grantTypesSupported?: string[];
+    scopes?: string[];
+}
+/**
+ * AuthSchemes contains SecuritySchemes from OpenAPI 3.0 and an extra flattened
+ * OpenIdConnectWithConfig.
+ */
+export type AuthScheme = OpenAPIV3.SecuritySchemeObject | OpenIdConnectWithConfig;
+/**
+ * Represents the OAuth2 flow (or grant type).
+ */
+export declare enum OAuthGrantType {
+    CLIENT_CREDENTIALS = "client_credentials",
+    AUTHORIZATION_CODE = "authorization_code",
+    IMPLICIT = "implicit",
+    PASSWORD = "password"
+}
+/**
+ * Converts an OAuthFlows object to a OAuthGrantType.
+ */
+export declare function getOAuthGrantTypeFromFlow(flow: Oauth2Flow): OAuthGrantType | undefined;
+export {};

package/dist/types/auth/auth_tool.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from './auth_credential.js';
+import { AuthScheme } from './auth_schemes.js';
+/**
+ * The auth config sent by tool asking client to collect auth credentials and
+ * adk and client will help to fill in the response.
+ */
+export interface AuthConfig {
+    /**
+     * The auth scheme used to collect credentials
+     */
+    authScheme: AuthScheme;
+    /**
+     * The raw auth credential used to collect credentials. The raw auth
+     * credentials are used in some auth scheme that needs to exchange auth
+     * credentials. e.g. OAuth2 and OIDC. For other auth scheme, it could be
+     * undefined.
+     */
+    rawAuthCredential?: AuthCredential;
+    /**
+     * The exchanged auth credential used to collect credentials. adk and client
+     * will work together to fill it. For those auth scheme that doesn't need to
+     * exchange auth credentials, e.g. API key, service account etc. It's filled
+     * by client directly. For those auth scheme that need to exchange auth
+     * credentials, e.g. OAuth2 and OIDC, it's first filled by adk. If the raw
+     * credentials passed by tool only has client id and client credential, adk
+     * will help to generate the corresponding authorization uri and state and
+     * store the processed credential in this field. If the raw credentials passed
+     * by tool already has authorization uri, state, etc. then it's copied to this
+     * field. Client will use this field to guide the user through the OAuth2 flow
+     * and fill auth response in this field
+     */
+    exchangedAuthCredential?: AuthCredential;
+    /**
+     * A user specified key used to load and save this credential in a credential
+     * service.
+     */
+    credentialKey: string;
+}
+/**
+ * The arguments for the special long running function tool that is used to
+ * request end user credentials.
+ */
+export interface AuthToolArguments {
+    functionCallId: string;
+    authConfig: AuthConfig;
+}

package/dist/types/auth/base_auth_provider.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from './auth_credential.js';
+import { AuthConfig } from './auth_tool.js';
+/**
+ * Abstract base interface for custom authentication providers.
+ */
+export interface BaseAuthProvider {
+    /**
+     * Provide an AuthCredential asynchronously.
+     *
+     * @param authConfig The current authentication configuration.
+     * @param context The current callback context (placeholder).
+     * @returns The retrieved AuthCredential, or undefined if unavailable.
+     */
+    getAuthCredential(authConfig: AuthConfig, context?: unknown): Promise<AuthCredential | undefined>;
+}

package/dist/types/auth/credential_service/base_credential_service.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+import { AuthCredential } from '../auth_credential.js';
+import { AuthConfig } from '../auth_tool.js';
+/**
+ * Abstract class for Service that loads / saves tool credentials from / to the
+ * backend credential store.
+ */
+export interface BaseCredentialService {
+    /**
+     * Loads the credential by auth config and current tool context from the
+     *  backend credential store.
+     *
+     * @param authConfig The auth config which contains the auth scheme and auth
+     *     credential information. auth_config.get_credential_key will be used to
+     *     build the key to load the credential.
+     * @param toolContext The context of the current invocation when the tool is
+     *     trying to load the credential.
+     * @return A promise that resolves to the credential saved in the store.
+     */
+    loadCredential(authConfig: AuthConfig, toolContext: Context): Promise<AuthCredential | undefined>;
+    saveCredential(authConfig: AuthConfig, toolContext: Context): Promise<void>;
+}

package/dist/types/auth/credential_service/in_memory_credential_service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+import { AuthCredential } from '../auth_credential.js';
+import { AuthConfig } from '../auth_tool.js';
+import { BaseCredentialService } from './base_credential_service.js';
+/**
+ * @experimental  (Experimental, subject to change) Class for in memory
+ * implementation of credential service
+ */
+export declare class InMemoryCredentialService implements BaseCredentialService {
+    private readonly credentials;
+    loadCredential(authConfig: AuthConfig, toolContext: Context): Promise<AuthCredential | undefined>;
+    saveCredential(authConfig: AuthConfig, toolContext: Context): Promise<void>;
+    private getBucketForCurrentContext;
+}

package/dist/types/auth/credential_service/session_state_credential_service.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+import { AuthCredential } from '../auth_credential.js';
+import { AuthConfig } from '../auth_tool.js';
+import { BaseCredentialService } from './base_credential_service.js';
+/**
+ * Class for implementation of credential service using session state as the store.
+ *
+ * Warning: Storing credentials in session state is insecure. Session state may be
+ * persisted in plaintext, logged, or accessible via XSS depending on the runner
+ * environment. Use a secure vault or encrypted storage for production applications.
+ */
+export declare class SessionStateCredentialService implements BaseCredentialService {
+    loadCredential(authConfig: AuthConfig, toolContext: Context): Promise<AuthCredential | undefined>;
+    saveCredential(authConfig: AuthConfig, toolContext: Context): Promise<void>;
+}

package/dist/types/auth/exchanger/base_credential_exchanger.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from '../auth_credential.js';
+import { AuthScheme } from '../auth_schemes.js';
+/**
+ * Base exception for credential exchange errors.
+ */
+export declare class CredentialExchangeError extends Error {
+}
+/**
+ * Result of a credential exchange.
+ */
+export interface ExchangeResult {
+    credential: AuthCredential;
+    wasExchanged: boolean;
+}
+/**
+ * Base interface for credential exchangers.
+ *
+ * Credential exchangers are responsible for exchanging credentials from
+ * one format or scheme to another.
+ */
+export interface BaseCredentialExchanger {
+    /**
+     * Exchange credential if needed.
+     *
+     * @param params.authCredential - The credential to exchange.
+     * @param params.authScheme - The authentication scheme (optional, some exchangers don't need it).
+     * @returns The exchanged credential.
+     * @throws CredentialExchangeError: If credential exchange fails.
+     */
+    exchange(params: {
+        authScheme?: AuthScheme;
+        authCredential: AuthCredential;
+    }): Promise<ExchangeResult>;
+}

package/dist/types/auth/exchanger/credential_exchanger_registry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Credential exchanger registry.
+ */
+import { AuthCredentialTypes } from '../auth_credential.js';
+import { BaseCredentialExchanger } from './base_credential_exchanger.js';
+/**
+ * Registry for credential exchanger instances.
+ */
+export declare class CredentialExchangerRegistry {
+    private exchangers;
+    /**
+     * Register an exchanger instance for a credential type.
+     * @param credentialType - The credential type to register for.
+     * @param exchangerInstance - The exchanger instance to register.
+     */
+    register(credentialType: AuthCredentialTypes, exchangerInstance: BaseCredentialExchanger): void;
+    /**
+     * Get the exchanger instance for a credential type.
+     * @param credentialType - The credential type to get exchanger for.
+     * @returns The exchanger instance if registered, undefined otherwise.
+     */
+    getExchanger(credentialType: AuthCredentialTypes): BaseCredentialExchanger | undefined;
+}