declare enum ArrayType {
    Float32 = "float32",
    Int16 = "int16",
    Int32 = "int32",
    Uint8 = "uint8",
    Uint8c = "uint8c"
}
declare enum PlayMode {
    Bounce = "bounce",
    Normal = "normal"
}
declare enum PlayerEvent {
    Active = "_active",
    Complete = "complete",
    ConfigError = "configError",
    ConfigReady = "config_ready",
    DataFailed = "data_failed",
    DataReady = "data_ready",
    Destroy = "destroy",
    Destroyed = "destroyed",
    DOMLoaded = "DOMLoaded",
    DrawnFrame = "drawnFrame",
    EnterFrame = "enterFrame",
    Error = "error",
    Frame = "frame",
    Freeze = "freeze",
    Idle = "_idle",
    Load = "load",
    LoadedImages = "loaded_images",
    Loop = "loop",
    LoopComplete = "loopComplete",
    MouseEnter = "mouseenter",
    MouseLeave = "mouseleave",
    Next = "next",
    Pause = "_pause",
    Play = "_play",
    Previous = "previous",
    Ready = "ready",
    Rendered = "rendered",
    RenderFrameError = "renderFrameError",
    SegmentStart = "segmentStart",
    Stop = "stop"
}
declare enum PreserveAspectRatio {
    Contain = "xMidYMid meet",
    Cover = "xMidYMid slice",
    Initial = "none",
    None = "xMinYMin slice"
}
declare enum RendererType {
    Canvas = "canvas",
    SVG = "svg"
}
declare enum ShapeType {
    Ellipse = "el",
    Fill = "fl",
    GradientFill = "gf",
    GradientStroke = "gs",
    Group = "gr",
    Merge = "mm",
    NoStyle = "no",
    OffsetPath = "op",
    Path = "sh",
    PolygonStar = "sr",
    PuckerBloat = "pb",
    Rectangle = "rc",
    Repeater = "rp",
    RoundedCorners = "rd",
    Stroke = "st",
    Transform = "tr",
    Trim = "tm",
    Twist = "tw",
    Unknown = "ms",
    ZigZag = "zz"
}
declare enum EffectTypes {
    TransformEffect = "transformEffect"
}
declare enum PropType {
    MultiDimensional = "multidimensiional",
    Shape = "shape",
    TextSelector = "textSelector",
    Transform = "transform",
    UniDimensional = "unidimensional"
}

type ParentPropertyGroup = LayerExpressionInterface | PropertyGroupFactory;
declare class PropertyGroupFactory {
    interfaceFunction: (val: string | number) => BaseProperty;
    parentPropertyGroup: ParentPropertyGroup;
    constructor(interfaceFunction: (val: number | string) => BaseProperty, parentPropertyGroup: ParentPropertyGroup);
    getInterface(val?: number): any;
}

declare class LetterProps {
    __complete?: boolean;
    _mdf: {
        fc: boolean;
        m: boolean;
        o: boolean;
        p: boolean;
        sc: boolean;
        sw: boolean;
    };
    fc?: string | number[] | undefined;
    m?: number | string | undefined;
    o?: number | undefined;
    p?: number | number[] | undefined;
    sc?: string | number[] | undefined;
    sw?: number | undefined;
    t?: string | undefined;
    constructor(o?: number, sw?: number, sc?: string, fc?: string, m?: number | string, p?: number | number[]);
    update(o: number, sw: number, sc?: string, fc?: string, m?: string, p?: number[]): boolean;
}

declare class TextProperty extends BaseProperty {
    _frameId: number;
    canResize: boolean;
    currentData: DocumentData;
    data: TextData;
    defaultBoxWidth: Vector2;
    effectsSequence: TextEffectFunction[];
    elem: ElementInterfaceIntersect;
    keysIndex: number;
    minimumFontSize: number;
    pv: DocumentData | string;
    v: DocumentData | string;
    constructor(elem: ElementInterfaceIntersect, data: TextData);
    addEffect(effectFunction: TextEffectFunction): void;
    buildFinalText(text: string): string[];
    calculateExpression(_text: string): number;
    canResizeFont(_canResize: boolean): void;
    completeTextData(documentData: DocumentData): void;
    copyData(obj: DocumentData, data: DocumentData | LetterProps): DocumentData;
    getExpressionValue(_currentValue: DocumentData, _text: string): void;
    getKeyframeValue(): DocumentData | LetterProps | undefined;
    getValue(_finalValue?: unknown): number;
    recalculate(index: number): void;
    searchExpressions(): boolean | null;
    searchKeyframes(): boolean;
    searchProperty(): boolean;
    setCurrentData(data: DocumentData): void;
    setMinimumFontSize(_fontValue: number): void;
    updateDocumentData(newData: DocumentData, indexFromProps?: number): void;
}

declare abstract class DynamicPropertyContainer {
    _isAnimated?: boolean;
    _mdf?: undefined | boolean;
    container?: ElementInterfaceIntersect | null;
    data?: DynamicProperty | Shape | TextProperty | TextData | TextRangeValue | VectorProperty<Keyframe[]> | GradientColor | Effect;
    dynamicProperties: DynamicPropertyContainer[];
    hd?: boolean;
    keyframes?: Keyframe[];
    propertyIndex?: undefined | number;
    propType?: PropType | false;
    addDynamicProperty(prop: DynamicPropertyContainer): void;
    getValue(_flag?: unknown): unknown;
    initDynamicPropertyContainer(container: ElementInterfaceIntersect): void;
    iterateDynamicProperties(): unknown;
    setGroupProperty(_propertyInterface: PropertyGroupFactory): void;
}

declare class GroupEffect extends DynamicPropertyContainer {
    data?: Effect;
    effectElements: EFXElement[];
    getValue: () => unknown;
    type?: string;
    constructor(data: Effect, element: ElementInterfaceIntersect, layer: LottieLayer);
    init(data: Effect, element: ElementInterfaceIntersect, layer: LottieLayer): void;
    renderFrame(_frame?: number | boolean): void;
}

declare class CVEffects {
    filters: GroupEffect[];
    constructor(elem: ElementInterfaceIntersect);
    getEffects(type: string): GroupEffect[];
    renderFrame(_isFirstFrame?: number | boolean): void;
}

declare class SVGEffects {
    filters: GroupEffect[];
    constructor(elem: ElementInterfaceIntersect);
    getEffects(type: EffectTypes): GroupEffect[];
    renderFrame(frame?: number | boolean): void;
}

declare class ShapeGroupData {
    _shouldRender?: boolean;
    closed?: boolean;
    gr: SVGGElement;
    it: ShapeDataInterface[];
    prevViewData: SVGElementInterface[];
    transform?: Transformer;
}

declare class ValueProperty<T extends number | number[] = number> extends BaseProperty {
    pv: T;
    v: T;
    constructor(elem: ElementInterfaceIntersect, data: VectorProperty, mult?: null | number, container?: ElementInterfaceIntersect | null);
}

declare class Matrix {
    props: Float32Array & {
        length: 16;
    };
    private _identity;
    private _identityCalculated;
    constructor();
    applyToPoint(x: number, y: number, z: number): {
        x: number;
        y: number;
        z: number;
    };
    applyToPointArray(x: number, y: number, z: number): number[];
    applyToPointStringified(x: number, y: number): string;
    applyToTriplePoints(pt1: number[], pt2: number[], pt3: number[]): Float32Array;
    applyToX(x: number, y: number, z: number): number;
    applyToY(x: number, y: number, z: number): number;
    applyToZ(x: number, y: number, z: number): number;
    clone(matr: Matrix): Matrix;
    cloneFromProps(props: Float32Array): this;
    equals(matr?: Matrix): boolean;
    getInverseMatrix(): Matrix;
    inversePoint(pt: number[]): {
        x: number;
        y: number;
        z: number;
    };
    inversePoints(pts: number[][]): {
        x: number;
        y: number;
        z: number;
    }[];
    isIdentity(): boolean;
    multiply(matrix: Matrix): this;
    reset(): this;
    rotate(angle?: number): this;
    rotateX(angle?: number): this;
    rotateY(angle?: number): this;
    rotateZ(angle?: number): this;
    scale(sx: number, sy: number, sz?: number): this;
    setTransform(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number): this;
    shear(sx: number, sy: number): this;
    skew(ax: number, ay: number): this;
    skewFromAxis(ax: number, angle: number): this;
    to2dCSS(): string;
    toCSS(): string;
    transform(a2: number, b2: number, c2: number, d2: number, e2: number, f2: number, g2: number, h2: number, i2: number, j2: number, k2: number, l2: number, m2: number, n2: number, o2: number, p2: number): this;
    translate(tx: number, ty: number, tzFromProps?: number): this;
    private _t;
    private roundMatrixProperty;
}

declare abstract class TransformEffect {
    _mdf?: boolean;
    _opMdf?: boolean;
    effectsManager?: GroupEffect;
    matrix?: Matrix;
    op?: ValueProperty;
    opacity: number;
    type?: string;
    init(effectsManager: GroupEffect): void;
    renderFrame(forceFrame?: boolean): void;
}

declare class SVGStyleData {
    _mdf: boolean;
    closed: boolean;
    coOp?: undefined | number;
    d: string;
    data: Shape;
    finalTransform?: undefined | Transformer;
    gr?: undefined | SVGGElement;
    grd?: undefined | CanvasGradient;
    hd?: undefined | boolean;
    it?: undefined | ShapeDataInterface[];
    lvl: number;
    msElem: null | SVGMaskElement | SVGPathElement;
    pElem: SVGPathElement;
    prevViewData?: undefined | SVGElementInterface[];
    pt?: undefined | VectorProperty;
    style?: undefined | SVGStyleData;
    t?: undefined | number;
    transform?: undefined | Transformer;
    ty?: undefined | ShapeType;
    type?: undefined | ShapeType;
    constructor(data: Shape, level: number);
    reset(): void;
}

declare class KeyframeValueProperty extends BaseProperty {
    pv: number | number[];
    selectorValue?: string;
    v: number;
    constructor(elem: ElementInterfaceIntersect, data: VectorProperty<Keyframe[]>, mult?: null | number, container?: ElementInterfaceIntersect | null);
}

declare class KeyframeMultidimensionalProperty<T extends number[] = Vector2> extends BaseProperty {
    pv: T;
    v: T;
    constructor(elem: ElementInterfaceIntersect, data: VectorProperty<Keyframe[]>, mult?: null | number, container?: ElementInterfaceIntersect | null);
}

declare class NoProperty extends BaseProperty {
    constructor();
}

declare function getProp<T = number | number[]>(elem: ElementInterfaceIntersect, dataFromProps?: VectorProperty<T> | ExpressionProperty, type?: number, mult?: null | number, container?: ElementInterfaceIntersect): ValueProperty<number> | KeyframeValueProperty | NoProperty | MultiDimensionalProperty<number[]> | KeyframeMultidimensionalProperty<[number, number]>;
declare const PropertyFactory: {
    getProp: typeof getProp;
};

declare class GradientProperty extends DynamicPropertyContainer {
    _cmdf: boolean;
    _collapsable: boolean;
    _hasOpacity: number;
    _omdf: boolean;
    c: Uint8ClampedArray;
    data: GradientColor;
    k?: boolean | undefined;
    o: Float32Array;
    prop: ReturnType<typeof PropertyFactory.getProp>;
    constructor(elem: ElementInterfaceIntersect, data: GradientColor, container: ElementInterfaceIntersect);
    checkCollapsable(): boolean;
    comparePoints(values: number[], points: number): boolean;
    getValue(forceRender?: boolean): number;
}

declare class SVGGradientFillStyleData extends DynamicPropertyContainer {
    a?: undefined | ValueProperty;
    cst: SVGStopElement[];
    e?: undefined | MultiDimensionalProperty;
    g?: undefined | GradientProperty;
    gf?: undefined | SVGGradientElement;
    gr?: undefined | SVGGElement;
    h?: undefined | KeyframeValueProperty;
    it: ShapeDataInterface[];
    maskId?: undefined | string;
    ms?: undefined | SVGMaskElement;
    o?: undefined | ValueProperty;
    of?: undefined | SVGElement;
    ost: SVGStopElement[];
    prevViewData: SVGElementInterface[];
    s?: undefined | MultiDimensionalProperty;
    stops: SVGStopElement[];
    style?: undefined | SVGStyleData;
    transform?: undefined | Transformer;
    constructor(elem: ElementInterfaceIntersect, data: Shape, styleData: SVGStyleData);
    initGradientData(elem: ElementInterfaceIntersect, data: Shape, styleData: SVGStyleData): void;
    setGradientData(pathElement: SVGElement, data: Shape): void;
    setGradientOpacity(data: Shape, styleData: SVGStyleData): void;
}

