import { Socket, SocketOptions, ManagerOptions } from 'socket.io-client';
import { TwinTypeEnum, TwinStatusEnum, ScreenTwinReportedProperties, TwinResponse, EdgeTwinResponse, EdgeTwinDesiredPropertiesResponse, CloudTwinResponse, Instance, PeripheralInstance, TwinMessageResult, TwinMessageResultStatus } from './types/twin.types';
import { type CloudAppConnectionParams } from './services/cloud-app-connection.service';
import { type WebAppConnectionParams } from './services/web-app-connection.service';
import type { WebAppSessionError } from './services/web-app-session.service';
import { type WebSessionCode, type WebSessionCodeListener, type WebSessionCodeOptions, type WebSessionCodeSubscription } from './services/web-session-code.service';
import { SignalsService } from './services/signals.service';
import { DataRequestTypeEnum, InitSignalPayload } from './types/signal.types';
import { WebRTCManager, PhygridDataChannel, PhygridMediaStream, WebRTCManagerOptions, IceServersProvider, IceServersResult, MediaStreamOptions, MediaTrackKind, TurnServerConfig, MediaStreamResponderOptions, DataChannelResponderOptions, MediaStreamCallback, DataChannelCallback, PeerInfo } from './services/webrtc';
import { DescriptorValidator } from './advisory-validation';
export interface EventPayload<T = any> {
    twinId?: string;
    sourceTwinId?: string;
    sourceDeviceId?: string;
    deviceId?: string;
    status?: TwinStatusEnum;
    data?: T;
}
export type MyIoOptions = Partial<ManagerOptions & SocketOptions>;
export type PhyHubClientParams = {
    instanceId?: string;
    moduleName?: string;
    dataResidency?: string;
    cloudApp?: undefined;
    webApp?: undefined;
} | {
    cloudApp: CloudAppConnectionParams;
    instanceId?: undefined;
    moduleName?: undefined;
    dataResidency?: undefined;
    webApp?: undefined;
} | {
    webApp: WebAppConnectionParams;
    instanceId?: undefined;
    moduleName?: undefined;
    dataResidency?: undefined;
    cloudApp?: undefined;
};
export interface CloudTwinLifecycleEvent {
    eventId?: string;
    $version?: number;
    twin: CloudTwinResponse;
}
export declare class PhyHubClient {
    private static instance;
    private instanceId;
    private moduleName;
    private socket;
    private socketConnected;
    private armedSocket;
    private armedSocketHandlers;
    private armedManagerHandlers;
    private pendingRequestErrorDetachers;
    private emitQueue;
    private lastDeviceStatusCheck;
    private lastDeviceStatusResponse;
    private signals;
    private subscribedTwins;
    private twinMessageListeners;
    private instances;
    private twinUpdateListeners;
    private twinInstancesRegistry;
    private webrtcManager;
    private cachedIceServers;
    private instanceTransport;
    private cloudAppParams;
    private cloudAppConnection;
    private cloudTwins;
    private cloudTwinCreatedListeners;
    private cloudTwinUpdatedListeners;
    private cloudTwinDeletedListeners;
    private webAppParams;
    private webAppConnection;
    private webAppListenersAttached;
    private readonly EVENTS;
    constructor(params?: PhyHubClientParams);
    private initializeConnection;
    private waitForSocketConnected;
    private initializeCloudAppConnection;
    private setupCloudAppSocketListeners;
    private initializeWebAppConnection;
    onWebAppSessionTerminated(listener: (error: WebAppSessionError) => void): () => void;
    private assertNotWebAppSession;
    private assertDeviceSession;
    private handleCloudTwinLifecycleEvent;
    private armSocketHandler;
    private armManagerHandler;
    private armRequestErrorListener;
    private detachArmedHandlers;
    private setupSocketListeners;
    private handlePeripheralOwnershipLost;
    private assureSocketConnection;
    private static connectInFlight;
    static connect(params?: PhyHubClientParams): Promise<PhyHubClient>;
    getSocket: () => Socket | null;
    initializeSignals: (initParams?: InitSignalPayload) => Promise<SignalsService>;
    isConnected(): boolean;
    sendSignal(type: DataRequestTypeEnum, data: Record<string, any>): Promise<void>;
    private resolveDeviceSpaceId;
    getDeviceStatus(): Promise<any>;
    getDataChannel: (targetTwinId: string, channelName?: string) => Promise<PhygridDataChannel>;
    onDataChannel: (callback: DataChannelCallback, options?: DataChannelResponderOptions) => Promise<() => void>;
    getMediaStream(targetTwinId: string, options?: MediaStreamOptions): Promise<{
        stream: PhygridMediaStream;
        close: () => void;
    }>;
    onMediaStream: (callback: MediaStreamCallback, options?: MediaStreamResponderOptions) => Promise<() => void>;
    getIceServers(useCase?: 'media' | 'data'): Promise<IceServersResult>;
    getWebRTCManager(options?: WebRTCManagerOptions): Promise<WebRTCManager>;
    getInstance(): Promise<Instance>;
    getEdgeInstance(): Promise<Instance>;
    getScreenInstance(): Promise<Instance>;
    getPeripheralInstance(peripheralTwinId: string, advisoryValidator?: DescriptorValidator): Promise<PeripheralInstance | null>;
    private getGridApp;
    getSettings(): Promise<Partial<EdgeTwinDesiredPropertiesResponse>>;
    getEdgeSettings(): Promise<Partial<EdgeTwinDesiredPropertiesResponse>>;
    getScreenSettings(): Promise<Partial<EdgeTwinDesiredPropertiesResponse>>;
    getDeviceInstance(): Promise<any>;
    getDeviceNetworks(): Promise<any>;
    setScreenInstanceReportedProperties(payload: EventPayload<ScreenTwinReportedProperties>): Promise<any>;
    emit(method: string, ...args: any[]): void;
    private processEmitQueue;
    onTwinUpdate(targetTwinId: string, callback: (twin: TwinResponse) => void): void;
    offTwinUpdate(targetTwinId: string, callback: (twin: TwinResponse) => void): boolean;
    sendEvent(targetTwinId: string, data: any): void;
    private sendCloudAppEvent;
    getCloudTwins(): CloudTwinResponse[];
    onCloudTwinCreated(listener: (event: CloudTwinLifecycleEvent) => void): () => void;
    onCloudTwinUpdated(listener: (event: CloudTwinLifecycleEvent) => void): () => void;
    onCloudTwinDeleted(listener: (event: CloudTwinLifecycleEvent) => void): () => void;
    disconnect(): void;
    request(targetTwinId: string, data: any, callback?: (response: TwinMessageResult) => void): Promise<TwinMessageResult | undefined>;
    onTwinMessage(targetTwinId: string, callback: (message: any) => void): Promise<void>;
    offTwinMessage(targetTwinId: string, callback: (message: any) => void): boolean;
    removeMessageListener(twinId: string, callback: (message: any) => void): void;
    subscribeTwin(targetTwinId: string, callback?: (response: any) => void): Promise<unknown>;
    unsubscribeTwin(targetTwinId: string): void;
    getTwinById(twinId: string): Promise<TwinResponse>;
    private buildWebSessionCodeClientAdapter;
    createWebSessionCode(options: WebSessionCodeOptions): Promise<WebSessionCode>;
    subscribeWebSessionCode(options: WebSessionCodeOptions, listener: WebSessionCodeListener): WebSessionCodeSubscription;
    updateReportedProperties(twinId: string, reportedProperties: Record<string, any>, twinType?: TwinTypeEnum): Promise<TwinResponse>;
}
export declare const connectPhyClient: (params?: PhyHubClientParams) => Promise<PhyHubClient>;
export type { EdgeTwinResponse, Instance, PeripheralInstance, TwinMessageResult, InitSignalPayload, CloudTwinResponse };
export type { PeripheralInstance as IPeripheralTwinInstance };
export { TwinMessageResultStatus };
export { formatScopedHardwareId, HARDWARE_ID_USER_PART_MAX_LENGTH } from './scoped-hardware-id';
export type { HardwareIdScope } from './scoped-hardware-id';
export type { PeripheralCreateResult, PeripheralHandover, PeripheralCreateOrUpdateAckResponse, PeripheralOwnershipLoss, } from './types/twin.types';
export { CloudAppConnection } from './services/cloud-app-connection.service';
export type { CloudAppConnectionParams } from './services/cloud-app-connection.service';
export { exchangeCloudAppToken, CloudAppTokenExchangeError } from './services/cloud-app-token.service';
export type { CloudAppToken, CloudAppTokenExchangeParams } from './services/cloud-app-token.service';
export { WebAppConnection } from './services/web-app-connection.service';
export type { WebAppConnectionParams, WebAppConnectResult } from './services/web-app-connection.service';
export { exchangeWebAppSession, WebAppSessionError, readWebSessionCodeFromLocation, clearWebSessionCodeFromLocation, loadWebAppBoot, readStoredWebSession, writeStoredWebSession, clearStoredWebSession, WEB_SESSION_STORAGE_KEY_PREFIX, } from './services/web-app-session.service';
export type { WebAppBoot } from './services/web-app-session.service';
export type { WebAppSession, WebAppSessionExchangeParams, WebAppSessionFetch, StoredWebSession, WebSessionStorageLike, } from './services/web-app-session.service';
export { WebSessionCodeIssuer, WebSessionCodeConfigError } from './services/web-session-code.service';
export type { WebSessionCode, WebSessionCodeOptions, WebSessionCodeState, WebSessionCodeListener, WebSessionCodeSubscription, WebSessionCodeTarget, } from './services/web-session-code.service';
declare const _default: {
    connectPhyClient: (params?: PhyHubClientParams) => Promise<PhyHubClient>;
};
export default _default;
export type { PhygridDataChannel, PhygridMediaStream, WebRTCManagerOptions, IceServersProvider, IceServersResult, MediaStreamOptions, MediaTrackKind, TurnServerConfig, MediaStreamResponderOptions, DataChannelResponderOptions, MediaStreamCallback, DataChannelCallback, PeerInfo, };
export { WebRTCManager, ensureWebRTCGlobals } from './services/webrtc';
export type { SignalingSink, SignalingMessageType } from './services/webrtc';
export { NoMediaResponderError, PeerCapReachedError, MissingMediaTrackError } from './services/webrtc';
export type { TwinMessagingMethods } from './twin-messaging';
export { createTwinMessaging } from './twin-messaging';
export type { DescriptorValidator, CompiledValidator, AdvisoryLogger, AdvisoryFacet } from './advisory-validation';
export { validateEmittedFacet } from './advisory-validation';
//# sourceMappingURL=index.d.ts.map