import * as React from 'react';
import { LocalMediaState, LocalMediaOptions, RoomJoinedSuccess, RoomConnectionState, NotificationsEventEmitter, ClientView } from '@whereby.com/core';
export { BreakoutState as Breakout, ChatMessageState as ChatMessage, CloudRecordingState as CloudRecording, LiveStreamState as LiveStreaming, LocalParticipantState as LocalParticipant, RemoteParticipantState as RemoteParticipant, RoomConnectionState as RoomConnection, ScreenshareState as Screenshare, WaitingParticipantState as WaitingParticipant } from '@whereby.com/core';
import * as _radix_ui_react_popover from '@radix-ui/react-popover';
import { PopoverProps } from '@radix-ui/react-popover';

interface ProviderProps {
    children: React.ReactNode;
}
declare function Provider({ children }: ProviderProps): React.JSX.Element;

interface VideoViewSelfProps {
    stream: MediaStream;
    muted?: boolean;
    mirror?: boolean;
    style?: React.CSSProperties;
    onVideoResize?: ({ width, height, stream }: {
        width: number;
        height: number;
        stream: MediaStream;
    }) => void;
}
type WherebyVideoElement = HTMLVideoElement & {
    captureAspectRatio: () => number;
    onVideoResize: ({ width, height, stream }: {
        width: number;
        height: number;
        stream: MediaStream;
    }) => void;
};
type VideoViewProps = VideoViewSelfProps & React.DetailedHTMLProps<React.VideoHTMLAttributes<WherebyVideoElement>, WherebyVideoElement>;
declare const VideoView: React.ForwardRefExoticComponent<Omit<VideoViewProps, "ref"> & React.RefAttributes<WherebyVideoElement>>;

interface LocalMediaActions {
    setCameraDevice: (deviceId: string) => void;
    setMicrophoneDevice: (deviceId: string) => void;
    setSpeakerDevice: (deviceId: string) => void;
    toggleCameraEnabled: (enabled?: boolean) => void;
    toggleMicrophoneEnabled: (enabled?: boolean) => void;
    toggleLowDataModeEnabled: (enabled?: boolean) => void;
}
type UseLocalMediaResult = {
    state: LocalMediaState;
    actions: LocalMediaActions;
};
type UseLocalMediaOptions = LocalMediaOptions;

interface RoomConnectionOptions {
    displayName?: string;
    localMediaOptions?: LocalMediaOptions;
    roomKey?: string;
    localMedia?: UseLocalMediaResult;
    externalId?: string;
}
interface UseRoomConnectionOptions extends Omit<RoomConnectionOptions, "localMedia"> {
    localMedia?: UseLocalMediaResult;
}
interface RoomConnectionActions {
    toggleLowDataMode: (enabled?: boolean) => void;
    toggleRaiseHand: (enabled?: boolean) => void;
    askToSpeak: (participantId: string) => void;
    askToTurnOnCamera: (participantId: string) => void;
    acceptWaitingParticipant: (participantId: string) => void;
    knock: () => void;
    cancelKnock: () => void;
    joinRoom: () => Promise<RoomJoinedSuccess>;
    leaveRoom: () => void;
    lockRoom: (locked: boolean) => void;
    muteParticipants: (clientIds: string[]) => void;
    turnOffParticipantCameras: (clientIds: string[]) => void;
    kickParticipant: (clientId: string) => void;
    endMeeting: (stayBehind?: boolean) => void;
    rejectWaitingParticipant: (participantId: string) => void;
    sendChatMessage: (text: string) => void;
    setDisplayName: (displayName: string) => void;
    startCloudRecording: () => void;
    startLiveTranscription: () => void;
    startScreenshare: () => void;
    stopCloudRecording: () => void;
    stopLiveTranscription: () => void;
    stopScreenshare: () => void;
    toggleCamera: (enabled?: boolean) => void;
    toggleMicrophone: (enabled?: boolean) => void;
    spotlightParticipant: (clientId: string) => void;
    removeSpotlight: (clientId: string) => void;
    joinBreakoutGroup: (group: string) => void;
    joinBreakoutMainRoom: () => void;
    switchCameraEffect: (effectId: string) => Promise<void>;
    switchCameraEffectCustom: (imageUrl: string) => Promise<void>;
    clearCameraEffect: () => Promise<void>;
}

type RoomConnectionRef = {
    state: Omit<RoomConnectionState, "events">;
    actions: RoomConnectionActions;
    events?: NotificationsEventEmitter;
};
declare function useRoomConnection(roomUrl: string, roomConnectionOptions?: UseRoomConnectionOptions): RoomConnectionRef;

declare function useLocalMedia(optionsOrStream?: UseLocalMediaOptions | MediaStream): UseLocalMediaResult;

type GridCellSelfProps = {
    participant: ClientView;
};
type GridCellProps = GridCellSelfProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
declare const GridCell: React.ForwardRefExoticComponent<Omit<GridCellProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const GridVideoView: React.ForwardRefExoticComponent<Omit<VideoViewProps, "ref" | "stream"> & {
    stream?: MediaStream;
} & React.RefAttributes<WherebyVideoElement>>;
interface GridProps {
    renderParticipant?: ({ participant }: {
        participant: ClientView;
    }) => React.ReactNode;
    renderFloatingParticipant?: ({ participant }: {
        participant: ClientView;
    }) => React.ReactNode;
    gridGap?: number;
    videoGridGap?: number;
    enableSubgrid?: boolean;
    stageParticipantLimit?: number;
    enableParticipantMenu?: boolean;
    enableConstrainedGrid?: boolean;
}
declare function Grid({ renderParticipant, renderFloatingParticipant, stageParticipantLimit, gridGap, videoGridGap, enableSubgrid, enableParticipantMenu, enableConstrainedGrid, }: GridProps): React.JSX.Element;

declare const ParticipantMenu: (props: PopoverProps) => React.JSX.Element;
declare const ParticipantMenuContent: React.ForwardRefExoticComponent<Omit<Omit<_radix_ui_react_popover.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const ParticipantMenuTrigger: React.ForwardRefExoticComponent<Omit<_radix_ui_react_popover.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const ParticipantMenuItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
    participantAction?: "maximize" | "spotlight" | "float";
} & React.RefAttributes<HTMLButtonElement>>;

export { GridCell, GridVideoView, ParticipantMenu, ParticipantMenuContent, ParticipantMenuItem, ParticipantMenuTrigger, Grid as VideoGrid, VideoView, Provider as WherebyProvider, useLocalMedia, useRoomConnection };
export type { RoomConnectionActions, RoomConnectionOptions, UseLocalMediaResult };