declare class SVGFillStyleData extends DynamicPropertyContainer {
    c?: undefined | MultiDimensionalProperty<Vector3>;
    gr?: undefined | SVGGElement;
    it: ShapeDataInterface[];
    o?: undefined | ValueProperty;
    prevViewData: SVGElementInterface[];
    style: SVGStyleData;
    transform?: undefined | Transformer;
    w?: undefined | ValueProperty;
    constructor(elem: ElementInterfaceIntersect, data: Shape, styleObj: SVGStyleData);
}

declare class ShapeTransformManager {
    sequenceList: TransformSequence[];
    sequences: TransformSequence;
    transform_key_count: number;
    addTransformSequence(transforms: {
        transform: Transformer;
    }[]): Transformer;
    getNewKey(): string;
    processSequence(sequence: TransformSequence, isFirstFrame?: number | boolean): void;
    processSequences(isFirstFrame?: number | boolean): void;
}

declare class CVShapeData extends ShapeData {
    constructor(element: CVShapeElement, data: Shape, styles: CVStyleElement[], transformsManager: ShapeTransformManager);
}

declare class ShapePath {
    _length: number;
    _maxLength: number;
    c: boolean;
    e?: ShapePath[];
    i: Vector2[];
    lengths: BezierLength[];
    o: Vector2[];
    s?: ShapePath[];
    v: Vector2[];
    get _type(): string;
    constructor();
    doubleArrayLength(): void;
    length(): number;
    setLength(len: number): void;
    setPathData(closed: boolean, len: number): void;
    setTripleAt(vX: number, vY: number, oX: number, oY: number, iX: number, iY: number, pos: number, replace?: boolean): void;
    setXYAt(x: number, y: number, type: string, pos: number, replace?: boolean): void;
    toReversed(): ShapePath;
}

declare class ShapeCollection {
    _length: number;
    _maxLength: number;
    shapes: ShapePath[];
    constructor();
    addShape(shapeData: ShapePath): void;
    releaseShapes(): void;
}

declare abstract class ShapeData {
    _isAnimated?: boolean;
    _length?: number;
    caches: string[];
    data?: SVGShapeData;
    gr?: SVGGElement;
    hd?: boolean;
    it: ShapeDataInterface[];
    last?: ShapeCollection;
    localShapeCollection?: ShapeCollection;
    lStr: string;
    lvl: number;
    pathsData: ShapePath[];
    prevViewData: SVGElementInterface[];
    sh: ShapeProperty | null;
    shape?: ShapeProperty;
    style?: SVGStyleData;
    styledShapes: CVShapeData[];
    styles: SVGStyleData[];
    tr: number[];
    transform?: Transformer;
    transformers: Transformer[];
    transforms?: {
        finalTransform: Matrix;
    };
    trNodes: TransformNode[];
    ty?: ShapeType;
    setAsAnimated(): void;
}

declare class SVGShapeData extends ShapeData {
    constructor(transformers: Transformer[], level: number, shape: ShapeProperty);
}

declare class SVGNoStyleData extends DynamicPropertyContainer {
    gr?: undefined | SVGGElement;
    it: ShapeDataInterface[];
    prevViewData: SVGElementInterface[];
    style: SVGStyleData;
    transform?: undefined | Transformer;
    constructor(elem: ElementInterfaceIntersect, _data: SVGShapeData, styleObj: SVGStyleData);
}

declare class DashProperty extends DynamicPropertyContainer {
    dashArray: Float32Array;
    dashoffset: Float32Array & {
        length: 1;
    };
    dashStr: string;
    dataProps: StrokeData[];
    elem: ElementInterfaceIntersect;
    frameId: number;
    k: boolean;
    renderer: RendererType;
    constructor(elem: ElementInterfaceIntersect, data: StrokeData[], renderer: RendererType, container: ElementInterfaceIntersect);
    getValue(forceRender?: boolean): number;
}

declare class SVGStrokeStyleData extends SVGFillStyleData {
    d?: DashProperty;
    constructor(elem: ElementInterfaceIntersect, data: Shape, styleObj: SVGStyleData);
}

declare class TransformProperty extends BaseProperty {
    _isDirty?: boolean;
    _opMdf?: boolean;
    _transformCachingAtTime?: {
        v: Matrix;
    };
    a?: MultiDimensionalProperty<number[]>;
    appliedTransformations: number;
    autoOriented?: boolean;
    data: Shape;
    elem: ElementInterfaceIntersect;
    o?: ValueProperty;
    opacity?: number;
    or?: MultiDimensionalProperty<Vector3>;
    p?: MultiDimensionalProperty<Vector3>;
    pre: Matrix;
    px?: ValueProperty;
    py?: ValueProperty;
    pz?: ValueProperty;
    r?: ValueProperty;
    rx?: ValueProperty;
    ry?: ValueProperty;
    rz?: ValueProperty;
    s?: MultiDimensionalProperty<Vector3>;
    sa?: ValueProperty;
    sk?: ValueProperty;
    v: Matrix;
    private defaultVector;
    constructor(elem: ElementInterfaceIntersect, data: Shape, container: ElementInterfaceIntersect | null);
    addDynamicProperty(prop: DynamicPropertyContainer): void;
    applyToMatrix(mat: Matrix): void;
    autoOrient(): void;
    getValue(forceRender?: boolean): number;
    precalculateMatrix(): void;
}

declare class SVGTransformData {
    _isAnimated: boolean;
    elements: ElementInterfaceIntersect[];
    gr?: SVGGElement;
    it?: ShapeDataInterface[];
    prevViewData?: SVGElementInterface[];
    style?: SVGStyleData;
    transform: Transformer;
    constructor(mProps: TransformProperty, op: ValueProperty, container: SVGGElement);
}

declare class OffsetPathModifier extends ShapeModifier {
    amount?: ValueProperty;
    lineJoin?: number | undefined;
    miterLimit?: ValueProperty;
    initModifierProperties(elem: ElementInterfaceIntersect, data: Shape): void;
    processPath(inputBezier: ShapePath, amount: number, lineJoin: number, miterLimit: number): ShapePath;
    processShapes(_isFirstFrame: boolean): void;
}

declare class PuckerAndBloatModifier extends ShapeModifier {
    amount?: ValueProperty;
    initModifierProperties(elem: ElementInterfaceIntersect, data: Shape): void;
    processPath(path: ShapePath, amount: number): ShapePath;
    processShapes(_isFirstFrame: boolean): void;
}

declare class RepeaterModifier extends ShapeModifier {
    arr: Shape[];
    c?: ValueProperty;
    data?: Shape;
    elemsData: ShapeGroupData[];
    eo?: ValueProperty;
    matrix?: Matrix;
    o?: ValueProperty;
    pMatrix?: Matrix;
    pos?: number;
    rMatrix?: Matrix;
    sMatrix?: Matrix;
    so?: ValueProperty;
    tMatrix?: Matrix;
    tr?: TransformProperty;
    private _currentCopies?;
    private _elements;
    private _groups;
    addShapeToModifier(shapeData: ShapeProperty): void;
    applyTransforms(pMatrix: Matrix, rMatrix: Matrix, sMatrix: Matrix, transform: TransformProperty, perc: number, inv?: boolean): void;
    changeGroupRender(elements: Shape[], renderFlag?: boolean): void;
    cloneElements(elements: Shape[]): Shape[];
    init(elem: ElementInterfaceIntersect, arr: Shape | Shape[], posFromProps?: number, elemsData?: ShapeGroupData[]): void;
    initModifierProperties(elem: ElementInterfaceIntersect, data: Shape): void;
    processShapes(_isFirstFrame: boolean): boolean;
    resetElements(elements: Shape[]): void;
}

declare class RoundCornersModifier extends ShapeModifier {
    rd?: ValueProperty;
    initModifierProperties(elem: ElementInterfaceIntersect, data: Shape): void;
    processPath(path: ShapePath, round: number): ShapePath;
    processShapes(_isFirstFrame: boolean): void;
}

declare class TrimModifier extends ShapeModifier {
    e?: ValueProperty;
    eValue?: number;
    m?: Shape['m'];
    o?: ValueProperty;
    s?: ValueProperty;
    sValue?: number;
    addPaths(newPaths: ShapePath[], localShapeCollection: ShapeCollection): void;
    addSegment(pt1: Vector2, pt2: Vector2, pt3: Vector2, pt4: Vector2, shapePath: ShapePath, pos: number, isNewShape?: boolean): void;
    addSegmentFromArray(points: number[], shapePath: ShapePath, pos: number, isNewShape?: boolean): void;
    addShapes(shapeData: ShapeProperty, shapeSegment: {
        e: number;
        s: number;
    }, shapePathFromProps?: ShapePath): ShapePath[];
    addShapeToModifier(shapeData: ShapeProperty): void;
    calculateShapeEdges(s: number, e: number, shapeLength: number, addedLength: number, totalModifierLength: number): number[][];
    initModifierProperties(elem: ElementInterfaceIntersect, data: Shape): void;
    processShapes(_isFirstFrame: boolean): void;
    releasePathsData(pathsData: ShapePath[]): ShapePath[];
}

declare class ZigZagModifier extends ShapeModifier {
    amplitude?: ValueProperty;
    frequency?: ValueProperty;
    pointsType?: ValueProperty;
    initModifierProperties(elem: ElementInterfaceIntersect, data: Shape): void;
    processPath(path: ShapePath, amplitude: number, frequency: number, pointType: number): ShapePath;
    processShapes(_isFirstFrame: boolean): void;
}

declare class ShapeModifier extends DynamicPropertyContainer {
    closed?: boolean;
    elem?: ElementInterfaceIntersect;
    frameId?: number | undefined;
    k?: boolean;
    shapes: ShapeProperty[];
    addShape(data: SVGShapeData | CVShapeData): void;
    addShapeToModifier(_shapeData: ShapeProperty): void;
    init(elem: ElementInterfaceIntersect, data: Shape | Shape[], _posFromProps?: number, _elemsData?: ShapeGroupData[]): void;
    initModifierProperties(_elem: ElementInterfaceIntersect, _data: Shape | Shape[]): void;
    isAnimatedWithShape(_data: Shape): boolean;
    processKeys(): number;
}

type ShapeModifierInterface = TrimModifier | PuckerAndBloatModifier | RepeaterModifier | ZigZagModifier | OffsetPathModifier;

declare abstract class RenderableDOMElement extends RenderableElement {
    innerElem: SVGGraphicsElement | HTMLElement | null;
    abstract createContainerElements(): void;
    abstract createContent(): void;
    abstract createRenderableComponents(): void;
    destroy(): void;
    abstract destroyBaseElement(): void;
    hide(): void;
    initElement(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface): void;
    abstract initRendererElement(): void;
    prepareFrame(num: number): void;
    abstract renderElement(): void;
    renderFrame(_val?: number): void;
    abstract renderInnerContent(): void;
    show(): void;
}

declare class ProcessedElement {
    elem: ElementInterfaceIntersect;
    pos: number;
    constructor(element: ElementInterfaceIntersect, position: number);
}

declare abstract class ShapeElement extends RenderableDOMElement {
    _length?: number;
    processedElements: ProcessedElement[];
    shapeModifiers: ShapeModifierInterface[];
    shapes: (SVGShapeData | CVShapeData)[];
    addProcessedElement(elem: ElementInterfaceIntersect, pos: number): void;
    addShapeToModifiers(data: SVGShapeData | CVShapeData): void;
    isShapeInAnimatedModifiers(data: Shape): boolean;
    prepareFrame(num: number): void;
    renderModifiers(): void;
    searchProcessedElement(elem: unknown): number;
}

declare abstract class SVGBaseElement extends RenderableDOMElement {
    _sizeChanged?: boolean;
    maskedElement?: HTMLElement | SVGGElement;
    matteElement?: SVGGElement;
    matteMasks?: {
        [key: number]: string;
    };
    transformedElement?: HTMLElement | SVGGElement;
    createContainerElements(): void;
    createRenderableComponents(): void;
    destroyBaseElement(): void;
    getBaseElement(): SVGElement | HTMLElement | null;
    getMatte(matteType?: number): string;
    initRendererElement(): void;
    renderElement(): void;
    setMatte(id: string): void;
}

