import * as lit from 'lit';
import { LitElement, CSSResult } from 'lit';
import { AnimationDirection, RendererType, AnimationSegment, AnimationItem } from 'lottie-web';
import { RefObject, CSSProperties } from 'react';

type BoolInt = 0 | 1;
interface Shape {
    a: ShapeData;
    o: ShapeData;
    p: ShapeData;
    r: ShapeData;
    s: ShapeData;
}
interface ShapeData {
    a: BoolInt;
    k: number | number[];
    ix: number;
}
interface Layer {
    ao: BoolInt;
    bm: number;
    completed: boolean;
    ddd: BoolInt;
    ip: number;
    ks: object;
    nm: string;
    op: number;
    shapes: Shape[];
    sr: number;
    st: number;
    td: number;
    ty: number;
}
interface LottieAsset {
    e?: BoolInt;
    layers?: Layer[];
    h?: number;
    id?: string;
    nm?: string;
    p?: string;
    u?: string;
    xt?: number;
    w?: number;
}
interface LottieJSON {
    assets?: LottieAsset[];
    ddd: BoolInt;
    fr: number;
    h: number;
    ip: number;
    layers: Layer[];
    markers: unknown[];
    meta: {
        a: string;
        d: string;
        g: string;
        k: string;
        tc: string;
    };
    nm: string;
    op: number;
    v: string;
    w: number;
}
interface AnimationSettings {
    autoplay?: Autoplay;
    loop?: Loop;
    direction?: AnimationDirection;
    mode?: PlayMode;
    speed?: number;
}
interface Animation extends AnimationSettings {
    id: string;
}
interface AnimationConfig extends Animation {
    url: string;
}
interface LottieManifest {
    animations: Animation[];
    author?: string;
    description?: string;
    generator?: string;
    keywords?: string;
    version?: string;
}
type AnimateOnScroll = boolean | '' | null;
type Autoplay = boolean | '' | 'autoplay' | null;
type Controls = boolean | '' | 'controls' | null;
type Loop = boolean | '' | 'loop' | null;
type Subframe = boolean | '' | null;
type ObjectFit = 'contain' | 'cover' | 'fill' | 'scale-down' | 'none';
type PreserveAspectRatio = 'xMidYMid meet' | 'xMidYMid slice' | 'xMinYMin slice' | 'none';
type JSXLottiePlayer = Omit<Partial<DotLottiePlayer>, 'style'> & {
    class?: string;
    ref?: RefObject<unknown>;
    style?: CSSProperties;
    src: string;
};
declare global {
    interface HTMLElementTagNameMap {
        'dotlottie-player': DotLottiePlayer;
    }
    function dotLottiePlayer(): DotLottiePlayer;
    namespace JSX {
        interface IntrinsicElements {
            'dotlottie-player': JSXLottiePlayer;
        }
    }
}

declare enum PlayerState {
    Completed = "completed",
    Destroyed = "destroyed",
    Error = "error",
    Frozen = "frozen",
    Loading = "loading",
    Paused = "paused",
    Playing = "playing",
    Stopped = "stopped"
}
declare enum PlayMode {
    Bounce = "bounce",
    Normal = "normal"
}
declare enum PlayerEvents {
    Complete = "complete",
    Destroyed = "destroyed",
    Error = "error",
    Frame = "frame",
    Freeze = "freeze",
    Load = "load",
    Loop = "loop",
    Next = "next",
    Pause = "pause",
    Play = "play",
    Previous = "previous",
    Ready = "ready",
    Rendered = "rendered",
    Stop = "stop"
}

declare class DotLottiePlayer extends LitElement {
    animateOnScroll?: AnimateOnScroll;
    autoplay?: Autoplay;
    background?: string;
    controls?: Controls;
    count?: number;
    currentState?: PlayerState;
    description?: string;
    direction?: AnimationDirection;
    hover?: boolean | undefined;
    intermission?: number | undefined;
    loop?: Loop;
    mode?: PlayMode;
    multiAnimationSettings?: AnimationSettings[];
    objectfit?: ObjectFit;
    preserveAspectRatio?: PreserveAspectRatio;
    renderer?: RendererType;
    segment?: AnimationSegment;
    simple?: boolean;
    speed?: number;
    src: string;
    subframe?: Subframe;
    protected container: HTMLElement;
    private _isSettingsOpen;
    private _seeker;
    private _currentAnimation;
    private _intersectionObserver?;
    private _lottieInstance;
    private _identifier;
    private _errorMessage;
    private _isBounce;
    private _isDotLottie;
    private _manifest;
    private _animations;
    private _playerState;
    private _getOptions;
    private _addIntersectionObserver;
    load(src: string | LottieJSON): Promise<void>;
    getManifest(): LottieManifest;
    private _addEventListeners;
    private _removeEventListeners;
    private _loopComplete;
    private _enterFrame;
    private _complete;
    private _DOMLoaded;
    private _dataReady;
    private _dataFailed;
    private _handleWindowBlur;
    private _mouseEnter;
    private _mouseLeave;
    private _onVisibilityChange;
    private _handleScroll;
    private _handleSeekChange;
    private _isLottie;
    addAnimation(configs: AnimationConfig[], fileName?: string, shouldDownload?: boolean): Promise<void | ArrayBuffer>;
    getLottie(): AnimationItem | null;
    play(): void;
    pause(): void;
    stop(): void;
    destroy(): void;
    seek(value: number | string): void;
    snapshot(): string | undefined;
    setSubframe(value: boolean): void;
    setCount(value: number): void;
    private _freeze;
    reload(): Promise<void>;
    setSpeed(value?: number): void;
    setDirection(value: AnimationDirection): void;
    setLooping(value: boolean): void;
    setMultiAnimationSettings(settings: AnimationSettings[]): void;
    togglePlay(): void;
    toggleLooping(): void;
    toggleBoomerang(): void;
    private _toggleSettings;
    private _handleSettingsClick;
    private _handleBlur;
    private _switchInstance;
    next(): void;
    prev(): void;
    convert({ typeCheck, manifest, animations, src, fileName, shouldDownload }: {
        typeCheck?: boolean;
        manifest?: LottieManifest;
        animations?: LottieJSON[];
        src?: string;
        fileName?: string;
        shouldDownload?: boolean;
    }): Promise<string | void | ArrayBuffer>;
    static get styles(): CSSResult;
    constructor();
    connectedCallback(): void;
    protected firstUpdated(): Promise<void>;
    disconnectedCallback(): void;
    protected renderControls(): lit.TemplateResult<1>;
    protected render(): lit.TemplateResult<1>;
}

export { DotLottiePlayer, PlayMode, PlayerEvents, PlayerState };