import { CallClosedCaption, CallIngressResponse, CallSessionResponse, CallSettingsResponse, CallState, CallStatsReport, Comparator, EgressResponse, InputDeviceStatus, MemberResponse, OwnCapability, StreamVideoParticipant, UserResponse } from '@stream-io/video-client';
export type UseInputMediaDeviceOptions = {
    /**
     * If `true`, the hook will use the optimistic status to determine whether the device is muted or not.
     */
    optimisticUpdates?: boolean;
};
/**
 * Utility hook, which provides the current call's state.
 */
export declare const useCallState: () => CallState;
/**
 * Utility hook which provides information whether the current call is being recorded. It will return `true` if the call is being recorded.
 */
export declare const useIsCallRecordingInProgress: () => boolean;
/**
 * Utility hook which provides information whether the raw track recording is running.
 */
export declare const useIsCallRawRecordingInProgress: () => boolean;
/**
 * Utility hook which provides information whether the individual track recording is running.
 */
export declare const useIsCallIndividualRecordingInProgress: () => boolean;
/**
 * Utility hook which provides information whether the current call is broadcasting.
 */
export declare const useIsCallHLSBroadcastingInProgress: () => boolean;
/**
 * Utility hook which provides information whether the current call is live.
 */
export declare const useIsCallLive: () => boolean;
/**
 * Returns the list of blocked users in the current call.
 */
export declare const useCallBlockedUserIds: () => string[];
/**
 * Returns the timestamp when this call was created.
 */
export declare const useCallCreatedAt: () => Date | undefined;
/**
 * Returns the timestamp when this call was ended.
 */
export declare const useCallEndedAt: () => Date | undefined;
/**
 * Returns the timestamp telling when the call is scheduled to start.
 */
export declare const useCallStartsAt: () => Date | undefined;
/**
 * Returns the timestamp when this call was updated.
 */
export declare const useCallUpdatedAt: () => Date | undefined;
/**
 * Returns the information about the call's creator.
 */
export declare const useCallCreatedBy: () => UserResponse | undefined;
/**
 * Returns the call's custom data.
 */
export declare const useCallCustomData: () => Record<string, any>;
/**
 * Returns the call's Egress information.
 */
export declare const useCallEgress: () => EgressResponse | undefined;
/**
 * Returns the call's Ingress information.
 */
export declare const useCallIngress: () => CallIngressResponse | undefined;
/**
 * Returns the data for the current call session.
 */
export declare const useCallSession: () => CallSessionResponse | undefined;
/**
 * Returns the call's settings.
 */
export declare const useCallSettings: () => CallSettingsResponse | undefined;
/**
 * Returns whether the call has transcribing enabled.
 */
export declare const useIsCallTranscribingInProgress: () => boolean;
/**
 * Returns information about the user who has marked this call as ended.
 */
export declare const useCallEndedBy: () => UserResponse | undefined;
/**
 * Utility hook which provides a boolean indicating whether there is
 * a participant in the current call which shares their screen.
 */
export declare const useHasOngoingScreenShare: () => boolean;
/**
 * Utility hook which provides the latest stats report of the current call.
 *
 * The latest stats report of the current call.
 * When stats gathering is enabled, this observable will emit a new value
 * at a regular (configurable) interval.
 *
 * Consumers of this observable can implement their own batching logic
 * in case they want to show historical stats data.
 */
export declare const useCallStatsReport: () => CallStatsReport | undefined;
/**
 * Utility hook which provides the dominant speaker of the current call.
 */
export declare const useDominantSpeaker: () => StreamVideoParticipant | undefined;
/**
 * Utility hook which provides a list of call members.
 */
export declare const useCallMembers: () => MemberResponse[];
/**
 * Utility hook providing the current calling state of the call. For example, `RINGING` or `JOINED`.
 */
export declare const useCallCallingState: () => import("@stream-io/video-client").CallingState;
/**
 * Utility hook providing the actual start time of the current session.
 * Useful for calculating the call duration.
 */
export declare const useCallStartedAt: () => Date | undefined;
/**
 * A hook which provides a list of all participants that have joined an active call.
 *
 * @param options.sortBy - A comparator function to sort the participants by.
 * Make sure to memoize output of the `combineComparators` function
 * (or keep it out of component's scope if possible) before passing it down to this property.
 */
export declare const useParticipants: ({ sortBy, }?: {
    /**
     * Make sure to memoize output of the `combineComparators` function
     * (or keep it out of component's scope if possible) before passing it down to this property.
     */
    sortBy?: Comparator<StreamVideoParticipant>;
}) => StreamVideoParticipant[];
/**
 * A hook which provides a list of all participants that have joined an active call.
 * Unlike `useParticipants`, it returns a more stable reference that is not affected
 * by participant sort settings.
 *
 * @category Call State
 */
export declare const useRawParticipants: () => StreamVideoParticipant[];
/**
 * A hook which provides a StreamVideoLocalParticipant object.
 * It signals that I have joined a call.
 */
export declare const useLocalParticipant: () => StreamVideoParticipant | undefined;
/**
 * A hook which provides a list of all other participants than me that have joined an active call.
 */
export declare const useRemoteParticipants: () => StreamVideoParticipant[];
/**
 * A hook which provides a list of participants that are currently pinned.
 */