declare const baseMethods$1: readonly ["createContainerElements", "createRenderableComponents", "destroyBaseElement", "getBaseElement", "getMatte", "initRendererElement", "renderElement", "setMatte"];
interface SVGShapeElement extends Pick<SVGBaseElement, typeof baseMethods$1[number]> {
}
declare class SVGShapeElement extends ShapeElement {
    _debug?: boolean;
    animatedContents: AnimatedContent[];
    identityMatrix: Matrix;
    prevViewData: SVGElementInterface[];
    stylesList: SVGStyleData[];
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    addToAnimatedContents(data: Shape, element: SVGElementInterface): void;
    buildExpressionInterface(): void;
    createContent(): void;
    createGroupElement(data: Shape): ShapeGroupData;
    createShapeElement(data: Shape, ownTransformers: Transformer[], level: number): SVGShapeData;
    createStyleElement(data: Shape, level: number): SVGFillStyleData | SVGStrokeStyleData | SVGNoStyleData | SVGGradientFillStyleData | null;
    createTransformElement(data: Shape, container: SVGGElement): SVGTransformData;
    destroy(): void;
    filterUniqueShapes(): void;
    initSecondaryElement(): void;
    reloadShapes(): void;
    renderInnerContent(): void;
    renderShape(): void;
    searchShapes(arr: Shape[], itemsData: SVGElementInterface[], prevViewData: SVGElementInterface[], container: SVGGElement, level: number, transformers: Transformer[], shouldRenderFromProps: boolean): void;
    setElementStyles(elementData: SVGShapeData): void;
    setShapesAsAnimated(shapes: ShapeDataInterface[]): void;
}

declare class ShapeProperty extends ShapeBaseProperty {
    ix?: number;
    shape?: {
        _mdf?: boolean;
        paths?: undefined | {
            shapes: ShapePath[];
            _length: number;
        };
    };
    totalShapeLength?: number;
    x?: boolean;
    constructor(elem: SVGShapeElement | CVShapeElement, data: Shape, type: number);
}
declare class KeyframeShapeProperty extends ShapeBaseProperty {
    lastFrame: number;
    constructor(elem: SVGShapeElement | CVShapeElement, data: Shape, type: number);
}

declare class CVShapeElement extends ShapeElement {
    canvasContext?: CanvasRenderingContext2D;
    dashResetter: number[];
    prevViewData: ShapeGroupData[];
    stylesList: CVStyleElement[];
    transformHelper: Transformer;
    transformsManager: ShapeTransformManager;
    constructor(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface);
    addTransformToStyleList(transform: Transformer): void;
    closeStyles(styles: CVStyleElement[]): void;
    createContent(): void;
    createGroupElement(_data?: Shape): {
        it: never[];
        prevViewData: never[];
    };
    createShapeElement(data: Shape): CVShapeData;
    createStyleElement(data: Shape, transforms: {
        transform: Transformer;
    }[]): CVElement | null;
    createTransformElement(data: Shape): {
        transform: Transformer;
    };
    destroy(): void;
    drawLayer(): void;
    reloadShapes(): void;
    removeTransformFromStyleList(): void;
    renderFill(_styleData: any, itemData: CanvasItem, groupTransform: TransformEffect): void;
    renderGradientFill(styleData: Shape, itemData: SVGGradientFillStyleData, groupTransform: TransformEffect): void;
    renderInnerContent(): void;
    renderPath(pathData: Shape, itemData: CVShapeData): void;
    renderShape(parentTransform: Transformer, items: Shape[], data: ShapeGroupData[], isMain?: boolean): void;
    renderShapeTransform(parentTransform: Transformer, groupTransform: Transformer): void;
    renderStroke(_styleData: Shape, itemData: CanvasItem, groupTransform: TransformEffect): void;
    renderStyledShape(styledShape: CVShapeData, shape: ShapeProperty): void;
    searchShapes(arr: Shape[], itemsData: CanvasItem[], prevViewData: CVShapeElement[], shouldRenderFromProps: boolean, transforms: Transformer[]): void;
}

declare abstract class ShapeBaseProperty extends DynamicPropertyContainer {
    _caching?: Caching;
    _cachingAtTime?: Caching;
    comp?: CompElementInterface | undefined;
    data?: Shape;
    effectsSequence: ((arg: unknown) => ShapePath | undefined)[];
    elem?: SVGShapeElement | CVShapeElement;
    frameId?: number;
    k?: boolean;
    keyframesMetadata: KeyframesMetadata[];
    kf?: boolean;
    localShapeCollection?: ShapeCollection;
    lock?: boolean;
    offsetTime: number;
    p?: MultiDimensionalProperty | ValueProperty;
    paths?: ShapePath[] | ShapeCollection | undefined;
    pathsData: ShapePath[];
    pv?: ShapePath;
    ty?: ShapeType;
    v?: ShapePath;
    getValueAtTime(_frameNumFromProps: number, _num?: number): ShapePath | null;
    initiateExpression(_elem: ElementInterfaceIntersect, _data: ExpressionProperty, _property: KeyframeValueProperty): void;
    interpolateShape(frameNum: number, previousValue: ShapePath, caching?: Caching): void;
    interpolateShapeCurrentTime(): ShapePath | undefined;
    processEffectsSequence(_val?: unknown): number;
    reset(): void;
    setVValue(newPath?: ShapePath): void;
    shapesEqual(shape1: ShapePath, shape2: ShapePath): boolean;
}

declare class StarShapeProperty extends ShapeBaseProperty {
    d?: StrokeData[];
    ir?: ValueProperty;
    is?: ValueProperty;
    or: ValueProperty;
    os: ValueProperty;
    pt: ValueProperty;
    r: ValueProperty;
    s?: ValueProperty;
    constructor(elem: ElementInterfaceIntersect, data: Shape);
    convertPolygonToPath(): void;
    convertStarToPath(): void;
    convertToPath(): void;
    getValue(_val?: unknown): number;
}

declare class EllShapeProperty extends ShapeBaseProperty {
    _cPoint: number;
    d?: number;
    s: MultiDimensionalProperty;
    constructor(elem: ElementInterfaceIntersect, data: Shape);
    convertEllToPath(): void;
    getValue(_flag?: boolean): number;
}

declare class RectShapeProperty extends ShapeBaseProperty {
    d?: number;
    ir?: ValueProperty;
    is?: ValueProperty;
    or?: ValueProperty;
    os?: ValueProperty;
    pt?: ValueProperty;
    r: ValueProperty;
    s: MultiDimensionalProperty;
    constructor(elem: ElementInterfaceIntersect, data: Shape);
    convertRectToPath(): void;
    getValue(): number;
}

declare class MaskElement {
    data: LottieLayer;
    element: ElementInterfaceIntersect;
    globalData: GlobalData;
    maskElement: SVGElement | null;
    masksProperties: Shape[];
    solidPath: string;
    storedData: StoredData[];
    viewData: ViewData[];
    private _identityMat;
    constructor(data: LottieLayer, element: ElementInterfaceIntersect, globalData: GlobalData);
    createLayerSolidPath(): string;
    destroy(): void;
    drawPath(pathData: null | Shape, pathNodes: ShapePath, viewData: ViewData): void;
    getMaskelement(): SVGElement | null;
    getMaskProperty(pos: number): ShapeProperty | KeyframeShapeProperty | RectShapeProperty | EllShapeProperty | StarShapeProperty | null;
    renderFrame(frame?: number | null): void;
}

declare class CompExpressionInterface {
    _name?: undefined | string;
    comp: CompElementInterface;
    displayStartTime: number;
    frameDuration: number;
    height?: undefined | number;
    layer: CompExpressionInterface;
    numLayers?: undefined | number;
    pixelAspect: number;
    width?: undefined | number;
    constructor(comp: CompElementInterface);
    getInterface(name?: string | number | number[]): LayerExpressionInterface | null;
}

declare abstract class EffectZero {
    p?: ValueProperty;
    constructor(data: EffectValue, elem: ElementInterfaceIntersect, container: GroupEffect);
}
declare abstract class EffectOne {
    p?: ValueProperty;
    constructor(data: EffectValue, elem: ElementInterfaceIntersect, container: GroupEffect);
}
declare class SliderEffect extends EffectZero {
}
declare class AngleEffect extends EffectZero {
}
declare class ColorEffect extends EffectOne {
}
declare class PointEffect extends EffectOne {
}
declare class LayerIndexEffect extends EffectZero {
}
declare class MaskIndexEffect extends EffectZero {
}
declare class CheckboxEffect extends EffectZero {
}
declare class NoValueEffect {
    p: {};
}

declare class EffectsManager {
    _mdf?: boolean;
    effectElements: EffectInterface[];
    constructor(data: LottieLayer, element: ElementInterfaceIntersect, _dynamicProperties?: DynamicPropertyContainer[]);
}
type EffectInterface = GroupEffect | EffectsManager | SliderEffect | AngleEffect | ColorEffect | PointEffect | CheckboxEffect | LayerIndexEffect | MaskIndexEffect | NoValueEffect;

declare abstract class BaseElement {
    baseElement: null | HTMLElement | SVGGElement;
    comp?: CompElementInterface;
    compInterface?: CompExpressionInterface;
    data?: LottieLayer;
    dynamicProperties: DynamicPropertyContainer[];
    effectsManager?: EffectsManager;
    finalTransform?: Transformer;
    frameDuration: number;
    globalData?: GlobalData;
    itemsData: ShapeGroupData[];
    layerElement: null | SVGGElement | HTMLElement;
    layerId?: string;
    layerInterface?: null | LayerExpressionInterface;
    maskManager?: MaskElement | CVMaskElement;
    renderedFrame: number;
    shapesData: Shape[];
    type?: unknown;
    checkMasks(): boolean;
    destroy(): void;
    getBaseElement(): SVGElement | HTMLElement | null;
    getType(): unknown;
    initBaseData(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface): void;
    initExpressions(): void;
    setBlendMode(): void;
    sourceRectAtTime(): SourceRect | null;
}

declare abstract class TransformElement extends BaseElement {
    _isFirstFrame: boolean | number;
    hierarchy: ElementInterfaceIntersect[];
    localTransforms: null | Transformer[];
    mHelper: Matrix;
    renderableEffectsManager?: SVGEffects;
    globalToLocal(point: Vector3): [number, number, number];
    initTransform(): void;
    renderLocalTransform(): void;
    renderTransform(): void;
    searchEffectTransforms(): void;
}

declare abstract class HierarchyElement extends TransformElement {
    _isParent: boolean;
    checkParenting(): void;
    initHierarchy(): void;
    setAsParent(): void;
    setHierarchy(hierarchy: ElementInterfaceIntersect[]): void;
}

declare abstract class FrameElement extends HierarchyElement {
    _mdf: boolean;
    displayStartTime: number;
    addDynamicProperty(prop: DynamicPropertyContainer): void;
    initFrame(): void;
    prepareProperties(_number: number, isVisible?: boolean): void;
}

declare abstract class RenderableElement extends FrameElement {
    hidden: boolean;
    isInRange: boolean;
    isTransparent: boolean;
    renderableComponents: RenderableComponent[];
    addRenderableComponent(component: RenderableComponent): void;
    checkLayerLimits(num: number): void;
    checkTransparency(): void;
    getLayerSize(): {
        h: number;
        w: number;
    };
    hide(): void;
    initRenderable(): void;
    prepareRenderableFrame(num: number, _?: boolean): void;
    removeRenderableComponent(component: RenderableComponent): void;
    renderRenderable(): void;
    show(): void;
    sourceRectAtTime(): SourceRect | null;
}

declare abstract class CVBaseElement extends RenderableElement {
    buffers: (HTMLCanvasElement | OffscreenCanvas)[];
    canvasContext?: CanvasRenderingContext2D;
    currentTransform?: DOMMatrix;
    maskManager?: CVMaskElement;
    renderableEffectsManager?: CVEffects;
    transformCanvas?: TransformCanvas | undefined;
    transformEffects: GroupEffect[];
    clearCanvas(canvasContext?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null): void;
    createContainerElements(): void;
    createContent(): void;
    createRenderableComponents(): void;
    destroy(): void;
    exitLayer(): void;
    hideElement(): void;
    initRendererElement(): void;
    prepareLayer(): void;
    renderFrame(forceRender?: number): void;
    abstract renderInnerContent(): void;
    restoreIsolatedLayer(): void;
    setBlendMode(): void;
    showElement(): void;
}

declare class CVMaskElement {
    _isFirstFrame: number | boolean;
    data: LottieLayer;
    element: CVShapeElement | CVBaseElement;
    hasMasks: boolean;
    isSimple: boolean;
    masksProperties: Shape[];
    opacityData: ValueProperty[];
    viewData: ShapeProperty[];
    private maskBuffer;
    private pathBuffer;
    constructor(data: LottieLayer, element: CVShapeElement | CVBaseElement);
    applyMasks(): void;
    clipLocal(): void;
    destroy(): void;
    getMaskProperty(pos: number): ShapeProperty;
    renderFrame(_num?: number): void;
    private ensureBufferCtx;
    private firstActiveMode;
}

declare class GroupEffectInterface {
    effectElements: Effect[];
    effects: Effect[];
    get numProperties(): number;
    constructor(effects: Effect[], effectElements: Effect[]);
    getInterface(name: string | number): Effect | null;
}

