/**
 * @module transport/TelegramHttpTransport
 * @description HTTP transport implementation for Telegram Bot API
 * Extends BaseTelegramApi and provides HTTP communication layer
 */
import { BaseTelegramApi } from '../api/BaseTelegramApi.generated.js';
import { TokensManager } from './TokensManager.js';
import { ContentTypeSuffix } from '../constants.js';
import type { HttpContentType, HttpClientOptions } from '../types/http-client.types.js';
import type { TokensData, MethodPriorities } from '../types/transport.types.js';
import type { IQueueProvider } from '../types/queue.types.js';
import type { ILogger, LoggerOptions, ILoggerAware } from '../types/logger.types.js';
/**
 * Transport configuration options
 */
export interface TelegramHttpTransportOptions extends LoggerOptions {
    /** HTTP client configuration */
    httpClientOptions?: HttpClientOptions;
    /** Tokens manager instance (optional, will create new if not provided) */
    tokensManager?: TokensManager;
    /** Enable bypass mode (direct HTTP requests without queue) for debugging */
    bypassQueue?: boolean;
    /** Queue provider (optional, required if bypassQueue is false) */
    queueProvider?: IQueueProvider;
    /** Method priority configuration (optional) */
    methodPriorities?: MethodPriorities;
}
/**
 * HTTP transport implementation for Telegram Bot API
 * Supports both direct HTTP requests (bypass mode) and queue-based requests
 */
export declare class TelegramHttpTransport extends BaseTelegramApi implements ILoggerAware {
    private readonly httpClient;
    private readonly tokensManager;
    private readonly bypassQueue;
    private readonly queueProvider?;
    private readonly methodPriorities;
    /** Logger instance - mutable to support LoggerBinder.bind() */
    logger?: ILogger;
    /**
     * Create a new TelegramHttpTransport instance
     * @param options - Transport configuration options
     */
    constructor(options?: TelegramHttpTransportOptions);
    /**
     * Get tokens manager instance
     */
    get tokens(): TokensData;
    /**
     * Implementation of abstract callApi method from BaseTelegramApi
     * @param methodName - Telegram API method name
     * @param params - Method parameters
     * @param routeId - Route ID (token identifier)
     * @param contentType - Content type for the request
     * @returns Promise with API response
     */
    protected callApi<T>(methodName: string, params: object, routeId?: string, contentType?: keyof typeof ContentTypeSuffix): Promise<T>;
    /**
     * Enqueue request through queue provider
     * @param token - Bot token
     * @param methodName - API method name
     * @param params - Method parameters
     * @param contentType - Content type
     * @param routeId - Route ID for queue naming
     * @returns Promise with API response
     */
    private enqueueRequest;
    /**
     * Get priority for API method
     * Uses custom priorities if configured, otherwise falls back to default categories
     *
     * Default priority levels:
     * - HIGH (8): answerCallbackQuery, answerInlineQuery - most time-sensitive
     * - MEDIUM (5): all other methods except getUpdates - normal operations
     * - LOW (2): getUpdates - background polling
     *
     * @param methodName - API method name
     * @returns Priority value (0-10, higher is more important)
     */
    private getMethodPriority;
    /**
     * Send a direct request without going through standard callApi flow
     * Useful for testing and debugging
     * @param methodName - Telegram API method name
     * @param params - Method parameters
     * @param tokenId - Token identifier (optional, uses default if not provided)
     * @param contentType - Content type for the request
     * @returns Promise with API response
     */
    sendDirectRequest<T>(methodName: string, params: object, tokenId?: string, contentType?: HttpContentType): Promise<T>;
    /**
     * Resolve token by ID or get default token
     * @param tokenId - Token identifier (optional)
     * @returns Bot token or undefined
     */
    private resolveToken;
    /**
     * Map ContentTypeSuffix to HttpContentType
     * @param contentType - Content type suffix from constants
     * @returns Mapped content type
     */
    private mapContentType;
    /**
     * Add a bot token
     * @param tokenId - Unique identifier for the token
     * @param token - Bot token from BotFather
     * @returns True if token was added successfully
     */
    addToken(tokenId: string, token: string): boolean;
    /**
     * Remove a bot token
     * @param tokenId - Token identifier to remove
     * @param defaultId - Optional new default token ID
     * @returns True if token was removed successfully
     */
    removeToken(tokenId: string, defaultId?: string): boolean;
    /**
     * Set the default token
     * @param tokenId - Token identifier to set as default
     * @returns True if successfully set
     */
    setDefaultToken(tokenId: string): boolean;
    /**
     * Get all registered token IDs
     * @returns Array of token IDs
     */
    getTokenIds(): string[];
    /**
     * Check if bypass queue mode is enabled
     * @returns True if bypass mode is enabled
     */
    isBypassMode(): boolean;
    /**
     * Get queue statistics for a specific bot/route
     * @param routeId - Route ID (optional, uses 'default' if not provided)
     * @returns Queue statistics
     */
    getQueueStats(routeId?: string): Promise<import("../types/queue.types.js").QueueStats>;
    /**
     * Get queue provider instance (if available)
     * @returns Queue provider or undefined
     */
    getQueueProvider(): IQueueProvider | undefined;
    /**
     * Close transport and cleanup resources
     */
    closeTransport(): Promise<void>;
}