import { Encoder, EncoderDecoder } from '@iotize/common/converter/api';
import { TapAuth } from '@iotize/tap/auth';
import { TapRequestFrame, TapResponseFrame } from '@iotize/tap/client/api';
import { SecurityOptionsConfig, TapConfig } from '@iotize/tap/config/schema/v1';
import { FirmwareState } from '@iotize/tap/service/impl/firmware';
import { LoginCredential } from '@iotize/tap/service/impl/interface';
import { Subject } from 'rxjs';
import { GetMetaData, PostMetaData, PutMetaData } from './annotations';
import { VirtualTarget } from './api/virtual-target';
import { ConfigExplorer } from './config-explorer';
import { DataLogEngine } from './datalog-engine';
import { ServerComProtocol } from './server-com-protocol';
import { VirtualTapConfig } from './virtual-tap';
import { VirtualTargetDataCom } from './virtual-target';
export interface CallContext<T = Uint8Array> {
    pathParameters: Record<string, number>;
    server: VirtualTap;
    body: T;
    rawBody: Uint8Array;
    protocol: ServerComProtocol;
    getPathParameter(name: string): number;
}
declare type RequestMeta<T = any> = GetMetaData<T> | PostMetaData<T> | PutMetaData<T>;
interface Endpoint<T = Uint8Array> {
    call: (context: CallContext<T>) => any;
    meta: RequestMeta;
}
interface EndpointCandidate {
    endpoint: Endpoint;
    pathParameters: Record<string, number>;
}
interface RequestContext {
    protocol: ServerComProtocol;
}
export declare function checkRouteMatch(request: {
    method: TapRequestFrame.MethodType;
    path: string;
}, meta: RequestMeta<any>): boolean;
export declare function getRouteParams(request: {
    method: TapRequestFrame.MethodType;
    path: string;
}, meta: RequestMeta<any>): Record<string, number>;
export declare const FACTORY_RESET_CONFIG: TapConfig;
export declare class VirtualTap {
    deviceConfig: VirtualTapConfig;
    protocols: ServerComProtocol[];
    requestDecoder: import("@iotize/tap/client/impl").TapApduRequestConverter;
    responseEncoder: import("@iotize/tap/client/impl").TapApduResponseConverter;
    sessionState: TapAuth.SessionState;
    requestStream: Subject<Uint8Array>;
    responseStream: Subject<Uint8Array>;
    endpoints: Endpoint<any>[];
    info: VirtualTap.Info;
    configExplorer: ConfigExplorer;
    targetCom: VirtualTargetDataCom;
    dataLogEngine: DataLogEngine;
    private _firmwareState;
    get firmwareVersion(): string;
    get serialNumber(): string;
    get modelName(): string;
    get securityOptions(): SecurityOptionsConfig;
    get config(): TapConfig;
    setConfig(configSchema: TapConfig): void;
    static create(serverConfig?: VirtualTapConfig, tapConfig?: TapConfig): VirtualTap;
    constructor(configSchema: TapConfig, deviceConfig: VirtualTapConfig);
    setFirmwareState(firmwareState: FirmwareState): void;
    getFirmwareState(): FirmwareState;
    setTarget(target: VirtualTarget): void;
    getHostName(): string;
    getMacAddress(): string;
    getHostProtocols(): import("@iotize/tap").HostProtocol[];
    login(data: LoginCredential): void;
    private setSessionStateFromProfile;
    logout(): void;
    listen(): Promise<unknown>;
    start(): Promise<void>;
    private rescheduleProtocolStart;
    stop(): Promise<void>;
    registerService(services: any[]): void;
    registerHostProtocol(protocol: ServerComProtocol): void;
    _encodeResponse(response: TapResponseFrame): Uint8Array;
    onNewConnection(): void;
    factoryReset(): void;
    reboot(): Promise<void>;
    handleData(data: Uint8Array, context: RequestContext): TapResponseFrame;
    private _buildServices;
    handleRequest(request: TapRequestFrame, context: RequestContext): TapResponseFrame;
    handleEndpoint(request: TapRequestFrame, candidate: EndpointCandidate, context: RequestContext): TapResponseFrame;
    checkCredentials(auth: string[]): void;
    checkConfigModeEnabled(): void;
    sendErrorResponse(code: number): Uint8Array;
    createResponse<T>(data: {
        converter: Encoder<T, Uint8Array>;
        value: T;
    }): TapResponseFrame;
    sendResponse<T>(response: TapResponseFrame): Uint8Array;
    sendData(data: Uint8Array): Uint8Array;
    bindConfigToRoute<T, Key extends keyof T>(options: {
        path: string;
        item: (call: CallContext<any>) => T;
        key: Key;
        default: T[Key];
        converter?: EncoderDecoder<T[Key], Uint8Array>;
        get?: boolean;
        put?: boolean;
        post?: boolean;
    }): void;
    private _startProtocols;
}
export declare namespace VirtualTap {
    class Info {
    }
}
export {};