declare class NumericValue {
    [index: number]: number;
    value: number;
    constructor(value: number);
    set(value: number): this;
    [Symbol.toPrimitive](hint: string): string | number;
    toExponential(...args: Parameters<number['toExponential']>): string;
    toFixed(...args: Parameters<number['toFixed']>): string;
    toJSON(): number;
    toLocaleString(...args: Parameters<number['toLocaleString']>): string;
    toPrecision(...args: Parameters<number['toPrecision']>): string;
    toString(...args: Parameters<number['toString']>): string;
    valueOf(): number;
}

declare class ShapePathInterface {
    _name?: undefined | string;
    ind?: undefined | number;
    ix?: undefined | number;
    mn?: undefined | string;
    prop: null | ShapeProperty;
    propertyGroup: LayerExpressionInterface;
    propertyIndex?: undefined | number;
    get path(): ShapeProperty | null;
    get shape(): ShapeProperty | null;
    constructor(shape: Shape, view: ShapeData, propertyGroup: LayerExpressionInterface);
    getInterface(val: string | number): ShapeProperty | null;
}

declare class ShapeExpressionInterface {
    _name: string;
    arr: never[];
    interfaces: ShapePathInterface[];
    numProperties: number;
    parentGroup: LayerExpressionInterface;
    propertyGroup: PropertyGroupFactory;
    constructor(shapes: Shape[], view: ShapeGroupData, propertyGroup: LayerExpressionInterface);
    contentsInterfaceFactory(shape: Shape, view: ShapeGroupData, propertyGroup: PropertyGroupFactory): (value: string | number) => ShapePathInterface | null;
    defaultInterfaceFactory(): () => null;
    ellipseInterfaceFactory(shape: Shape, view: SVGShapeData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    fillInterfaceFactory(shape: Shape, view: SVGFillStyleData, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    getInterface(valueFromProps?: string | number): PropertyGroupFactory;
    gradientFillInterfaceFactory(shape: Shape, view: SVGGradientFillStyleData, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    groupInterfaceFactory(shape: Shape, view: ShapeGroupData, propertyGroup: PropertyGroupFactory): (value: string | number) => Transformer | ((value: string | number) => ShapePathInterface | null) | undefined;
    iterateElements(shapes: null | Shape[], view: ShapeGroupData | ShapeGroupData[], propertyGroup: PropertyGroupFactory): ShapePathInterface[];
    parentGroupWrapper(): LayerExpressionInterface;
    rectInterfaceFactory(shape: Shape, view: SVGShapeData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    repeaterInterfaceFactory(shape: Shape, view: RepeaterModifier, propertyGroup: LayerExpressionInterface): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    roundedInterfaceFactory(shape: Shape, view: RoundCornersModifier, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    starInterfaceFactory(shape: Shape, view: ShapeData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    strokeInterfaceFactory(shape: Shape, view: SVGStrokeStyleData, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    transformInterfaceFactory(shape: Shape, view: SVGTransformData | SVGFillStyleData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    trimInterfaceFactory(shape: Shape, view: TrimModifier, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | null;
    private noOp;
}

declare class TextExpressionInterface {
    _sourceText?: {
        value: string;
        style?: {
            fillColor: string;
        };
    };
    elem: ElementInterfaceIntersect;
    get sourceText(): {
        value: string;
        style?: {
            fillColor: string;
        };
    };
    constructor(elem: ElementInterfaceIntersect);
    getInterface(name: string): {
        value: string;
        style?: {
            fillColor: string;
        };
    } | null;
}

declare class MaskInterface {
    _data: Shape;
    _mask: ViewData;
    get maskOpacity(): number;
    get maskPath(): ShapeProperty | KeyframeShapeProperty | RectShapeProperty | EllShapeProperty | StarShapeProperty | null;
    constructor(mask: ViewData, data: Shape);
}
declare class MaskManagerInterface {
    _masksInterfaces: MaskInterface[];
    maskManager: MaskElement | CVMaskElement;
    constructor(maskManager: MaskElement | CVMaskElement, _elem?: ElementInterfaceIntersect);
    getInterface(name: string): MaskInterface | null;
}

declare class TransformExpressionInterface {
    transform: TransformProperty;
    get anchorPoint(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get opacity(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get orientation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get position(): Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | NumericValue | {
        mult: number;
        pv: number;
        v: number;
    } | (number | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[] | NumericValue | {
        mult: number;
        pv: number;
        v: number;
    } | undefined)[] | undefined;
    get rotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get scale(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get skew(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get skewAxis(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get xPosition(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get xRotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get yPosition(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get yRotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get zPosition(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    get zRotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]);
    private _px;
    private _py;
    private _pz;
    private _transformFactory;
    constructor(transform: TransformProperty);
    getInterface(name: string | number): Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | NumericValue | (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => NumericValue) | (() => Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[]) | {
        mult: number;
        pv: number;
        v: number;
    } | (number | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | number[] | NumericValue | {
        mult: number;
        pv: number;
        v: number;
    } | undefined)[] | null | undefined;
}

declare class LayerExpressionInterface {
    _elem: ElementInterfaceIntersect;
    _name?: undefined | string;
    anchor_point: ExpressionInterface;
    anchorPoint: ExpressionInterface;
    content?: ShapeExpressionInterface;
    effect: ExpressionInterface;
    height?: undefined | number;
    index?: undefined | number;
    inPoint: number;
    mask?: undefined | MaskManagerInterface;
    opacity: ExpressionInterface;
    outPoint: number;
    position: ExpressionInterface;
    rotation: ExpressionInterface;
    scale: ExpressionInterface;
    shapeInterface?: ShapeExpressionInterface;
    source?: undefined | string;
    sourceRectAtTime: () => SourceRect | null;
    startTime: number;
    text?: TextExpressionInterface;
    textInterface?: TextExpressionInterface;
    transformInterface: TransformExpressionInterface;
    width?: undefined | number;
    get active(): boolean;
    get hasParent(): boolean;
    get parent(): LayerExpressionInterface | null;
    get transform(): TransformExpressionInterface;
    constructor(elem: ElementInterfaceIntersect);
    applyPoint(matrix: Matrix, arr: number[]): number[];
    fromComp(arr: number[]): {
        x: number;
        y: number;
        z: number;
    };
    fromWorld(arr: number[], time: number): {
        x: number;
        y: number;
        z: number;
    };
    fromWorldVec(arr: number[], time: number): {
        x: number;
        y: number;
        z: number;
    };
    getInterface(name: string | number): unknown;
    getMatrix(time?: number): Matrix;
    invertPoint(matrix: Matrix, arr: number[]): {
        x: number;
        y: number;
        z: number;
    };
    registerEffectsInterface(effects: null | GroupEffectInterface): void;
    registerMaskInterface(maskManager: MaskElement | CVMaskElement): void;
    sampleImage(): number[];
    toComp(_arr: number[], _time: number): void;
    toWorld(arr: number[], time: number): number[];
    toWorldVec(arr: number[], time?: number): number[];
}

declare abstract class BaseProperty extends DynamicPropertyContainer {
    _caching?: Caching;
    _cachingAtTime?: Caching;
    _isFirstFrame: number | boolean;
    _name?: string;
    _placeholder?: boolean;
    comp?: undefined | CompElementInterface;
    e?: ValueProperty | {
        v: number;
    };
    effectsSequence: EffectFunction[];
    elem?: ElementInterfaceIntersect;
    frameExpressionId?: number;
    frameId?: undefined | number;
    g?: unknown;
    initFrame: number;
    k?: boolean;
    keyframesMetadata: KeyframesMetadata[];
    kf?: boolean | null;
    lock?: boolean;
    loopIn?: (type: string, duration: number, durationFlag?: boolean) => void;
    loopOut?: (type: string, duration: number, durationFlag?: boolean) => void;
    mult?: number;
    numKeys?: number;
    offsetTime: number;
    propertyGroup?: undefined | LayerExpressionInterface;
    pv?: string | number | number[] | DocumentData | ShapePath;
    s?: ValueProperty | MultiDimensionalProperty<Vector3>;
    sh?: Shape;
    smooth?: (width: number, samples: number) => void;
    textIndex?: number;
    textTotal?: number;
    v?: string | number | number[] | Matrix | DocumentData | ShapePath;
    value?: number | number[];
    vel?: number | number[];
    x?: boolean;
    addEffect(effectFunction: EffectFunction): void;
    getSpeedAtTime(_frameNum: number): void;
    getValueAtCurrentTime(): string | number | number[] | ShapePath | DocumentData | undefined;
    getValueAtTime(_val1?: unknown, _val2?: unknown): unknown;
    getVelocityAtTime(_frameNum: number): number | number[];
    initiateExpression(_elem: ElementInterfaceIntersect, _data: ExpressionProperty, _property: KeyframeValueProperty): EffectFunction;
    interpolateValue(frameNum: number, caching?: Caching): [number, number, number];
    processEffectsSequence(): number;
    setVValue(val?: number | number[] | Keyframe[] | ShapePath): void;
    speedAtTime(_frameNum: number): void;
    valueAtTime(_a: number, _b?: number): void;
    velocityAtTime(_frameNum: number): void;
}

declare class MultiDimensionalProperty<T extends number[] = Vector2> extends BaseProperty {
    v: T;
    constructor(elem: ElementInterfaceIntersect, data: VectorProperty<T>, mult?: null | number, container?: ElementInterfaceIntersect | null);
}

declare class AudioElement extends RenderableElement {
    assetData: null | LottieAsset;
    audio: Audio;
    lv: MultiDimensionalProperty;
    tm: ValueProperty;
    private _canPlay;
    private _currentTime;
    private _isPlaying;
    private _previousVolume;
    private _volume;
    private _volumeMultiplier;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    getBaseElement(): null;
    hide(): void;
    initExpressions(): void;
    pause(): void;
    prepareFrame(num: number): void;
    renderFrame(_val?: number): void;
    resume(): void;
    setRate(rateValue: number): void;
    show(): void;
    sourceRectAtTime(): null;
    volume(volumeValue: number): void;
}

declare class AudioController {
    audioFactory?: undefined | AudioFactory;
    audios: AudioElement[];
    isPlaying?: boolean;
    private _isMuted;
    private _volume;
    constructor(audioFactory?: AudioFactory);
    addAudio(audio: AudioElement): void;
    createAudio(assetPath?: string): any;
    getVolume(): number;
    mute(): void;
    pause(): void;
    resume(): void;
    setAudioFactory(audioFactory: AudioFactory): void;
    setRate(rateValue: number): void;
    setVolume(value: number): void;
    unmute(): void;
    private _updateVolume;
}

declare abstract class CompElement extends RenderableDOMElement {
    completeLayers?: boolean;
    currentFrame: number;
    elements: ElementInterfaceIntersect[];
    layers: LottieLayer[];
    tm?: ValueProperty;
    abstract buildAllItems(): void;
    abstract checkLayers(frame?: number): void;
    createContent(): void;
    destroy(): void;
    destroyElements(): void;
    getElements(): ElementInterfaceIntersect[] | undefined;
    initElement(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface): void;
    prepareFrame(val: number): void;
    renderInnerContent(): void;
    setElements(elements: ElementInterfaceIntersect[]): void;
}

declare class CanvasContext {
    fillStyle: string;
    id: number;
    lineCap: string;
    lineJoin: string;
    lineWidth: number | string;
    miterLimit: number | string;
    opacity: number;
    strokeStyle: string;
    transform: Tuple<number, 16>;
    constructor();
}
declare class CVContextData {
    _length: number;
    appliedFillStyle: string;
    appliedLineCap: string;
    appliedLineJoin: string;
    appliedLineWidth: string | number;
    appliedMiterLimit: string | number;
    appliedStrokeStyle: string;
    cArrPos: number;
    cTr: Matrix;
    currentFillStyle: string;
    currentLineCap: string;
    currentLineJoin: string;
    currentLineWidth: string | number;
    currentMiterLimit: string | number;
    currentOpacity: number;
    currentStrokeStyle: string;
    nativeContext: null | CanvasRenderingContext2D;
    stack: CanvasContext[];
    transformMat: Matrix;
    constructor();
    duplicate(): void;
    fill(rule: CanvasFillRule): void;
    fillRect(x: number, y: number, w: number, h: number): void;
    fillStyle(value: string): void;
    lineCap(value: string): void;
    lineJoin(value: string): void;
    lineWidth(value: number): void;
    miterLimit(value: number): void;
    opacity(op: number): void;
    reset(): void;
    restore(forceRestore?: boolean): void;
    save(saveOnNativeFlag?: boolean): void;
    setContext(value?: null | CanvasRenderingContext2D): void;
    setOpacity(value: number): void;
    stroke(): void;
    strokeStyle(value: string): void;
    transform(props: Float32Array): void;
}

declare class ImageElement extends SVGBaseElement {
    assetData?: undefined | LottieAsset | null;
    layers: LottieLayer[];
    sourceRect: SourceRect | null;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    createContent(): void;
    hide(): void;
    renderInnerContent(): void;
    show(): void;
    sourceRectAtTime(): SourceRect | null;
}

declare const svgShapeMethods$1: readonly ["initElement"];
declare const imageMethods$1: readonly ["prepareFrame"];
interface CVImageElement extends Pick<SVGShapeElement, typeof svgShapeMethods$1[number]>, Pick<ImageElement, typeof imageMethods$1[number]> {
}
declare class CVImageElement extends CVBaseElement {
    assetData: LottieAsset | null;
    img: HTMLCanvasElement;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    createContent(): void;
    destroy(): void;
    renderInnerContent(): void;
}

declare const svgShapeMethods: readonly ["initElement"];
declare const imageMethods: readonly ["prepareFrame"];
interface CVSolidElement extends Pick<SVGShapeElement, typeof svgShapeMethods[number]>, Pick<ImageElement, typeof imageMethods[number]> {
}
declare class CVSolidElement extends CVBaseElement {
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    renderInnerContent(): void;
}

declare class TextAnimatorProperty extends DynamicPropertyContainer {
    _frameId: number;
    _isFirstFrame: boolean;
    defaultPropsArray: number[];
    lettersChangedFlag: boolean;
    renderedLetters: LetterProps[];
    private _animatorsData;
    private _elem;
    private _hasMaskedPath;
    private _moreOptions;
    private _pathData;
    private _renderType;
    private _textData;
    private mHelper;
    constructor(textData: TextData, renderType: RendererType, elem: ElementInterfaceIntersect);
    getMeasures(documentData: DocumentData, lettersChangedFlag?: boolean): void;
    getValue(): number;
    searchProperties(_: DynamicPropertyContainer[]): void;
}

declare abstract class TextElement extends RenderableDOMElement {
    emptyProp?: LetterProps;
    lettersChangedFlag?: boolean;
    renderType?: RendererType;
    textAnimator?: TextAnimatorProperty;
    textProperty?: TextProperty;
    applyTextPropertiesToMatrix(documentData: DocumentData, matrixHelper: Matrix, lineNumber: number, xPos: number, yPos: number): void;
    buildColor(colorData: Vector3): string;
    abstract buildNewText(): void;
    canResizeFont(_canResize: boolean): void;
    createPathShape(matrixHelper: Matrix, shapes: Shape[]): string;
    initElement(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect): void;
    prepareFrame(num: number): void;
    setMinimumFontSize(_fontSize: number): void;
    updateDocumentData(newData: DocumentData, index: number): void;
    validateText(): void;
}

declare const canvasMethods$1: readonly ["clearCanvas", "createContainerElements", "createContent", "createRenderableComponents", "hide", "hideElement", "initRendererElement", "destroy", "exitLayer", "prepareLayer", "renderFrame", "renderLocalTransform", "renderRenderable", "searchEffectTransforms", "setBlendMode", "show", "showElement"];
interface CVTextElement extends Pick<CVBaseElement, typeof canvasMethods$1[number]> {
}
declare class CVTextElement extends TextElement {
    canvasContext?: CanvasRenderingContext2D;
    currentRender: unknown;
    fill: boolean;
    fillColorAnim: boolean;
    justifyOffset: number;
    renderedLetters: LetterProps[];
    stroke: boolean;
    strokeColorAnim: boolean;
    strokeWidthAnim: boolean;
    textSpans: TextSpan[];
    tHelper: CanvasRenderingContext2D | null;
    values: {
        fill: string;
        fValue: string;
        stroke: string;
        sWidth: number;
    };
    yOffset: number;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    buildNewText(): void;
    destroyBaseElement(): void;
    renderElement(): void;
    renderInnerContent(): void;
}

declare class SolidElement extends ImageElement {
    createContent(): void;
}

declare const baseMethods: readonly ["createContainerElements", "createRenderableComponents", "destroyBaseElement", "getBaseElement", "getMatte", "initRendererElement", "renderElement", "setMatte"];
interface SVGTextLottieElement extends Pick<SVGBaseElement, typeof baseMethods[number]> {
}
declare class SVGTextLottieElement extends TextElement {
    _sizeChanged?: boolean;
    bbox?: {
        height: number;
        left: number;
        top: number;
        width: number;
    };
    renderedLetters: string[];
    textContainer?: SVGTextElement;
    textSpans: TextSpan[];
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    buildNewText(): void;
    buildShapeData(data: LottieLayer, scale: number): LottieLayer;
    buildTextContents(textArray: string[]): string[];
    createContent(): void;
    getValue(): void;
    renderInnerContent(): void;
    sourceRectAtTime(): SourceRect | null;
}

declare abstract class SVGRendererBase extends BaseRenderer {
    destroyed: boolean;
    renderConfig?: SVGRendererConfig;
    svgElement?: SVGSVGElement;
    appendElementInPos(element: ElementInterfaceIntersect, pos: number): void;
    buildItem(pos: number): void;
    checkPendingElements(): void;
    configAnimation(animData: AnimationData): void;
    createImage(data: LottieLayer): ImageElement;
    createShape(data: LottieLayer): SVGShapeElement;
    createSolid(data: LottieLayer): SolidElement;
    createText(data: LottieLayer): SVGTextLottieElement;
    destroy(): void;
    findIndexByInd(ind?: number): number;
    hide(): void;
    renderFrame(numFromProps?: number | false): void;
    show(): void;
    updateContainerSize(_width?: number, _height?: number): void;
}

declare const rendererMethods$1: readonly ["addPendingElement", "appendElementInPos", "buildAllItems", "buildElementParenting", "buildItem", "checkLayers", "checkPendingElements", "configAnimation", "createAudio", "createCamera", "createFootage", "createImage", "createItem", "createNull", "createShape", "createSolid", "createText", "findIndexByInd", "getElementById", "getElementByPath", "includeLayers", "initItems", "searchExtraCompositions", "setProjectInterface", "setupGlobalData", "updateContainerSize"];
declare const compMethods: readonly ["createContent", "destroy", "destroyElements", "getElements", "hide", "initElement", "prepareFrame", "renderFrame", "renderInnerContent", "setElements", "show"];
interface SVGCompElement extends Pick<SVGRendererBase, typeof rendererMethods$1[number]>, Pick<CompElement, typeof compMethods[number]> {
}
declare class SVGCompElement extends SVGBaseElement {
    _debug?: boolean;
    completeLayers: boolean;
    currentFrame: number;
    elements: ElementInterfaceIntersect[];
    layers?: undefined | LottieLayer[];
    pendingElements: ElementInterfaceIntersect[];
    supports3d: boolean;
    tm?: KeyframeValueProperty;
    constructor(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface);
    createComp(data: LottieLayer, _container?: HTMLElement, comp?: CompElementInterface): SVGCompElement;
}

declare class ProjectInterface {
    compositions: CompElementInterface[];
    currentFrame: number;
    getComposition(name?: string): CompExpressionInterface | null | undefined;
    registerComposition(comp: CompElementInterface): void;
}

declare class FootageElement extends RenderableElement {
    assetData: null | LottieAsset;
    footageData: null | SVGElement;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    getBaseElement(): null;
    getFootageData(): SVGElement | null;
    initExpressions(): void;
    prepareFrame(): void;
    renderFrame(): void;
}

declare class NullElement extends FrameElement {
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    getBaseElement(): null;
    prepareFrame(num: number): void;
    renderFrame(_frame?: number | null): null;
}

declare abstract class BaseRenderer extends FrameElement {
    animationItem?: AnimationItem;
    completeLayers: boolean;
    currentFrame: number;
    elements: (ElementInterfaceIntersect | undefined)[];
    layers: LottieLayer[];
    pendingElements: SVGBaseElement[];
    addPendingElement(element: SVGBaseElement): void;
    buildAllItems(): void;
    buildElementParenting(element: SVGBaseElement, parentName?: number, hierarchy?: ElementInterfaceIntersect[]): void;
    buildItem(_val: number): void;
    checkLayers(val?: number): void;
    abstract checkPendingElements(): void;
    createAudio(data: LottieLayer): AudioElement;
    createCamera(_data: LottieLayer): HTMLElement;
    abstract createComp(_data: LottieLayer, _container?: HTMLElement, _comp?: CompElementInterface, _?: unknown): SVGCompElement | CVCompElement;
    createFootage(data: LottieLayer): FootageElement;
    abstract createImage(_layer: LottieLayer): CVImageElement | ImageElement;
    createItem(layer: LottieLayer): HTMLElement | CVCompElement | SVGCompElement | ImageElement | AudioElement | SVGShapeElement | SVGTextLottieElement | CVTextElement | FootageElement | CVImageElement | CVSolidElement | NullElement | CVShapeElement;
    createNull(data: LottieLayer): NullElement;
    abstract createShape(_layer: LottieLayer): CVShapeElement | SVGShapeElement;
    abstract createSolid(_layer: LottieLayer): CVSolidElement | SolidElement;
    abstract createText(_layer: LottieLayer): SVGTextLottieElement | CVTextElement;
    getElementById(ind: number): null | ElementInterfaceIntersect;
    getElementByPath(path: unknown[]): ElementInterfaceIntersect | undefined;
    includeLayers(newLayers: LottieLayer[]): void;
    initItems(): void;
    searchExtraCompositions(assets: LottieLayer[]): void;
    setProjectInterface(pInterface: ProjectInterface | null): void;
    setupGlobalData(animData: AnimationData, fontsContainer: HTMLElement | SVGDefsElement): void;
}

declare abstract class CanvasRendererBase extends BaseRenderer {
    canvasContext?: undefined | null | CanvasRenderingContext2D;
    contextData?: CVContextData;
    destroyed?: boolean;
    renderConfig?: CanvasRendererConfig;
    transformCanvas?: TransformCanvas;
    protected _dprLocked: boolean;
    private _elementWidth;
    private _resizeObserver?;
    addResizeObserver(): void;
    buildItem(pos: number): void;
    checkPendingElements(): void;
    configAnimation(animData: AnimationData): void;
    createImage(data: LottieLayer): CVImageElement;
    createShape(data: LottieLayer): CVShapeElement;
    createSolid(data: LottieLayer): CVSolidElement;
    createText(data: LottieLayer): CVTextElement;
    ctxFill(rule?: CanvasFillRule): void;
    ctxFillRect(x: number, y: number, w: number, h: number): void;
    ctxFillStyle(value?: string): void;
    ctxLineCap(value: CanvasLineCap): void;
    ctxLineJoin(value: CanvasLineJoin): void;
    ctxLineWidth(value: number): void;
    ctxMiterLimit(value: number): void;
    ctxOpacity(op?: number): void;
    ctxStroke(): void;
    ctxStrokeStyle(value?: string): void;
    ctxTransform(props: Float32Array): void;
    destroy(): void;
    hide(): void;
    renderFrame(num: number | false, forceRender?: boolean): void;
    reset(): void;
    restore(actionFlag?: boolean): void;
    save(_flag?: boolean): void;
    show(): void;
    syncDevicePixelRatio(): void;
    updateContainerSize(width?: number, height?: number): void;
}

declare const rendererMethods: readonly ["addPendingElement", "buildAllItems", "buildElementParenting", "buildItem", "checkLayers", "checkPendingElements", "configAnimation", "createAudio", "createCamera", "createFootage", "createImage", "createItem", "createNull", "createShape", "createSolid", "createText", "ctxFill", "ctxFillRect", "ctxFillStyle", "ctxLineCap", "ctxLineJoin", "ctxLineWidth", "ctxMiterLimit", "ctxOpacity", "ctxStroke", "ctxStrokeStyle", "ctxTransform", "getElementById", "getElementByPath", "includeLayers", "initItems", "reset", "restore", "save", "searchExtraCompositions", "setProjectInterface", "setupGlobalData", "syncDevicePixelRatio", "updateContainerSize"];
declare const canvasMethods: readonly ["clearCanvas", "createContainerElements", "createContent", "createRenderableComponents", "exitLayer", "hide", "hideElement", "initRendererElement", "prepareLayer", "renderFrame", "setBlendMode", "show", "showElement"];
interface CVCompElement extends Pick<CanvasRendererBase, typeof rendererMethods[number]>, Pick<CVBaseElement, typeof canvasMethods[number]> {
}
declare class CVCompElement extends CompElement {
    canvasContext?: CanvasRenderingContext2D;
    pendingElements: ElementInterfaceIntersect[];
    constructor(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface);
    createComp(data: LottieLayer): CVCompElement;
    destroy(): void;
    destroyBaseElement(): void;
    renderElement(): void;
    renderInnerContent(): void;
}

declare class CanvasRenderer extends CanvasRendererBase {
    rendererType: RendererType;
    transformMat: Matrix;
    constructor(animationItem: AnimationItem, config?: CanvasRendererConfig);
    createComp(data: LottieLayer): CVCompElement;
}

declare class SVGRenderer extends SVGRendererBase {
    rendererType: RendererType;
    constructor(animationItem: AnimationItem, config?: SVGRendererConfig);
    createComp(data: LottieLayer, _container?: HTMLElement, comp?: CompElementInterface): SVGCompElement;
}

declare class EnterFrameEvent {
    currentTime: number;
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    totalTime: number;
    type: PlayerEvent;
    constructor(type: PlayerEvent, currentTime: number, totalTime: number, frameMultiplier: number);
}
declare class CompleteEvent {
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    type: PlayerEvent;
    constructor(type: PlayerEvent, frameMultiplier: number);
}
declare class DrawnFrameEvent {
    currentTime: number;
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    totalTime: number;
    type: PlayerEvent;
    constructor(type: PlayerEvent, currentTime: number, direction: AnimationDirection, totalTime: number);
}
declare class CompleteLoopEvent {
    currentLoop: number;
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    totalLoops: number | boolean;
    type: PlayerEvent;
    constructor(type: PlayerEvent, totalLoops: number | boolean, currentLoop: number, frameMultiplier: number);
}
declare class SegmentStartEvent {
    firstFrame: number;
    target?: undefined | AnimationItem;
    totalFrames: number;
    type: PlayerEvent;
    constructor(type: PlayerEvent, firstFrame: number, totalFrames: number);
}
declare class DestroyEvent {
    target: AnimationItem;
    type: PlayerEvent;
    constructor(type: PlayerEvent, target: AnimationItem);
}
declare class ConfigErrorEvent {
    nativeError: unknown;
    target?: undefined | AnimationItem;
    type: PlayerEvent;
    constructor(nativeError: unknown, _: number);
}
declare class AnimationConfigErrorEvent {
    nativeError: unknown;
    target?: undefined | AnimationItem;
    type: PlayerEvent;
    constructor(type: PlayerEvent, nativeError: unknown);
}
declare abstract class BaseEvent {
    _cbs: Partial<Record<PlayerEvent, ((ev?: LottieEvent) => unknown)[] | null>>;
    addEventListener(eventName: PlayerEvent, callback: (ev?: LottieEvent) => unknown): () => void;
    removeEventListener(eventName: PlayerEvent, callback?: (ev: LottieEvent) => unknown): void;
    triggerEvent(eventName: PlayerEvent, ev?: LottieEvent): void;
}
type LottieEvent = AnimationConfigErrorEvent | EnterFrameEvent | CompleteEvent | CompleteLoopEvent | SegmentStartEvent | ConfigErrorEvent | DestroyEvent | DrawnFrameEvent;

declare class ImagePreloader {
    assetsPath: string;
    images: ImageData[];
    imagesLoadedCb: null | ((images: ImageData[] | null) => void);
    loadedAssets: number;
    loadedFootagesCount: number;
    path: string;
    totalFootages: number;
    totalImages: number;
    private _adoptedImages;
    private _createImageData?;
    private _elementHelper?;
    private _footageLoaded;
    private _hasNotified;
    private _imageLoaded;
    private _isRegistering;
    private _pendingTimeouts;
    private _preloadHost;
    private proxyImage;
    constructor();
    adoptSvgImage(assetData: null | LottieAsset): SVGImageElement | null;
    createFootageData(data: LottieAsset): ImageData;
    createImageData(assetData: LottieAsset): ImageData;
    destroy(): void;
    footageLoaded(): void;
    getAsset(assetData: null | LottieAsset): SVGElement | HTMLCanvasElement | HTMLMediaElement | HTMLImageElement | null;
    imageLoaded(): void;
    loadAssets(assets: LottieAsset[], cb: ImagePreloader['imagesLoadedCb']): void;
    loadedFootages(): boolean;
    loadedImages(): boolean;
    setAssetsPath(path?: string): void;
    setCacheType(type: RendererType, _elementHelper?: SVGElement): void;
    setPath(path?: string): void;
    private _awaitSvgImageReady;
    private _createProxyImage;
    private cleanupElementHelper;
    private createImgData;
    private destroyPreloadHost;
    private ensurePreloadHost;
    private getAssetsPath;
    private notifyIfComplete;
}

declare class AnimationItem extends BaseEvent {
    __complete?: boolean;
    _isFirstFrame: boolean | number;
    animationData: AnimationData;
    animationID: string;
    assets: LottieAsset[];
    assetsPath: string;
    audioController: AudioController;
    autoplay: boolean;
    container?: undefined | HTMLCanvasElement;
    currentFrame: number;
    currentRawFrame: number;
    drawnFrameEvent: DrawnFrameEvent;
    enterFrameEvent: EnterFrameEvent;
    enterFrameLegacyEvent: EnterFrameEvent;
    expressionsPlugin: {
        initExpressions: (animation: AnimationItem) => void;
        resetFrame: () => void;
    } | null;
    firstFrame: number;
    frameModifier: AnimationDirection;
    frameMult: number;
    frameRate: number;
    imagePreloader: ImagePreloader;
    isLoaded: boolean;
    isPaused: boolean;
    isSubframeEnabled: boolean;
    loop: boolean | number;
    markers: MarkerData[];
    name: string;
    onError?: (arg: unknown) => void;
    path: string;
    playCount: number;
    playDirection: AnimationDirection;
    playSpeed: number;
    projectInterface: ProjectInterface;
    renderer: SVGRenderer | CanvasRenderer;
    segmentPos: number;
    segments: Vector2[];
    timeCompleted: number;
    totalFrames: number;
    wrapper: HTMLElement | null;
    protected animType?: undefined | RendererType;
    protected autoloadSegments: boolean;
    protected filename?: undefined | string;
    protected initialSegment?: undefined | Vector2;
    private _completedLoop;
    private _fontsLoadTimeout?;
    private _idle;
    private _isDestroyed;
    constructor();
    adjustSegment(arr: Vector2, offset: number): void;
    advanceTime(value: number): void;
    checkLoaded(): void;
    checkSegments(offset: number): boolean;
    configAnimation(animData: AnimationData): void;
    destroy(name?: string): void;
    getAssetData(id?: string): LottieAsset | null;
    getAssetsPath(assetData: null | LottieAsset): string;
    getDuration(isFrame?: boolean): number;
    getMarkerData(markerName: number | string): MarkerData | null;
    getPath(): string;
    getVolume(): number;
    goToAndPlay(value: number | string, isFrame?: boolean, name?: string): void;
    goToAndStop(value: number | string, isFrame?: boolean, name?: string): void;
    gotoFrame(): void;
    hide(): void;
    imagesLoaded(): void;
    includeLayers(data: AnimationData): void;
    loadNextSegment(): void;
    loadSegments(): void;
    mute(name?: string): void;
    onSegmentComplete(data: AnimationData): void;
    onSetupError(): void;
    pause(name?: string): void;
    play(name?: string): void;
    playSegments(arr: Vector2 | Vector2[], forceFlag?: boolean): void;
    preloadImages(): void;
    renderFrame(num?: number | null): void;
    resetSegments(forceFlag?: boolean): void;
    resize(width?: number, height?: number): void;
    setCurrentRawFrameValue(value: number): void;
    setData(wrapper: HTMLElement, animationDataFromProps?: AnimationData): void;
    setDirection(val: AnimationDirection, name?: string): void;
    setLoop(isLooping: boolean): void;
    setParams(params: AnimationConfiguration): void;
    setSegment(init: number, end: number): void;
    setSpeed(val: number, name?: string): void;
    setSubframe(flag?: boolean): void;
    setupAnimation(data: AnimationData): void;
    setVolume(val: number, name?: string): void;
    show(): void;
    stop(name?: string): void;
    togglePause(name?: string): void;
    trigger(name: PlayerEvent): void;
    triggerConfigError(nativeError: unknown): void;
    triggerRenderFrameError(nativeError: unknown): void;
    unmute(name?: string): void;
    updateDocumentData(path: unknown[], documentData: DocumentData, index: number): void;
    updateFrameModifier(): void;
    waitForFontsLoaded(): void;
    private _handleLoop;
}

declare class SVGGradientStrokeStyleData extends SVGGradientFillStyleData {
    c?: undefined | MultiDimensionalProperty<Vector3>;
    d: DashProperty;
    w?: undefined | ValueProperty;
    constructor(elem: ElementInterfaceIntersect, data: Shape, styleData: SVGStyleData);
}

declare function createRenderFunction(data: Shape): typeof renderFill | typeof renderGradient | typeof renderStroke | typeof renderPath | typeof renderContentTransform | null;
declare function renderContentTransform(_: Shape, itemData?: SVGTransformData, isFirstFrame?: number | boolean): void;
declare function renderFill(_: Shape, itemData?: SVGFillStyleData, isFirstFrame?: number | boolean): void;
declare function renderGradient(styleData: Shape, itemData?: SVGGradientFillStyleData, isFirstFrame?: number | boolean): void;
declare function renderPath(styleData: Shape, itemData?: SVGShapeData, isFirstFrame?: number | boolean): void;
declare function renderStroke(_: Shape, itemData?: SVGStrokeStyleData | SVGGradientStrokeStyleData, isFirstFrame?: number | boolean): void;
type CreateRenderFunction = ReturnType<typeof createRenderFunction>;

declare class BezierData {
    points: BezierPoint[];
    segmentLength: number;
    constructor(length: number);
}

declare class FootageInterface {
    _name: string;
    currentProperty?: SVGElement | null;
    currentPropertyName: string;
    dataInterface: FootageInterface;
    elem: FootageElement;
    constructor(elem: FootageElement);
    dataInterfaceFactory(elem: FootageElement): this;
    getInterface(value: number | string): FootageInterface | null | undefined;
    init(): (value: keyof SVGElement) => "" | any | undefined;
    outlineInterface(_elem?: FootageElement): void;
    outlineInterfaceFactory(elem: FootageElement): () => (value: keyof SVGElement) => "" | any | undefined;
    searchProperty(value: keyof SVGElement): "" | ((value: keyof SVGElement) => "" | any | undefined) | undefined;
}

declare class FontManager {
    chars: Character[] | null;
    fonts: DocumentData[];
    isLoaded: boolean;
    typekitLoaded: number;
    private _warned;
    private checkLoadedFontsBinded;
    private initTime;
    private setIsLoadedBinded;
    constructor();
    addChars(chars?: null | Character[]): void;
    addFonts(fontData?: {
        list: DocumentData[];
    }, defs?: HTMLElement | SVGDefsElement): void;
    getCharData(char: Character | string, style?: string, font?: string): Character;
    getFontByName(name?: string): DocumentData;
    measureText(char: string, fontName?: string, size?: number): number;
    private checkLoadedFonts;
    private createHelper;
    private setIsLoaded;
}

declare class SlotManager {
    animationData: LottieLayer;
    constructor(animationData: LottieLayer);
    getProp(data: DocumentData | LottieLayer | LottieAsset): any;
}

declare class TextSelectorProperty extends BaseProperty {
    _currentTextLength: number;
    a: ValueProperty;
    b?: ValueProperty;
    data: TextRangeValue;
    e: ValueProperty | {
        v: number;
    };
    elem: ElementInterfaceIntersect;
    finalE: number;
    finalS: number;
    ne: ValueProperty;
    o: ValueProperty;
    rn?: number;
    sm: ValueProperty;
    t?: string | undefined;
    totalChars?: number;
    xe: ValueProperty;
    constructor(elem: ElementInterfaceIntersect, data: TextRangeValue);
    getMult(indFromProps: number, _val?: number): number | number[];
    getTextSelectorProp(_elem: ElementInterfaceIntersect, _data: TextRangeValue, _arr: unknown[]): void;
    getValue(newCharsFlag?: boolean): number;
    private _getCoordinates;
    private _handleShapeType;
}

declare class TextAnimatorDataProperty {
    a?: {
        a: ValueProperty | NoProperty;
        fb: ValueProperty | NoProperty;
        fc: ValueProperty | NoProperty;
        fh: ValueProperty | NoProperty;
        fs: ValueProperty | NoProperty;
        o: ValueProperty | NoProperty;
        p: MultiDimensionalProperty | NoProperty;
        r: ValueProperty | NoProperty;
        rx: ValueProperty | NoProperty;
        ry: ValueProperty | NoProperty;
        s: ValueProperty | NoProperty;
        sa: ValueProperty | NoProperty;
        sc: ValueProperty | NoProperty;
        sk: ValueProperty | NoProperty;
        sw: ValueProperty | NoProperty;
        t: ValueProperty | NoProperty;
    };
    s?: TextSelectorProperty;
    constructor(elem: ElementInterfaceIntersect, animatorProps?: TextAnimatorDataProperty, container?: ElementInterfaceIntersect);
}

type AnimationDirection = 1 | -1;
interface TextSpan {
    children: SVGSVGElement[];
    childSpan?: undefined | null | SVGTextElement | SVGGElement;
    elem?: undefined | number[][];
    glyph: null | SVGCompElement | SVGShapeElement;
    span: null | SVGTextElement | SVGGElement;
    style?: undefined | CSSStyleDeclaration;
}
type SVGElementInterface = SVGShapeData | SVGTransformData | SVGFillStyleData | SVGStrokeStyleData | SVGNoStyleData | SVGGradientFillStyleData | SVGGradientStrokeStyleData;
interface Transformer {
    _localMatMdf: boolean;
    _matMdf: boolean;
    _mdf?: boolean;
    _opMdf: boolean;
    container: SVGGElement;
    key?: undefined | string;
    localMat: Matrix;
    localOpacity: number;
    mat: Matrix;
    matrix?: undefined | Matrix;
    mProp: TransformProperty;
    mProps: TransformProperty;
    op: ValueProperty;
    opacity: number;
}
type RendererIntersect = SVGRenderer & CanvasRenderer;
type ElementInterfaceIntersect = CompElementInterface & RenderableComponentIntersect & RendererIntersect & AnimationItem;
type RenderableComponentIntersect = ImageElement & AudioElement & SVGShapeElement & SVGMaskElement & SVGEffects & SVGTextLottieElement & CVMaskElement & CVEffects & CVTextElement;
type RenderableComponent = ImageElement | AudioElement | MaskElement | SVGShapeElement | SVGEffects | SVGTextLottieElement | CVMaskElement | CVEffects | CVTextElement;
interface TransformCanvas {
    h: number;
    props?: undefined | Float32Array;
    sx: number;
    sy: number;
    tx: number;
    ty: number;
    w: number;
}
interface BezierLength {
    addedLength: number;
    lengths: number[];
    percents: number[];
}
type ExpressionInterface = ExpressionInterfaces[keyof ExpressionInterfaces];
interface ExpressionInterfaces {
    comp: typeof CompExpressionInterface;
    effects: unknown;
    footage: typeof FootageInterface;
    layer: typeof LayerExpressionInterface;
    shape: typeof ShapeExpressionInterface;
    text: typeof TextExpressionInterface;
}
interface AnimatedContent {
    data: Shape;
    element: ShapeDataInterface | SVGElementInterface;
    fn: null | CreateRenderFunction;
}
type CompElementInterface = BaseRenderer | CVCompElement | SVGCompElement;
interface CVStyleElement {
    closed: boolean;
    co?: undefined | string;
    coOp?: undefined | number;
    da?: undefined | Float32Array;
    data: Shape;
    do?: undefined | number;
    elements: CVShapeData[];
    grd?: undefined | string;
    lc?: undefined | CanvasLineCap;
    lj?: undefined | CanvasLineJoin;
    ml?: undefined | number;
    preTransforms: TransformSequence;
    r?: 'evenodd' | 'nonzero';
    transforms: Transformer[];
    type: ShapeType;
    wi?: undefined | number;
}
interface CVElement {
    a?: undefined | ValueProperty;
    c?: undefined | MultiDimensionalProperty<number[]>;
    d?: undefined | DashProperty;
    e?: undefined | MultiDimensionalProperty;
    g?: undefined | GradientProperty;
    h?: undefined | ValueProperty;
    it: CVElement[];
    o?: undefined | ValueProperty;
    prevViewData: CVElement[];
    s?: undefined | MultiDimensionalProperty;
    style?: undefined | CVStyleElement;
    w?: undefined | ValueProperty;
}
interface EFXElement {
    p: BaseProperty;
}
interface KeyframesMetadata {
    __fnct?: (val: number) => number | number[];
    bezierData?: undefined | BezierData;
}
interface BaseRendererConfig {
    className?: undefined | string;
    imagePreserveAspectRatio?: undefined | string;
}
interface FilterSizeConfig {
    height: string;
    width: string;
    x: string;
    y: string;
}
interface Letter {
    add: number;
    an: number;
    animatorJustifyOffset: number;
    anIndexes: number[];
    extra?: undefined | number;
    ind?: undefined | number;
    l: number;
    line: number;
    n: boolean;
    val: string;
    xOffset: number;
    yOffset: number;
}
type SVGRendererConfig = BaseRendererConfig & {
    title?: undefined | string;
    description?: undefined | string;
    preserveAspectRatio?: undefined | string;
    progressiveLoad?: undefined | boolean;
    hideOnTransparent?: undefined | boolean;
    viewBoxOnly?: undefined | boolean;
    viewBoxSize?: undefined | string | false;
    focusable?: undefined | boolean;
    filterSize?: undefined | FilterSizeConfig;
    contentVisibility?: undefined | string;
    runExpressions?: undefined | boolean;
    width?: undefined | number;
    height?: undefined | number;
    id?: undefined | string;
};
type CanvasRendererConfig = BaseRendererConfig & {
    clearCanvas?: undefined | boolean;
    context?: undefined | null | CanvasRenderingContext2D;
    contentVisibility: string;
    id: string;
    imagePreserveAspectRatio: PreserveAspectRatio;
    preserveAspectRatio: PreserveAspectRatio;
    progressiveLoad?: undefined | boolean;
    runExpressions?: undefined | boolean;
    dpr?: undefined | number;
};
type HTMLRendererConfig = BaseRendererConfig & {
    hideOnTransparent?: undefined | boolean;
    filterSize?: undefined | {
        width: string;
        height: string;
        y: string;
        x: string;
    };
    runExpressions?: undefined | boolean;
};
interface AnimationConfiguration<T extends RendererType = RendererType.Canvas | RendererType.SVG> {
    animationData?: undefined | AnimationData;
    animType?: undefined | RendererType;
    assetsPath?: undefined | string;
    audioFactory?: undefined | AudioFactory;
    autoloadSegments?: undefined | boolean;
    autoplay?: undefined | boolean;
    container?: undefined | HTMLElement;
    initialSegment?: undefined | Vector2;
    loop?: undefined | HTMLBooleanAttribute;
    name?: undefined | string;
    path?: undefined | string;
    prerender?: undefined | boolean;
    renderer?: undefined | T;
    rendererSettings?: undefined | {
        svg: SVGRendererConfig;
        canvas: CanvasRendererConfig;
    }[T];
    wrapper?: undefined | HTMLElement;
}
interface Stop {
    s: number[];
}
interface GradientColor {
    k: {
        a: 1 | 0;
        k: number[] | Stop[];
    };
    p: number;
}
type DynamicProperty = {
    hd?: boolean;
} & VectorProperty<number | number[] | Keyframe[]>;
type BoolInt = 0 | 1;
interface ShapeDataProperty {
    _mdf?: boolean;
    a: 1 | 0;
    ix?: undefined | number;
    k: ShapePath | ShapePath[];
    paths: {
        _length: number;
        _maxLength: number;
        shapes: ShapePath[];
    };
}
interface StrokeData {
    n: 'o' | 'd' | 'g';
    nm?: 'offset' | 'dash' | 'gap';
    p: BaseProperty;
    v?: VectorProperty;
}
interface ShapeColor {
    a: 1 | 0;
    ix?: undefined | number;
    k: number | number[] | ShapeColorValue[];
}
interface ShapeColorValue {
    e: Vector4;
    i: Vector4;
    s: Vector4;
}
interface Shape {
    _length: number;
    _processed?: boolean;
    _shouldRender?: boolean;
    a?: undefined | VectorProperty<number | Vector2 | Vector3>;
    bm?: undefined | number;
    c?: undefined | ShapeColor;
    cix?: undefined | number;
    cl?: undefined | string;
    closed?: undefined | boolean;
    d?: undefined | number | StrokeData[];
    dc?: undefined | number;
    e?: undefined | VectorProperty<Vector2>;
    eo?: undefined | VectorProperty;
    g?: undefined | GradientColor;
    h?: undefined | VectorProperty;
    hd?: undefined | boolean;
    ind?: undefined | number;
    inv?: undefined | boolean;
    ir?: undefined | {
        ix?: number;
    };
    is?: undefined | {
        ix?: number;
    };
    it?: undefined | Shape[];
    ix?: undefined | number;
    ks?: undefined | ShapeDataProperty;
    lc?: 1 | 2 | 3;
    lj?: 1 | 2 | 3;
    ln?: undefined | string;
    m?: 1 | 2;
    maxDist?: undefined | number;
    ml?: undefined | number;
    mn?: undefined | string;
    mode?: undefined | string;
    nm?: undefined | string;
    np?: undefined | number;
    o?: undefined | {
        a: 0 | 1;
        k: number;
        ix?: number;
        x?: number;
    };
    or?: undefined | {
        k: Keyframe[];
        ix?: number;
    };
    os?: undefined | {
        ix?: number;
    };
    p?: undefined | VectorProperty<Vector2>;
    pt?: undefined | VectorProperty<ShapePath | ShapePath[]>;
    r?: undefined | VectorProperty<{
        e: number;
        s: number;
        t: number;
    }[]>;
    rx?: undefined | VectorProperty;
    ry?: undefined | VectorProperty;
    rz?: undefined | VectorProperty;
    s?: undefined | VectorProperty<Vector2 | Vector3>;
    sa?: VectorProperty;
    sk?: undefined | VectorProperty;
    so?: undefined | VectorProperty;
    sy?: undefined | number;
    t?: undefined | number;
    tr?: undefined | Shape;
    ty: undefined | ShapeType;
    w?: undefined | VectorProperty;
    x?: undefined | {
        a: 0 | 1;
        k: number;
        ix?: number;
    };
}
interface StoredData {
    elem: SVGPathElement;
    expan: SVGFEMorphologyElement | null;
    filterId?: undefined | string;
    lastOperator: string;
    lastPath: string;
    lastRadius: number;
    x: ValueProperty | null;
}
interface ViewData {
    elem: SVGPathElement;
    invRect?: undefined | SVGRectElement | null;
    lastPath: string;
    op: ValueProperty;
    prop: ShapeProperty | KeyframeShapeProperty | RectShapeProperty | EllShapeProperty | StarShapeProperty | null;
}
interface LottieAsset {
    __used?: boolean;
    e?: undefined | BoolInt;
    h?: undefined | number;
    id?: undefined | string;
    layers?: undefined | LottieLayer[] & {
        __used?: boolean;
    };
    nm?: undefined | string;
    p?: undefined | string;
    pr?: undefined | string;
    sid?: undefined | string;
    t?: undefined | string;
    u?: undefined | string;
    w?: undefined | number;
    xt?: undefined | number;
}
type HTMLBooleanAttribute = boolean | string | number | null;
interface AnimationSettings {
    autoplay?: undefined | HTMLBooleanAttribute;
    direction?: undefined | AnimationDirection;
    loop?: undefined | HTMLBooleanAttribute;
    mode?: undefined | PlayMode;
    speed?: undefined | number;
}
interface LottieAnimation extends AnimationSettings {
    id: string;
}
interface LottieManifest {
    animations: LottieAnimation[];
    author?: undefined | string;
    description?: undefined | string;
    generator?: undefined | string;
    keywords?: undefined | string;
    version?: undefined | string;
}
type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [...R, T]>;
type Vector2 = Tuple<number, 2>;
type Vector3 = Tuple<number, 3>;
type Vector4 = Tuple<number, 4>;
interface VectorProperty<T = number> {
    _mdf?: boolean;
    a: 1 | 0;
    ix?: undefined | number;
    k: T;
    s?: undefined | number;
    sid?: undefined | number;
    v?: undefined | T;
    z?: undefined | number;
}
interface Coordinates {
    c?: undefined | boolean;
    x: number | number[];
    y: number | number[];
}
interface LayerStyle {
    a?: undefined | {
        a: 0 | 1;
        k: number;
    };
    bm?: undefined | {
        a: 0 | 1;
        k: number;
    };
    c: {
        a: 0 | 1;
        k: Vector3 | Vector4;
    };
    ch?: undefined | {
        a: 0 | 1;
        k: number;
    };
    d?: undefined | {
        a: 0 | 1;
        k: number;
    };
    mn: string;
    nm: string;
    no?: undefined | {
        a: 0 | 1;
        k: number;
    };
    o?: undefined | {
        a: 0 | 1;
        k: number;
    };
    s: {
        a: 0 | 1;
        k: number;
    };
    ty: number;
}
interface TransformSequence {
    _mdf?: boolean;
    [key: string]: unknown;
    finalTransform?: undefined | Matrix;
    transforms?: undefined | {
        transform: Transformer;
    }[];
}
interface DocumentData extends FontList {
    __complete?: boolean;
    ascent?: undefined | number;
    boxWidth?: undefined | Vector2 | number;
    f: string;
    fc?: undefined | Vector3 | string;
    fillColorAnim?: undefined | boolean;
    finalLineHeight?: undefined | number;
    finalSize?: undefined | number;
    finalText: string[];
    j?: undefined | number;
    justifyOffset?: undefined | number;
    k: {
        s: LetterProps | DocumentData;
        t: number;
    }[];
    l: Letter[];
    lh: number;
    lineWidths: number[];
    ls?: undefined | number;
    of?: undefined | string;
    ps?: undefined | Vector2 | null;
    s: number;
    sc?: undefined | Vector3;
    sid?: unknown;
    strokeColorAnim?: undefined | boolean;
    strokeWidthAnim?: undefined | boolean;
    sw?: undefined | number;
    sz?: undefined | Vector2;
    t: string | number;
    tr: number;
    x?: undefined | string;
    yOffset?: undefined | number;
}
interface TransformNode {
    p?: undefined | number[];
    pts?: undefined | number[];
    t: string;
}
interface BezierPoint {
    partialLength: number;
    point: number[];
}
interface TextRangeValue {
    a: {
        a: 0 | 1;
        k: number;
    };
    b: number;
    e: {
        a: 0 | 1;
        k: number;
    };
    hd?: undefined | boolean;
    ne?: undefined | {
        a: 0 | 1;
        k: number;
    };
    o?: undefined | {
        a: 0 | 1;
        k: number;
    };
    r: number;
    rn: 0 | 1;
    s?: undefined | {
        a: 0 | 1;
        k: number;
    };
    sh: number;
    sm?: undefined | {
        a: 0 | 1;
        k: number;
    };
    t: 0 | 1;
    totalChars: number;
    xe?: undefined | {
        a: 0 | 1;
        k: number;
    };
}
interface ShapeDataInterface {
    _isAnimated: boolean;
    caches: string[];
    container: ElementInterfaceIntersect;
    elements: ElementInterfaceIntersect[];
    it: ShapeDataInterface[];
    lStr: string;
    lvl: number;
    setAsAnimated: () => void;
    sh: {
        propType: string;
        k: boolean;
        kf: boolean;
        _mdf: boolean;
        comp: ElementInterfaceIntersect;
        paths: ShapeElement;
        v: {
            v: number[][];
            o: number[][];
            i: number[][];
            c?: number[][];
            _length: number;
        };
    };
    style?: undefined | CSSStyleDeclaration;
    styles: SVGStyleData[];
    transform: Transformer;
    transformers: Transformer[];
    w?: undefined | ValueProperty;
}
interface TextData {
    __complete?: boolean;
    _mdf?: boolean;
    a?: undefined | TextAnimatorDataProperty[];
    ascent: number;
    boxWidth: Vector2;
    d?: undefined | DocumentData;
    f: string;
    fc: string;
    fillColorAnim: boolean;
    finalLineHeight: number;
    finalSize: number;
    finalText: string[];
    fStyle: string;
    fWeight: string;
    hd?: undefined | boolean;
    justifyOffset: number;
    l: Letter[];
    lh: number;
    lineWidths: number[];
    ls: number;
    m?: undefined | {
        _mdf?: boolean;
        g: number;
        a: {
            a: 0 | 1;
            k: Vector2;
            ix?: number;
        };
        v: string;
    };
    n?: any;
    of: string;
    p?: undefined | TextVectorData;
    ps: null | Vector2;
    r?: undefined | {
        v: number[];
    };
    s: number;
    sc: string;
    strokeColorAnim: boolean;
    strokeWidthAnim: boolean;
    sw: number;
    t: string;
    tr: number;
    yOffset: number;
}
interface TextVectorData {
    _mdf?: boolean;
    a?: undefined | VectorProperty;
    f?: undefined | VectorProperty;
    l: VectorProperty;
    m: number;
    n?: undefined | VectorProperty;
    p?: undefined | VectorProperty;
    r?: undefined | VectorProperty;
    v?: undefined | VectorProperty;
}
interface EffectValue {
    ty: number;
    v: {
        a: 1 | 0;
        k: number | Vector3 | Vector4;
    };
}
interface Effect {
    ef: EffectValue[];
    en: 1 | 0;
    fs?: undefined | FilterSizeConfig;
    ix?: undefined | number;
    mn?: undefined | string;
    nm?: undefined | string;
    np: number;
    ty: number;
}
interface FontList {
    cache?: undefined | Record<string, unknown>;
    fClass: string;
    fFamily: string;
    fName: string;
    fOrigin: string;
    fPath: string;
    fStyle: string;
    fWeight: string;
    helper?: undefined | {
        measureText: (str: string, fontName?: string, size?: number) => number;
    };
    loaded?: boolean;
    monoCase?: undefined | {
        node: HTMLElement;
        parent: HTMLElement;
        w: number;
    };
    origin: number;
    sansCase?: undefined | {
        node: HTMLElement;
        parent: HTMLElement;
        w: number;
    };
}
interface Character {
    ch?: undefined | Character;
    data?: undefined | LottieLayer;
    fFamily?: undefined | string;
    shapes: Shape[];
    size: number;
    style?: undefined | string;
    t: number;
    w: number;
}
interface AnimationData {
    __complete?: boolean;
    $schema?: string;
    ao?: undefined | boolean | 0 | 1;
    assets: LottieAsset[];
    chars?: Character[] | null;
    ddd: 0 | 1;
    fonts?: undefined | {
        list: DocumentData[];
    };
    fr: number;
    h: number;
    ip: number;
    layers: LottieLayer[];
    markers?: MarkerData[];
    meta?: undefined | {
        a: string;
        d: string;
        k: string;
        tc: string;
        g: string;
    };
    mn?: undefined | string;
    nm: string;
    op: number;
    segments?: undefined | {
        time: number;
    }[];
    slots?: undefined | {
        [key: string]: {
            p: any;
        };
    };
    v: string;
    w: number;
}
interface LottieLayer {
    __used?: boolean;
    ao?: undefined | 0 | 1 | boolean;
    au?: undefined | {
        lv?: {
            k: number[];
        };
    };
    bm?: undefined | number;
    chars?: undefined | Character[];
    cl?: undefined | string;
    completed?: undefined | boolean;
    ct?: 0 | 1;
    ddd?: 0 | 1;
    ef?: undefined | Effect[];
    en?: undefined | number;
    fonts?: undefined | {
        list: DocumentData[];
    };
    fr?: undefined | number;
    h?: undefined | number;
    hasMask?: undefined | boolean;
    hd?: undefined | boolean;
    height?: undefined | number;
    id?: undefined | string;
    ind?: undefined | number;
    ip: number;
    ks: Shape;
    layers?: undefined | LottieLayer[] & {
        __used?: boolean;
    };
    ln?: undefined | string;
    masksProperties?: undefined | Shape[];
    mn?: undefined | string;
    nm: string;
    np?: undefined | string;
    op: number;
    parent?: undefined | number;
    pe?: undefined | VectorProperty;
    refId?: undefined | string;
    sc?: undefined | string;
    sh?: undefined | number;
    shapes: Shape[];
    singleShape?: boolean;
    slots?: undefined | {
        [key: string]: {
            p: any;
        };
    };
    sr?: undefined | number;
    st: number;
    sw?: undefined | number;
    sy?: undefined | LayerStyle[];
    t?: undefined | TextData;
    td?: 0 | 1;
    textData?: undefined | {
        height: number;
        width: number;
    };
    tg?: undefined | string;
    tm?: undefined | VectorProperty;
    tp?: undefined | number;
    tt?: undefined | number;
    ty: number;
    w?: undefined | number;
    width?: undefined | number;
    xt?: undefined | number;
}
interface MarkerData {
    duration: number;
    payload?: undefined | Record<string, unknown>;
    time: number;
}
interface Audio {
    pause: () => void;
    play: () => void;
    playing: () => boolean;
    rate: (val: number) => void;
    resume: () => void;
    seek: (val?: number) => number;
    setRate: (val: number) => void;
    volume: (val: number) => void;
}
type AudioFactory = (path?: string) => Audio;
interface ImageData {
    assetData: LottieAsset;
    img: null | SVGElement | HTMLCanvasElement | HTMLImageElement | HTMLMediaElement;
}
interface CanvasItem {
    c: MultiDimensionalProperty<Vector3>;
    d?: undefined | {
        dashoffset: string;
        _mdf?: boolean;
    };
    it?: undefined | CanvasItem;
    o: ValueProperty;
    prevViewData?: undefined | CanvasItem;
    style: {
        closed?: boolean;
        co: string;
        coOp: number;
        data: LottieLayer;
        elements: Transformer[];
        lc: string;
        lj: string;
        ml: number;
        preTransforms: any;
        transforms: any[];
        type: string;
        wi: number;
    };
    w?: undefined | {
        _mdf?: boolean;
        v: number;
    };
}
interface Keyframe {
    e: Vector3;
    h?: undefined | number;
    i: Coordinates;
    keyframeMetadata?: {
        length: number;
        name: string;
    };
    n: string;
    o: Coordinates;
    s: ShapePath[] | Vector3 | null;
    t: number;
    ti: Vector2 | null;
    to?: undefined | Vector2 | null;
}
type EffectFunction = (...args: any[]) => any;
type TextEffectFunction = (data: DocumentData, value: string) => DocumentData;
interface Caching {
    _lastAddedLength: number;
    _lastKeyframeIndex: number;
    _lastPoint: number;
    lastFrame: number;
    lastIndex: number;
    lastTime: number;
    shapeValue: ShapePath | null;
    value: number | number[];
}
interface GlobalData {
    _mdf?: boolean;
    audioController?: undefined | AudioController;
    blendMode?: undefined | string;
    canvasContext?: undefined | null | CanvasRenderingContext2D;
    comp?: CompElementInterface;
    compSize?: {
        w: number;
        h: number;
    };
    currentGlobalAlpha: number;
    defs: SVGDefsElement;
    fontManager?: undefined | FontManager;
    frameId: number;
    frameNum?: undefined | number;
    frameRate: number;
    getAssetData: AnimationItem['getAssetData'];
    getAssetsPath: AnimationItem['getAssetsPath'];
    imageLoader?: undefined | ImagePreloader | null;
    isDashed?: undefined | boolean;
    mouseX?: undefined | number;
    mouseY?: undefined | number;
    nm?: undefined | string;
    popExpression: () => void;
    progressiveLoad?: undefined | boolean;
    projectInterface: ProjectInterface;
    pushExpression: () => void;
    registerExpressionProperty: (expression: ExpressionProperty) => void;
    renderConfig?: undefined | SVGRendererConfig | CanvasRendererConfig | HTMLRendererConfig;
    renderer?: undefined | CanvasRenderer | SVGRenderer;
    slotManager?: undefined | SlotManager;
    transformCanvas?: undefined | TransformCanvas;
}
type ExpressionProperty = VectorProperty<Keyframe[]> & {
    release?: () => void;
    x: string;
};
interface SourceRect {
    height: number;
    left: number;
    top: number;
    width: number;
}
interface ConvertParams {
    animations?: undefined | AnimationData[];
    currentAnimation?: undefined | number;
    filename?: undefined | string;
    generator?: undefined | string;
    isDotLottie?: undefined | boolean;
    manifest?: undefined | LottieManifest;
    shouldDownload?: undefined | boolean;
    src?: undefined | string;
    typeCheck?: undefined | boolean;
}
interface AnimationAttributes extends AnimationSettings {
    id: string;
    url: string;
}
interface AddAnimationParams {
    configs: AnimationAttributes[];
    filename?: undefined | string;
    generator: string;
    id?: undefined | string;
    shouldDownload?: undefined | boolean;
    src?: undefined | string;
}
interface Result {
    error?: undefined | string;
    result: null | string | ArrayBuffer;
    success: boolean;
}
declare global {
    interface Document {
        _isProxy?: boolean;
    }
}

export { PlayMode as P, AnimationItem as e, ArrayType as j, PlayerEvent as k, PreserveAspectRatio as l, RendererType as m, ShapeType as n };
export type { AddAnimationParams as A, ConvertParams as C, HTMLBooleanAttribute as H, LottieManifest as L, Result as R, SVGRendererConfig as S, Vector2 as V, AnimationData as a, LottieAsset as b, AnimationConfiguration as c, AnimationDirection as d, AnimationSettings as f, CanvasRendererConfig as g, HTMLRendererConfig as h, LottieAnimation as i };