@jhzhu89/azure-client-pool/dist/index.d.ts

Azure client lifecycle management with intelligent caching and authentication

import { TokenCredential } from '@azure/identity';

declare const AuthMode: {
    readonly Application: "application";
    readonly Delegated: "delegated";
    readonly Composite: "composite";
};
type AuthMode = (typeof AuthMode)[keyof typeof AuthMode];
declare const CredentialType: {
    readonly Application: "application";
    readonly Delegated: "delegated";
};
type CredentialType = (typeof CredentialType)[keyof typeof CredentialType];
interface ApplicationAuthRequest {
    readonly mode: typeof AuthMode.Application;
}
interface DelegatedAuthRequest {
    readonly mode: typeof AuthMode.Delegated;
    readonly userAssertion: string;
}
interface CompositeAuthRequest {
    readonly mode: typeof AuthMode.Composite;
    readonly userAssertion: string;
}
type AuthRequest = ApplicationAuthRequest | DelegatedAuthRequest | CompositeAuthRequest;
interface CredentialProvider {
    getCredential(authType: CredentialType): Promise<TokenCredential>;
}
interface ClientFactory<TClient, TOptions = void> {
    createClient(credentialProvider: CredentialProvider, options?: TOptions): Promise<TClient>;
    getClientFingerprint?(options?: TOptions): string | undefined;
}

interface ConfigurationSource {
    load(): Promise<Record<string, unknown>>;
}

type AuthRequestFactory = (authData: {
    userAssertion?: string;
} & Record<string, unknown>) => AuthRequest;
interface RequestMapper<TSource, TOptions = void> {
    extractAuthData(source: TSource): {
        userAssertion?: string;
    } & Record<string, unknown>;
    extractOptions?(source: TSource): TOptions;
}
declare class McpRequestMapper implements RequestMapper<Record<string, unknown>> {
    extractAuthData(request: Record<string, unknown>): {
        userAssertion?: string;
    } & Record<string, unknown>;
}

interface ClientProvider<TClient, TOptions = void> {
    getClient(authRequest: AuthRequest, options?: TOptions): Promise<TClient>;
    invalidateClientCache(authRequest: AuthRequest, options?: TOptions): Promise<boolean>;
}
declare function createClientProvider<TClient, TOptions = void>(clientFactory: ClientFactory<TClient, TOptions>, options?: {
    configSource?: ConfigurationSource;
}): Promise<ClientProvider<TClient, TOptions>>;
declare function createClientProviderWithMapper<TClient, TRequest, TOptions = void>(clientFactory: ClientFactory<TClient, TOptions>, requestMapper: RequestMapper<TRequest, TOptions>, authRequestFactory: AuthRequestFactory, options?: {
    configSource?: ConfigurationSource;
}): Promise<{
    getClient(request: TRequest): Promise<TClient>;
    invalidateClientCache(request: TRequest): Promise<boolean>;
}>;

interface Logger {
    debug(message: string, context?: Record<string, unknown>): void;
    info(message: string, context?: Record<string, unknown>): void;
    warn(message: string, context?: Record<string, unknown>): void;
    error(message: string, context?: Record<string, unknown>): void;
    child?(context: Record<string, unknown>): Logger;
}
declare function getLogger(component?: string): Logger;
declare function setRootLogger(logger: Logger): void;

export { type ApplicationAuthRequest, AuthMode, type AuthRequest, type AuthRequestFactory, type ClientFactory, type ClientProvider, type CompositeAuthRequest, type ConfigurationSource, type CredentialProvider, CredentialType, type DelegatedAuthRequest, type Logger, McpRequestMapper, type RequestMapper, createClientProvider, createClientProviderWithMapper, getLogger, setRootLogger };