export declare const usePinnedParticipants: () => StreamVideoParticipant[];
/**
 * Returns the approximate participant count of the active call.
 * This includes the anonymous users as well, and it is computed on the server.
 */
export declare const useParticipantCount: () => number;
/**
 * Returns the approximate anonymous participant count of the active call.
 * The regular participants are not included in this count. It is computed on the server.
 */
export declare const useAnonymousParticipantCount: () => number;
/**
 * Returns the generated thumbnail of the current call, if enabled in settings.
 */
export declare const useCallThumbnail: () => import("@stream-io/video-client").ThumbnailResponse | undefined;
/**
 * A hook which returns the local participant's own capabilities.
 */
export declare const useOwnCapabilities: () => OwnCapability[] | undefined;
/**
 * Hook that returns true if the local participant has all the given permissions.
 *
 * @param permissions the permissions to check.
 */
export declare const useHasPermissions: (...permissions: OwnCapability[]) => boolean;
/**
 * Returns the camera state of the current call.
 */
export declare const useCameraState: ({ optimisticUpdates, }?: UseInputMediaDeviceOptions) => {
    status: InputDeviceStatus;
    optimisticStatus: InputDeviceStatus;
    isEnabled: boolean;
    isMute: boolean;
    optimisticIsMute: boolean;
    isTogglePending: boolean;
    /**
     * If optimistic updates are enabled (`options.optimisticUpdates`), we
     * consider the optimistic status to determine whether the device is muted or not.
     * Otherwise, we rely on the actual status.
     */
    optionsAwareIsMute: boolean;
    camera: import("@stream-io/video-client").CameraManager;
    direction: import("@stream-io/video-client").CameraDirection;
    mediaStream: MediaStream | undefined;
    rootMediaStream: MediaStream | undefined;
    devices: MediaDeviceInfo[];
    hasBrowserPermission: boolean;
    isPromptingPermission: boolean;
    selectedDevice: string | undefined;
};
/**
 * Returns the microphone state of the current call.
 */
export declare const useMicrophoneState: ({ optimisticUpdates, }?: UseInputMediaDeviceOptions) => {
    status: InputDeviceStatus;
    optimisticStatus: InputDeviceStatus;
    isEnabled: boolean;
    isMute: boolean;
    optimisticIsMute: boolean;
    isTogglePending: boolean;
    /**
     * If optimistic updates are enabled (`options.optimisticUpdates`), we
     * consider the optimistic status to determine whether the device is muted or not.
     * Otherwise, we rely on the actual status.
     */
    optionsAwareIsMute: boolean;
    microphone: import("@stream-io/video-client").MicrophoneManager;
    mediaStream: MediaStream | undefined;
    devices: MediaDeviceInfo[];
    selectedDevice: string | undefined;
    hasBrowserPermission: boolean;
    isPromptingPermission: boolean;
    isSpeakingWhileMuted: boolean;
    audioBitrateProfile: import("@stream-io/video-client/dist/src/gen/video/sfu/models/models").AudioBitrateProfile;
};
/**
 * Returns the speaker state of the current call.
 *
 * Note: This hook is not supported in React Native
 */
export declare const useSpeakerState: () => {
    speaker: import("@stream-io/video-client").SpeakerManager;
    volume: number;
    readonly devices: MediaDeviceInfo[];
    selectedDevice: string;
    isDeviceSelectionSupported: boolean;
};
/**
 * Returns the Screen Share state of the current call.
 */
export declare const useScreenShareState: ({ optimisticUpdates, }?: UseInputMediaDeviceOptions) => {
    status: InputDeviceStatus;
    optimisticStatus: InputDeviceStatus;
    isEnabled: boolean;
    isMute: boolean;
    optimisticIsMute: boolean;
    isTogglePending: boolean;
    /**
     * If optimistic updates are enabled (`options.optimisticUpdates`), we
     * consider the optimistic status to determine whether the device is muted or not.
     * Otherwise, we rely on the actual status.
     */
    optionsAwareIsMute: boolean;
    screenShare: import("@stream-io/video-client").ScreenShareManager;
    mediaStream: MediaStream | undefined;
    audioBitrateProfile: import("@stream-io/video-client/dist/src/gen/video/sfu/models/models").AudioBitrateProfile;
};
/**
 * Returns incoming video settings for the current call, including
 * global and per-participant manual video quality overrides.
 */
export declare const useIncomingVideoSettings: () => {
    enabled: boolean;
    preferredResolution: import("@stream-io/video-client/dist/src/gen/video/sfu/models/models").VideoDimension | undefined;
    participants: {
        [k: string]: {
            enabled: boolean;
            preferredResolution: import("@stream-io/video-client/dist/src/gen/video/sfu/models/models").VideoDimension | undefined;
        };
    };
    isParticipantVideoEnabled: (sessionId: string) => boolean;
};
/**
 * Returns whether the browser's autoplay policy is blocking audio playback.
 *
 * When the browser blocks audio autoplay (e.g., no prior user interaction),
 * this hook returns `true`. Use `call.resumeAudio()` inside a click handler
 * to unblock audio playback. Returns `false` on React Native.
 */
export declare const useIsAutoplayBlocked: () => boolean;
/**
 * Returns the current call's closed captions queue.
 */
export declare const useCallClosedCaptions: () => CallClosedCaption[];
/**
 * Returns the current call's closed captions queue.
 */
export declare const useIsCallCaptioningInProgress: () => boolean;