import { IEventEmitter } from '@breadstone/mosaik-elements';
import { ICaptureEventDetail, IRecordEventDetail } from '../../../events';
import { CameraCaptureFormat } from '../../../Types/CameraCaptureFormat';
import { CameraRecorderFormat } from '../../../Types/CameraRecorderFormat';
import { CameraType } from '../../../Types/CameraType';
import { CustomElement } from '../../Abstracts/CustomElement';
import { CameraFrame } from './CameraFrame';
import { ICameraElementProps } from './ICameraElementProps';
declare const CameraElement_base: (abstract new (...args: Array<any>) => import("../../../Behaviors/Themeable").IThemeableProps) & (abstract new (...args: Array<any>) => import("../../../Behaviors/Disableable").IDisableableProps) & (abstract new (...args: Array<any>) => import("../../../Behaviors/Dimensionable").IDimensionableProps) & typeof CustomElement & import("../../../Behaviors/Themeable").IThemeableCtor;
/**
 * Camera - An input device that captures images or videos, allowing users to take photos or record footage directly within the application.
 *
 * @element mosaik-camera
 *
 * @slot underlay - The underlay slot.
 * @slot overlay - The overlay slot.
 *
 * @fires captured {CaptureEvent} - Raised when a image was captured.
 * @fires recorded {RecordEvent} - Raised when a video was recorded.
 *
 * @example
 * Basic camera with auto-play:
 * ```html
 * <mosaik-camera auto-play></mosaik-camera>
 * ```
 *
 * @example
 * Camera using back lens with jpeg capture format:
 * ```html
 * <mosaik-camera type="back" capture-format="jpeg"></mosaik-camera>
 * ```
 *
 * @public
 */
export declare class CameraElement extends CameraElement_base implements ICameraElementProps {
    private _videoElement;
    private readonly _captured;
    private readonly _recorded;
    private _type;
    private _recorderFormat;
    private _captureFormat;
    private _src;
    private _poster;
    private _autoPlay;
    private _autoFullScreen;
    private _isRecording;
    private _recorder;
    private _dataAvailableEventSubscription;
    private _frame;
    /**
     * @public
     */
    constructor();
    /**
     * Returns the `is` property.
     * The `is` property represents natural name of this element.
     *
     * @public
     * @static
     * @readonly
     */
    static get is(): string;
    /**
     * Gets or sets the `type` property.
     *
     * @public
     * @attr
     */
    get type(): CameraType;
    set type(value: CameraType);
    /**
     * Gets or sets the `recorderFormat` property.
     *
     * @public
     * @attr
     */
    get recorderFormat(): CameraRecorderFormat;
    set recorderFormat(value: CameraRecorderFormat);
    /**
     * Gets or sets the `captureFormat` property.
     *
     * @public
     * @attr
     */
    get captureFormat(): CameraCaptureFormat;
    set captureFormat(value: CameraCaptureFormat);
    /**
     * Gets or sets the `src` property.
     *
     * @public
     */
    get src(): string | MediaProvider | null;
    set src(value: string | MediaProvider | null);
    /**
     * Gets or sets the `poster` property.
     *
     * @public
     */
    get poster(): string;
    set poster(value: string);
    /**
     * Gets or sets the `autoPlay` property.
     *
     * @public
     * @attr
     */
    get autoPlay(): boolean;
    set autoPlay(value: boolean);
    /**
     * Gets or sets the `autoFullScreen` property.
     *
     * @public
     * @attr
     */
    get autoFullScreen(): boolean;
    set autoFullScreen(value: boolean);
    /**
     * A camera frame info object
     * When the camera frame is set, the camera will be displayed as a frame.
     * If a picture will captured, only the inner part of the frame will be captured.
     *
     * @public
     * @attr
     * @remarks
     * A frame can be defined as a string (*e.g.* `16:9`) or as an object (*e.g.* `{ width: 16, height: 9 }`).
     */
    get frame(): CameraFrame | null;
    set frame(value: CameraFrame | null);
    /**
     * Returns the `isSupported` property.
     *
     * @public
     * @readonly
     */
    get isSupported(): boolean;
    /**
     * Returns the `isSupported` property.
     *
     * @public
     * @readonly
     */
    get isRecorderSupported(): boolean;
    /**
     * Fires when a image was captured.
     * Provides reference to `ICaptureEventDetail` as event detail.
     *
     * @public
     * @readonly
     * @eventProperty
     */
    get captured(): IEventEmitter<ICaptureEventDetail>;
    /**
     * Fires when a video was recorded.
     * Provides reference to `IRecordEventDetail` as event detail.
     *
     * @public
     * @readonly
     * @eventProperty
     */
    get recorded(): IEventEmitter<IRecordEventDetail>;
    /**
     * @public
     * @override
     */
    disconnectedCallback(): void;
    /**
     * Record a stream of the current video element.
     *
     * @public
     */
    record(): void;
    /**
     * Captures a image of the current video element.
     *
     * @public
     */
    capture(): void;
    /**
     * @protected
     * @override
     */
    protected onApplyTemplate(): void;
    /**
     * Emits the `captured` event.
     *
     * @protected
     */
    protected onCaptured(args: ICaptureEventDetail): void;
    /**
     * Emits the `recorded` event.
     *
     * @protected
     */
    protected onRecorded(args: IRecordEventDetail): void;
    /**
     * @private
     */
    private load;
    /**
     * @private
     */
    private cameraTypeToFacingMode;
}
/**
 * @public
 */
export declare namespace CameraElement {
    type Props = ICameraElementProps;
}
/**
 * @public
 */
declare global {
    interface HTMLElementTagNameMap {
        'mosaik-camera': CameraElement;
    }
}
export {};
//# sourceMappingURL=CameraElement.d.ts.map