import { AuthorizedGetEndpoint, AuthorizedPostEndpoint, AuthorizedUploadEndpoint, AuthorizeRequest, AuthorizeResponse, AuthClientOptions, AuthEndpoints, AuthRequestOptions, AuthUploadRequestOptions, ChallengeRequest, ChallengeResponse, DeviceEventResponse, DeviceReferenceRequest, DeviceSeedRequest, RelativeEndpoint, SessionConfigurationRequest, SessionConfigurationResponse } from "./types.js";
export interface AuthorizedEventStreamObserver {
    onMessage(data: string): void;
    onError(error: unknown): void;
    onComplete(): void;
}
export interface AuthorizedEventStreamSubscription {
    cancel(): void;
}
export declare class TruliooApiError extends Error {
    readonly status: number;
    readonly endpoint: RelativeEndpoint;
    readonly responseBody: unknown;
    /**
     * Creates an API error for a non-success Trulioo HTTP response.
     *
     * @param message Human-readable error message.
     * @param status HTTP status code.
     * @param endpoint Relative endpoint associated with the failure.
     * @param responseBody Parsed or raw response body.
     */
    constructor(message: string, status: number, endpoint: RelativeEndpoint, responseBody: unknown);
}
/** Low-level web HTTP client for Trulioo bootstrap, authorized session, and device-intelligence requests. */
export declare class TruliooClient {
    readonly endpoints: AuthEndpoints;
    private readonly baseUrl;
    private readonly rawFetchImpl;
    private readonly defaultHeaders;
    private readonly allowedEndpoints;
    /**
     * Creates a Trulioo web HTTP client.
     *
     * @param options Client configuration including base URL, fetch implementation, and endpoint policy.
     */
    constructor(options: AuthClientOptions);
    /**
     * Sends a shortcode challenge request.
     *
     * @param request Challenge request payload.
     * @param init Optional fetch init overrides.
     * @returns Challenge response containing the authorization code.
     */
    challenge(request: ChallengeRequest, init?: RequestInit): Promise<ChallengeResponse>;
    /**
     * Sends an authorization request.
     *
     * @param request Authorization request payload.
     * @param init Optional fetch init overrides.
     * @returns Authorization response containing the access token.
     */
    authorize(request: AuthorizeRequest, init?: RequestInit): Promise<AuthorizeResponse>;
    /**
     * Requests session configuration for an authorized Trulioo session.
     *
     * @param request Session-configuration request payload.
     * @param options Authorized request options.
     * @returns Normalized session configuration response.
     */
    sessionConfiguration(request: SessionConfigurationRequest, options?: AuthRequestOptions): Promise<SessionConfigurationResponse>;
    /**
     * Seeds a Trulioo device event.
     *
     * @param request Device-seed request payload.
     * @param options Authorized request options.
     * @returns Device-event response for the seeded event.
     */
    deviceSeed(request: DeviceSeedRequest, options?: AuthRequestOptions): Promise<DeviceEventResponse>;
    /**
     * Sends subject reference data for a Trulioo device session.
     *
     * @param request Device-reference request payload.
     * @param options Authorized request options.
     * @returns Promise that resolves when the request completes.
     */
    deviceReference(request: DeviceReferenceRequest, options?: AuthRequestOptions): Promise<void>;
    /**
     * Fetches the current Trulioo device-event state for the provided event identifier.
     *
     * @param eventId Device event identifier.
     * @param options Authorized request options.
     * @returns Current device-event response.
     */
    deviceEvent(eventId: string, options?: AuthRequestOptions): Promise<DeviceEventResponse>;
    /**
     * Performs the full challenge, authorize, and session-configuration bootstrap sequence.
     *
     * @param request Aggregated bootstrap request payloads.
     * @param init Optional fetch init overrides applied across the sequence.
     * @returns Aggregated session bootstrap result.
     */
    startSession(request: {
        challenge: ChallengeRequest;
        authorize: AuthorizeRequest;
        sessionConfiguration: SessionConfigurationRequest;
    }, init?: RequestInit): Promise<{
        challenge: ChallengeResponse;
        authorization: AuthorizeResponse;
        sessionConfiguration: SessionConfigurationResponse;
    }>;
    /**
     * Sends an authorized POST request.
     *
     * @param endpoint Authorized endpoint definition.
     * @param request Request payload to serialize.
     * @param options Authorized request options.
     * @returns Decoded response payload.
     */
    authorizedPost<Request, Response>(endpoint: AuthorizedPostEndpoint<Request, Response>, request: Request, options?: AuthRequestOptions): Promise<Response>;
    /**
     * Sends an authorized POST request without a request body.
     *
     * @param endpoint Authorized endpoint definition.
     * @param options Authorized request options.
     * @returns Decoded response payload.
     */
    authorizedPostWithoutBody<Response>(endpoint: AuthorizedPostEndpoint<unknown, Response>, options?: AuthRequestOptions): Promise<Response>;
    /**
     * Sends an authorized POST request and discards the response body.
     *
     * @param endpoint Authorized endpoint definition.
     * @param request Request payload to serialize.
     * @param options Authorized request options.
     * @returns Promise that resolves when the request completes.
     */
    authorizedPostWithoutResponse<Request>(endpoint: AuthorizedPostEndpoint<Request, unknown>, request: Request, options?: AuthRequestOptions): Promise<void>;
    /**
     * Sends an authorized GET request and discards the response body.
     *
     * @param endpoint Authorized endpoint definition.
     * @param options Authorized request options.
     * @returns Promise that resolves when the request completes.
     */
    authorizedGetWithoutResponse<Response>(endpoint: AuthorizedGetEndpoint<Response>, options?: AuthRequestOptions): Promise<void>;
    /**
     * Sends an authorized GET request.
     *
     * @param endpoint Authorized endpoint definition.
     * @param options Authorized request options.
     * @returns Decoded response payload.
     */
    authorizedGet<Response>(endpoint: AuthorizedGetEndpoint<Response>, options?: AuthRequestOptions): Promise<Response>;
    /**
     * Sends an authorized GET request and returns the raw response text.
     *
     * Useful for endpoints that return SSE or other non-JSON payloads.
     *
     * @param endpoint Authorized endpoint definition.
     * @param options Authorized request options.
     * @returns Raw response body text.
     */
    authorizedGetText(endpoint: AuthorizedGetEndpoint<unknown>, options?: AuthRequestOptions): Promise<string>;
    /**
     * Opens an authorized SSE-style GET request and emits each streamed `data:` payload.
     *
     * @param endpoint Authorized endpoint definition.
     * @param observer Event-stream observer callbacks.
     * @param options Authorized request options.
     * @returns Cancelable stream subscription.
     */
    authorizedGetEventStream(endpoint: AuthorizedGetEndpoint<unknown>, observer: AuthorizedEventStreamObserver, options?: AuthRequestOptions): AuthorizedEventStreamSubscription;
    /**
     * Sends an authorized binary upload request.
     *
     * @param endpoint Authorized endpoint definition.
     * @param body Binary upload payload.
     * @param options Authorized upload options.
     * @returns Decoded response payload.
     */
    authorizedUpload<Response>(endpoint: AuthorizedUploadEndpoint, body: Uint8Array, options?: AuthUploadRequestOptions): Promise<Response>;
    private request;
    private requestWithoutResponse;
    private requestText;
    private requestEventStream;
    private requestBinary;
    private toUrl;
}
export declare function normalizeDeviceEnvironment(environment: string | null | undefined): string | undefined;