declare enum PlayMode {
    Bounce = "bounce",
    Normal = "normal"
}
declare enum PreserveAspectRatio {
    Contain = "xMidYMid meet",
    Cover = "xMidYMid slice",
    Initial = "none",
    None = "xMinYMin slice"
}
declare enum RendererType {
    Canvas = "canvas",
    HTML = "html",
    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"
}

declare class PropertyGroupFactory {
    interfaceFunction: (val: string | number) => BaseProperty;
    parentPropertyGroup: LayerExpressionInterface;
    constructor(interfaceFunction: (val: number | string) => BaseProperty, parentPropertyGroup: LayerExpressionInterface);
    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(): LetterProps | DocumentData | 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 | null): void;
}

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

declare class SVGEffects {
    filters: GroupEffect[];
    constructor(elem: ElementInterfaceIntersect);
    getEffects(type: EffectTypes): (GroupEffect | undefined)[];
    renderFrame(frame?: number | null): 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;
    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 KeyframedValueProperty extends BaseProperty {
    pv: number | number[];
    selectorValue?: string;
    v: number;
    constructor(elem: ElementInterfaceIntersect, data: VectorProperty<Keyframe[]>, mult?: null | number, container?: ElementInterfaceIntersect | null);
}

declare class KeyframedMultidimensionalProperty<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> | KeyframedValueProperty | NoProperty | MultiDimensionalProperty<number[]> | KeyframedMultidimensionalProperty<Vector2>;
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 | KeyframedValueProperty;
    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 ShapeTransformManager {
    sequenceList: TransformSequence[];
    sequences: TransformSequence;
    transform_key_count: number;
    addTransformSequence(transforms: {
        transform: Transformer;
    }[]): Transformer;
    getNewKey(): string;
    processSequence(sequence: TransformSequence, isFirstFrame?: boolean): void;
    processSequences(isFirstFrame?: boolean): void;
}

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

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 CVShapeData extends ShapeData {
    constructor(element: CVShapeElement, data: Shape, styles: CVStyleElement[], transformsManager: ShapeTransformManager);
}

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 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 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: SVGShapeData): 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: SVGShapeData, shapeSegment: {
        e: number;
        s: number;
    }, shapePathFromProps?: ShapePath): ShapePath[];
    addShapeToModifier(shapeData: SVGShapeData): 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: SVGShapeData[];
    addShape(data: SVGShapeData | CVShapeData): void;
    addShapeToModifier(_shapeData: SVGShapeData): 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?: undefined | SVGGraphicsElement | HTMLElement | null;
    createContainerElements(): void;
    createContent(): void;
    createRenderableComponents(): void;
    destroy(): void;
    hide(): void;
    initElement(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface): void;
    initRendererElement(): void;
    prepareFrame(num: number): void;
    renderElement(): void;
    renderFrame(_val?: number): void;
    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 class HShapeElement extends ShapeElement {
    animatedContents: unknown[];
    currentBBox: BoundingBox;
    prevViewData: HShapeElement[];
    shapeBoundingBox: {
        bottom: number;
        left: number;
        right: number;
        top: number;
    };
    shapeCont?: undefined | SVGElement;
    shapesContainer: SVGGElement;
    stylesList: CSSStyleDeclaration[];
    svgElement?: SVGSVGElement;
    tempBoundingBox: {
        height: number;
        width: number;
        x: number;
        xMax: number;
        y: number;
        yMax: number;
    };
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    _renderShapeFrame(): void;
    calculateBoundingBox(itemsData: ShapeDataInterface[], boundingBox: BoundingBox): void;
    calculateF(t: number, p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, i: number): number;
    calculateShapeBoundingBox(item: ShapeDataInterface, boundingBox: BoundingBox): void;
    checkBounds(vPoint: Vector2, oPoint: Vector2, nextIPoint: Vector2, nextVPoint: Vector2, boundingBox: BoundingBox): void;
    createContent(): void;
    currentBoxContains(box: BoundingBox): boolean;
    expandStrokeBoundingBox(widthProperty: ValueProperty, boundingBox: BoundingBox): void;
    filterUniqueShapes(): void;
    getBoundsOfCurve(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2): void;
    getTransformedPoint(transformers: Transformer[], pointFromProps: number[]): number[];
    renderInnerContent(): void;
    searchShapes(_shapes: Shape[], _itemsData: ShapeGroupData[], _prevViewData: HShapeElement[], _shapesContainer: SVGElement, _pos: number, _: unknown[], _flag: boolean): 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 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;
    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 SVGTransformData {
    _isAnimated: boolean;
    elements: ElementInterfaceIntersect[];
    gr?: SVGGElement;
    it?: ShapeDataInterface[];
    prevViewData?: SVGElementInterface[];
    style?: SVGStyleData;
    transform: Transformer;
    constructor(mProps: TransformProperty, op: ValueProperty, container: SVGGElement);
}

declare class SVGShapeElement extends ShapeElement {
    _debug?: boolean;
    animatedContents: AnimatedContent[];
    createContainerElements: () => void;
    createRenderableComponents: () => void;
    destroyBaseElement: () => void;
    getBaseElement: () => HTMLElement | SVGGElement | null;
    getMatte: (matteType?: number) => string;
    identityMatrix: Matrix;
    initRendererElement: () => void;
    prevViewData: SVGElementInterface[];
    renderElement: () => void;
    setMatte: (id: string) => void;
    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;
    pathsData?: ShapePath[] | ShapePath;
    shape?: {
        _mdf?: boolean;
        paths?: undefined | {
            shapes: ShapePath[];
            _length: number;
        };
    };
    totalShapeLength?: number;
    x?: boolean;
    constructor(elem: SVGShapeElement | CVShapeElement | HShapeElement, data: Shape, type: number);
}
declare class KeyframedShapeProperty extends ShapeBaseProperty {
    lastFrame: number;
    constructor(elem: SVGShapeElement | CVShapeElement | HShapeElement, data: Shape, type: number);
}

declare class CVShapeElement extends ShapeElement {
    canvasContext?: CanvasRenderingContext2D;
    clearCanvas: (canvasContext?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null) => void;
    createContainerElements: () => void;
    createRenderableComponents: () => void;
    dashResetter: number[];
    exitLayer: () => void;
    hide: () => void;
    initRendererElement: () => void;
    prepareLayer: () => void;
    prevViewData: ShapeGroupData[];
    renderFrame: (forceRender?: number) => void;
    setBlendMode: () => void;
    show: () => void;
    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)[];
    elem?: SVGShapeElement | CVShapeElement | HShapeElement;
    frameId?: number;
    k?: boolean;
    keyframesMetadata: KeyframesMetadata[];
    kf?: boolean;
    localShapeCollection?: ShapeCollection;
    lock?: boolean;
    offsetTime: number;
    p?: MultiDimensionalProperty;
    paths?: ShapePath[] | ShapeCollection | undefined;
    pv?: ShapePath;
    ty?: ShapeType;
    v?: ShapePath;
    getValueAtTime(_frameNumFromProps: number, _num?: number): ShapePath | null;
    initiateExpression(_elem: ElementInterfaceIntersect, _data: ExpressionProperty, _property: KeyframedValueProperty): 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[];
    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 | KeyframedShapeProperty | 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?: HTMLElement | SVGGElement;
    comp?: CompElementInterface;
    compInterface?: CompExpressionInterface;
    data?: LottieLayer;
    dynamicProperties: DynamicPropertyContainer[];
    effectsManager?: EffectsManager;
    frameDuration: number;
    globalData?: GlobalData;
    itemsData: ShapeGroupData[];
    layerElement?: SVGGElement | HTMLElement;
    layerId?: string;
    layerInterface?: null | LayerExpressionInterface;
    maskManager?: MaskElement | CVMaskElement;
    shapesData: Shape[];
    type?: unknown;
    buildAllItems(): void;
    checkLayers(_frame?: number): void;
    checkMasks(): boolean;
    destroy(): void;
    destroyBaseElement(): void;
    getBaseElement(): SVGElement | HTMLElement | null;
    getType(): unknown;
    initBaseData(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface): void;
    initExpressions(): void;
    setBlendMode(): void;
    sourceRectAtTime(): void;
}

declare abstract class TransformElement extends BaseElement {
    _isFirstFrame?: boolean;
    finalTransform?: Transformer;
    hierarchy?: ElementInterfaceIntersect[];
    localTransforms?: Transformer[];
    mHelper: Matrix;
    renderableEffectsManager?: SVGEffects;
    globalToLocal(point: Vector3): Vector3;
    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;
    createElements(): void;
    createRenderableComponents(): void;
    destroy(): void;
    exitLayer(): void;
    hideElement(): void;
    initRendererElement(): void;
    prepareLayer(): void;
    renderFrame(forceRender?: number): void;
    renderInnerContent(): void;
    setBlendMode(): void;
    showElement(): void;
}

declare class CVMaskElement {
    _isFirstFrame?: boolean;
    data: LottieLayer;
    element: CVShapeElement | CVBaseElement;
    hasMasks: boolean;
    masksProperties: Shape[];
    viewData: ShapeProperty[];
    constructor(data: LottieLayer, element: CVShapeElement | CVBaseElement);
    destroy(): void;
    getMaskProperty(pos: number): ShapeProperty | undefined;
    renderFrame(_num?: number): void;
}

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

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 | undefined;
    defaultInterfaceFactory(): () => null;
    ellipseInterfaceFactory(shape: Shape, view: SVGShapeData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    fillInterfaceFactory(shape: Shape, view: SVGFillStyleData, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    getInterface(valueFromProps?: string | number): PropertyGroupFactory;
    gradientFillInterfaceFactory(shape: Shape, view: SVGGradientFillStyleData, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | 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;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    repeaterInterfaceFactory(shape: Shape, view: RepeaterModifier, propertyGroup: LayerExpressionInterface): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    roundedInterfaceFactory(shape: Shape, view: RoundCornersModifier, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    starInterfaceFactory(shape: Shape, view: ShapeData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    strokeInterfaceFactory(shape: Shape, view: SVGStrokeStyleData, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    transformInterfaceFactory(shape: Shape, view: SVGTransformData | SVGFillStyleData, propertyGroup: PropertyGroupFactory): (value: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | null;
    trimInterfaceFactory(shape: Shape, view: TrimModifier, propertyGroup: PropertyGroupFactory): (val: string | number) => (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | 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 | KeyframedShapeProperty | 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 | undefined;
}

declare class TransformExpressionInterface {
    transform: TransformProperty;
    get anchorPoint(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get opacity(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get orientation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get position(): Number | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | {
        mult: number;
        pv: number;
        v: number;
    } | (number | Number | number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | {
        mult: number;
        pv: number;
        v: number;
    } | undefined)[] | undefined;
    get rotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get scale(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get skew(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get skewAxis(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get xPosition(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get xRotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get yPosition(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get yRotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get zPosition(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    get zRotation(): (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>);
    private _px;
    private _py;
    private _pz;
    private _transformFactory;
    constructor(transform: TransformProperty);
    getInterface(name: string | number): Number | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | (() => {
        mult: number;
        pv: number;
        v: number;
    }) | (() => Number) | (() => number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>) | {
        mult: number;
        pv: number;
        v: number;
    } | (number | Number | number[] | Float32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | {
        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 | undefined;
    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?: 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[] | DocumentData | ShapePath | undefined;
    getValueAtTime(_val1?: unknown, _val2?: unknown): unknown;
    getVelocityAtTime(_frameNum: number): number | number[];
    initiateExpression(_elem: ElementInterfaceIntersect, _data: ExpressionProperty, _property: KeyframedValueProperty): EffectFunction;
    interpolateValue(frameNum: number, caching?: Caching): Vector3;
    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 {
    _canPlay: boolean;
    _currentTime: number;
    _isPlaying: boolean;
    _previousVolume: number | null;
    _volume: number;
    _volumeMultiplier: number;
    assetData: null | LottieAsset;
    audio: Audio;
    lv: MultiDimensionalProperty;
    tm: ValueProperty;
    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 class ProjectInterface {
    compositions: CompElementInterface[];
    currentFrame: number;
    getComposition(name?: string): CompExpressionInterface | null | undefined;
    registerComposition(comp: CompElementInterface): 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;
    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 class HTextElement extends TextElement {
    compH?: undefined | number;
    compW?: undefined | number;
    currentBBox: {
        h: number;
        w: number;
        x: number;
        y: number;
    };
    isMasked: boolean;
    maskedElement?: SVGGElement | HTMLElement;
    renderedLetters: string[];
    svgElement?: SVGSVGElement;
    textPaths: SVGPathElement[];
    textSpans: HTMLElement[];
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    buildNewText(): void;
    createContent(): void;
    renderInnerContent(): 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 class CVSolidElement extends CVBaseElement {
    initElement: (data: LottieLayer, globalData: GlobalData, comp: CompElementInterface) => void;
    prepareFrame: (num: number) => void;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    renderInnerContent(): void;
}

declare class CVTextElement extends TextElement {
    canvasContext?: CanvasRenderingContext2D;
    clearCanvas: (canvasContext?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null) => void;
    createContainerElements: () => void;
    createContent: () => void;
    createElements: () => void;
    createRenderableComponents: () => void;
    currentRender: unknown;
    destroy: () => void;
    exitLayer: () => void;
    fill: boolean;
    fillColorAnim: boolean;
    hide: () => void;
    hideElement: () => void;
    initRendererElement: () => void;
    justifyOffset: number;
    prepareLayer: () => void;
    renderedLetters: LetterProps[];
    renderFrame: (forceRender?: number) => void;
    renderLocalTransform: () => void;
    renderRenderable: () => void;
    searchEffectTransforms: () => void;
    setBlendMode: () => void;
    show: () => void;
    showElement: () => void;
    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;
    renderInnerContent(): void;
}

declare class SVGTextLottieElement extends TextElement {
    _sizeChanged?: boolean;
    bbox?: {
        height: number;
        left: number;
        top: number;
        width: number;
    };
    createContainerElements: () => void;
    createRenderableComponents: () => void;
    destroyBaseElement: () => void;
    getBaseElement: () => HTMLElement | SVGGElement | null;
    getMatte: (matteType?: number) => string;
    initRendererElement: () => void;
    renderedFrame?: undefined | number;
    renderedLetters: string[];
    renderElement: () => void;
    setMatte: (id: string) => void;
    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 SVGBaseElement extends RenderableDOMElement {
    _sizeChanged?: boolean;
    maskedElement?: HTMLElement | SVGGElement;
    matteElement?: SVGGElement;
    matteMasks?: {
        [key: number]: string;
    };
    transformedElement?: HTMLElement | SVGGElement;
    createContainerElements(): void;
    createRenderableComponents(): void;
    destroyBaseElement(): void;
    getBaseElement(): HTMLElement | SVGGElement | null;
    getMatte(matteType?: number): string;
    initRendererElement(): void;
    renderElement(): void;
    setMatte(id: string): void;
}

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

declare class SolidElement extends ImageElement {
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    createContent(): void;
}

declare class CVImageElement extends CVBaseElement {
    assetData: LottieAsset | null;
    img: HTMLCanvasElement;
    initElement: (data: LottieLayer, globalData: GlobalData, comp: CompElementInterface) => void;
    prepareFrame: (num: number) => void;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    createContent(): void;
    destroy(): void;
    renderInnerContent(): void;
}

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

declare class HCompElement extends CompElement {
    pendingElements: ElementInterfaceIntersect[];
    supports3d?: boolean;
    svgElement?: SVGSVGElement;
    threeDElements: ThreeDElement[];
    transformedElement?: undefined | SVGGElement | HTMLElement;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    _createBaseContainerElements(): void;
    addEffects(): void;
    addTo3dContainer(elem: Node, pos: number): void;
    appendElementInPos(_element: ElementInterfaceIntersect, _pos: number): void;
    build3dContainers(): void;
    buildElementParenting(_element: ElementInterfaceIntersect, _parentName?: number, _hierarchy?: ElementInterfaceIntersect[]): void;
    checkBlendMode(): void;
    checkPendingElements(): void;
    configAnimation(_data: AnimationData): void;
    createCamera(_data: LottieLayer): void;
    createComp(data: LottieLayer): HCompElement | SVGCompElement;
    createContainerElements(): void;
    createImage(_data: LottieLayer): void;
    createShape(_data: LottieLayer): void;
    createSolid(_data: LottieLayer): void;
    createText(_data: LottieLayer): void;
    createThreeDContainer(_pos: number, _type: string): void;
    getElementById(_id: number): void;
    getThreeDContainerByPos(_pos: number): void;
    initItems(): void;
    searchExtraCompositions(_assets: LottieLayer[]): void;
    setMatte(): void;
    updateContainerSize(): 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 HCameraElement extends FrameElement {
    _prevMat: Matrix;
    a?: ValueProperty<Vector3>;
    comp?: HCompElement;
    mat?: Matrix;
    or?: ValueProperty<Vector3>;
    p?: ValueProperty<number[]>;
    pe?: ValueProperty;
    px?: ValueProperty;
    py?: ValueProperty;
    pz?: ValueProperty;
    rx?: ValueProperty;
    ry?: ValueProperty;
    rz?: ValueProperty;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    createElements(): void;
    getBaseElement(): null;
    hide(): void;
    prepareFrame(num: number): void;
    renderFrame(_val?: number): void;
    setup(): void;
}

declare class SVGCompElement extends SVGBaseElement {
    _debug?: boolean;
    addPendingElement: (element: ElementInterfaceIntersect) => void;
    appendElementInPos: (element: ElementInterfaceIntersect, pos: number) => void;
    buildAllItems: () => void;
    buildElementParenting: (element: ElementInterfaceIntersect, parentName?: number, hierarchy?: ElementInterfaceIntersect[]) => void;
    buildItem: (pos: number) => void;
    checkLayers: (val?: number) => void;
    checkPendingElements: () => void;
    completeLayers: boolean;
    configAnimation: (animData: AnimationData) => void;
    createAudio: (data: LottieLayer) => AudioElement;
    createCamera: (_data: LottieLayer) => HCameraElement;
    createFootage: (data: LottieLayer) => FootageElement;
    createImage: (data: LottieLayer) => ImageElement;
    createItem: (layer: LottieLayer) => CVCompElement | HCompElement | SVGCompElement | ImageElement | AudioElement | SVGShapeElement | SVGTextLottieElement | CVTextElement | CVShapeElement | HCameraElement | HShapeElement | FootageElement | CVImageElement | CVSolidElement | NullElement | HTextElement;
    createNull: (data: LottieLayer) => NullElement;
    createShape: (data: LottieLayer) => SVGShapeElement;
    createSolid: (data: LottieLayer) => SolidElement;
    createText: (data: LottieLayer) => SVGTextLottieElement;
    currentFrame: number;
    destroy: () => void;
    destroyElements: () => void;
    elements: ElementInterfaceIntersect[];
    findIndexByInd: (ind?: number) => number;
    getElementById: (ind: number) => null | ElementInterfaceIntersect;
    getElementByPath: (path: unknown[]) => ElementInterfaceIntersect | undefined;
    getElements: () => ElementInterfaceIntersect[] | undefined;
    hide: () => void;
    includeLayers: (newLayers: LottieLayer[]) => void;
    initElement: (data: LottieLayer, globalData: GlobalData, comp: CompElementInterface) => void;
    initItems: () => void;
    layers?: undefined | LottieLayer[];
    pendingElements: ElementInterfaceIntersect[];
    prepareFrame: (val: number) => void;
    renderedFrame: number;
    renderFrame: (_val?: number) => void;
    renderInnerContent: () => void;
    searchExtraCompositions: (assets: LottieLayer[]) => void;
    setElements: (elems: ElementInterfaceIntersect[]) => void;
    setProjectInterface: (pInterface: ProjectInterface | null) => void;
    setupGlobalData: (animData: AnimationData, fontsContainer: HTMLElement | SVGDefsElement) => void;
    show: () => void;
    supports3d: boolean;
    tm?: KeyframedValueProperty;
    updateContainerSize: (_width?: number, _height?: number) => void;
    constructor(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface);
    createComp(data: LottieLayer): SVGCompElement;
}

declare class CVCompElement extends CompElement {
    addPendingElement: (element: ElementInterfaceIntersect) => void;
    buildAllItems: () => void;
    buildElementParenting: (element: ElementInterfaceIntersect, parentName?: number, hierarchy?: ElementInterfaceIntersect[]) => void;
    buildItem: (pos: number) => void;
    canvasContext?: CanvasRenderingContext2D;
    checkLayers: (val?: number) => void;
    checkPendingElements: () => void;
    clearCanvas: (canvasContext?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null) => void;
    configAnimation: (animData: AnimationData) => void;
    createAudio: (data: LottieLayer) => AudioElement;
    createCamera: (_data: LottieLayer) => HCameraElement;
    createContainerElements: () => void;
    createContent: () => void;
    createElements: () => void;
    createFootage: (data: LottieLayer) => FootageElement;
    createImage: (data: LottieLayer) => CVImageElement;
    createItem: (layer: LottieLayer) => CVCompElement | HCompElement | SVGCompElement | ImageElement | AudioElement | SVGShapeElement | SVGTextLottieElement | CVTextElement | CVShapeElement | HCameraElement | HShapeElement | FootageElement | CVImageElement | CVSolidElement | NullElement | HTextElement;
    createNull: (_layer: LottieLayer) => NullElement;
    createRenderableComponents: () => void;
    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;
    exitLayer: () => void;
    getElementById: (ind: number) => null | ElementInterfaceIntersect;
    getElementByPath: (path: unknown[]) => ElementInterfaceIntersect | undefined;
    hide: () => void;
    hideElement: () => void;
    includeLayers: (newLayers: LottieLayer[]) => void;
    initItems: () => void;
    initRendererElement: () => void;
    pendingElements: ElementInterfaceIntersect[];
    prepareLayer: () => void;
    renderFrame: (forceRender?: number) => void;
    reset: () => void;
    restore: (actionFlag?: boolean) => void;
    save: (_flag?: boolean) => void;
    searchExtraCompositions: (assets: LottieLayer[]) => void;
    setBlendMode: () => void;
    setProjectInterface: (pInterface: ProjectInterface | null) => void;
    setupGlobalData: (animData: AnimationData, fontsContainer: HTMLElement | SVGDefsElement) => void;
    show: () => void;
    showElement: () => void;
    updateContainerSize: (width?: number, height?: number) => void;
    constructor(data: LottieLayer, globalData: GlobalData, comp: CompElementInterface);
    createComp(data: LottieLayer): CVCompElement;
    destroy(): void;
    renderInnerContent(): void;
}

declare class CanvasContext {
    fillStyle: string;
    id: number;
    lineCap: string;
    lineJoin: string;
    lineWidth: number | string;
    miterLimit: number | string;
    opacity: number;
    strokeStyle: string;
    transform: number[];
    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 HSolidElement extends SolidElement {
    svgElement?: SVGSVGElement;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    addEffects(): void;
    checkBlendMode(): void;
    createContent(): void;
}

declare class HImageElement extends HSolidElement {
    imageElem?: SVGImageElement;
    constructor(data: LottieLayer, globalData: GlobalData, comp: ElementInterfaceIntersect);
    createContent(): void;
}

declare abstract class BaseRenderer extends FrameElement {
    animationItem?: AnimationItem;
    completeLayers?: boolean;
    currentFrame: number;
    elements: ElementInterfaceIntersect[];
    layers: LottieLayer[];
    pendingElements: ElementInterfaceIntersect[];
    renderedFrame: number;
    addPendingElement(element: ElementInterfaceIntersect): void;
    buildAllItems(): void;
    buildElementParenting(element: ElementInterfaceIntersect, parentName?: number, hierarchy?: ElementInterfaceIntersect[]): void;
    buildItem(_val: number): void;
    checkLayers(val?: number): void;
    checkPendingElements(): void;
    createAudio(data: LottieLayer): AudioElement;
    createCamera(_data: LottieLayer): HCameraElement;
    createComp(_data: LottieLayer, _container?: HTMLElement, _comp?: CompElementInterface, _?: unknown): SVGCompElement | CVCompElement | HCompElement;
    createFootage(data: LottieLayer): FootageElement;
    createImage(_layer: LottieLayer): CVImageElement | ImageElement | HImageElement;
    createItem(layer: LottieLayer): CVCompElement | HCompElement | SVGCompElement | ImageElement | AudioElement | SVGShapeElement | SVGTextLottieElement | CVTextElement | CVShapeElement | HCameraElement | HShapeElement | FootageElement | CVImageElement | CVSolidElement | NullElement | HTextElement;
    createNull(_layer: LottieLayer): NullElement;
    createShape(_layer: LottieLayer): CVShapeElement | SVGShapeElement | HShapeElement;
    createSolid(_layer: LottieLayer): CVSolidElement | SolidElement;
    createText(_layer: LottieLayer): SVGTextLottieElement | CVTextElement | HTextElement;
    getElementById(ind: number): null | ElementInterfaceIntersect;
    getElementByPath(path: unknown[]): ElementInterfaceIntersect | undefined;
    includeLayers(newLayers: LottieLayer[]): void;
    initItems(): void;
    prepareFrame(_num: number): 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;
    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, forceRender?: boolean): void;
    reset(): void;
    restore(actionFlag?: boolean): void;
    save(_flag?: boolean): void;
    show(): void;
    updateContainerSize(width?: number, height?: number): void;
}

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

declare class HybridRendererBase extends BaseRenderer {
    camera?: HCameraElement;
    destroyed: boolean;
    renderConfig: HTMLRendererConfig;
    rendererType: RendererType;
    resizerElem?: HTMLDivElement;
    supports3d: boolean;
    threeDElements: ThreeDElements[];
    constructor(animationItem: AnimationItem, config?: HTMLRendererConfig);
    addTo3dContainer(elem: HTMLElement, pos: number): void;
    appendElementInPos(element: ElementInterfaceIntersect, pos: number): void;
    build3dContainers(): void;
    checkPendingElements(): void;
    configAnimation(animData: AnimationData): void;
    createCamera(data: LottieLayer): HCameraElement;
    createImage(data: LottieLayer): ImageElement;
    createShape(data: LottieLayer): SVGShapeElement | HShapeElement;
    createSolid(data: LottieLayer): SolidElement;
    createText(data: LottieLayer): SVGTextLottieElement | HTextElement;
    createThreeDContainer(pos: number, type: string): {
        container: HTMLElement;
        endPos: number;
        perspectiveElem: HTMLDivElement;
        startPos: number;
        type: string;
    };
    destroy(): void;
    getThreeDContainerByPos(pos: number): HTMLDivElement | null;
    hide(): void;
    initItems(): void;
    renderFrame(_num: number | null): void;
    searchExtraCompositions(assets: LottieLayer[]): void;
    show(): void;
    updateContainerSize(): void;
}

declare class HybridRenderer extends HybridRendererBase {
    createComp(data: LottieLayer): HCompElement | SVGCompElement;
}

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;
    createNull(data: LottieLayer): NullElement;
    createShape(data: LottieLayer): SVGShapeElement;
    createSolid(data: LottieLayer): SolidElement;
    createText(data: LottieLayer): SVGTextLottieElement;
    destroy(): void;
    findIndexByInd(ind?: number): number;
    hide(): void;
    renderFrame(numFromProps?: number | null): void;
    show(): void;
    updateContainerSize(_width?: number, _height?: number): void;
}

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

declare class EnterFrameEvent {
    currentTime: number;
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    totalTime: number;
    type: AnimationEventName;
    constructor(type: AnimationEventName, currentTime: number, totalTime: number, frameMultiplier: number);
}
declare class CompleteEvent {
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    type: AnimationEventName;
    constructor(type: AnimationEventName, frameMultiplier: number);
}
declare class DrawnFrameEvent {
    currentTime: number;
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    totalTime: number;
    type: AnimationEventName;
    constructor(type: AnimationEventName, currentTime: number, direction: AnimationDirection, totalTime: number);
}
declare class CompleteLoopEvent {
    currentLoop: number;
    direction: AnimationDirection;
    target?: undefined | AnimationItem;
    totalLoops: number | boolean;
    type: AnimationEventName;
    constructor(type: AnimationEventName, totalLoops: number | boolean, currentLoop: number, frameMultiplier: number);
}
declare class SegmentStartEvent {
    firstFrame: number;
    target?: undefined | AnimationItem;
    totalFrames: number;
    type: AnimationEventName;
    constructor(type: AnimationEventName, firstFrame: number, totalFrames: number);
}
declare class DestroyEvent {
    target: AnimationItem;
    type: AnimationEventName;
    constructor(type: AnimationEventName, target: AnimationItem);
}
declare class ConfigErrorEvent {
    nativeError: unknown;
    target?: undefined | AnimationItem;
    type: AnimationEventName;
    constructor(nativeError: unknown, _: number);
}
declare class AnimationConfigErrorEvent {
    nativeError: unknown;
    target?: undefined | AnimationItem;
    type: AnimationEventName;
    constructor(type: AnimationEventName, nativeError: unknown);
}
declare abstract class BaseEvent {
    _cbs: Partial<Record<AnimationEventName, ((ev?: LottieEvent) => unknown)[] | null>>;
    addEventListener(eventName: AnimationEventName, callback: (ev?: LottieEvent) => unknown): () => void;
    removeEventListener(eventName: AnimationEventName, callback?: (ev: LottieEvent) => unknown): void;
    triggerEvent(eventName: AnimationEventName, 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 _createImageData?;
    private _elementHelper?;
    private _footageLoaded;
    private _imageLoaded;
    private proxyImage;
    constructor();
    createFootageData(data: LottieAsset): ImageData;
    createImageData(assetData: LottieAsset): ImageData;
    destroy(): void;
    footageLoaded(): void;
    getAsset(assetData: null | LottieAsset): HTMLCanvasElement | HTMLMediaElement | SVGElement | 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 _createProxyImage;
    private createImgData;
    private getAssetsPath;
    private testImageLoaded;
}

declare class AnimationItem extends BaseEvent {
    __complete?: boolean;
    _isFirstFrame?: number;
    animationData: AnimationData;
    animationID: string;
    assets: LottieAsset[];
    assetsPath: string;
    audioController: AudioController;
    autoplay: boolean;
    container?: undefined | HTMLCanvasElement;
    currentFrame: number;
    currentRawFrame: number;
    drawnFrameEvent: 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 | HybridRenderer;
    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;
    protected onComplete: null | ((arg: unknown) => void);
    protected onDestroy: null | ((arg: unknown) => void);
    protected onEnterFrame: null | ((arg: unknown) => void);
    protected onLoopComplete: null | ((arg: unknown) => void);
    protected onSegmentStart: null | ((arg: unknown) => void);
    private _completedLoop;
    private _idle;
    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 | undefined;
    getAssetsPath(assetData: null | LottieAsset): string;
    getDuration(isFrame?: boolean): number;
    getMarkerData(markerName: number): MarkerData | null | undefined;
    getPath(): string;
    getVolume(): number;
    goToAndPlay(value: number, isFrame?: boolean, name?: string): void;
    goToAndStop(value: number, 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, animationDatFromProps?: 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: AnimationEventName): void;
    triggerConfigError(nativeError: unknown): void;
    triggerRenderFrameError(nativeError: unknown): void;
    unmute(name?: string): void;
    updaFrameModifier(): void;
    updateDocumentData(path: unknown[], documentData: DocumentData, index: number): void;
    waitForFontsLoaded(): void;
}

declare function initExpressions(animation: AnimationItem): void;
declare const Expressions: {
    initExpressions: typeof initExpressions;
    resetFrame: () => void;
};

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?: boolean): void;
declare function renderFill(_: Shape, itemData?: SVGFillStyleData, isFirstFrame?: boolean): void;
declare function renderGradient(styleData: Shape, itemData?: SVGGradientFillStyleData, isFirstFrame?: boolean): void;
declare function renderPath(styleData: Shape, itemData?: SVGShapeData, isFirstFrame?: boolean): void;
declare function renderStroke(_: Shape, itemData?: SVGStrokeStyleData | SVGGradientStrokeStyleData, isFirstFrame?: 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: Characacter[] | null;
    fonts: DocumentData[];
    isLoaded: boolean;
    typekitLoaded: number;
    private _warned;
    private checkLoadedFontsBinded;
    private initTime;
    private setIsLoadedBinded;
    constructor();
    addChars(chars?: null | Characacter[]): void;
    addFonts(fontData?: {
        list: DocumentData[];
    }, defs?: HTMLElement | SVGDefsElement): void;
    getCharData(char: Characacter | string, style?: string, font?: string): Characacter;
    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;
    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;
}

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;
type AnimationEventName = 'drawnFrame' | 'enterFrame' | 'loopComplete' | 'complete' | 'segmentStart' | 'destroy' | 'config_ready' | 'data_ready' | 'DOMLoaded' | 'error' | 'data_failed' | 'loaded_images' | '_play' | '_pause' | '_idle' | '_active' | 'configError' | 'renderFrameError';
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 & HybridRenderer;
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 ThreeDElement {
    container: HTMLElement;
    perspectiveElem: HTMLElement;
    type: string;
}
interface AnimatedContent {
    data: Shape;
    element: ShapeDataInterface | SVGElementInterface;
    fn: null | CreateRenderFunction;
}
type CompElementInterface = BaseRenderer | CVCompElement | HCompElement | 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 ThreeDElements {
    container: HTMLElement;
    endPos: number;
    perspectiveElem: HTMLDivElement;
    startPos: number;
    type: string;
}
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.HTML | 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;
        html: HTMLRendererConfig;
    }[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<Vector1 | 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 | KeyframedShapeProperty | 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 Vector1 = number;
type Vector2 = [number, number];
type Vector3 = [number, number, number];
type Vector4 = [number, number, number, number];
interface VectorProperty<T = Vector1> {
    _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: any;
    };
    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 Characacter {
    ch?: undefined | Characacter;
    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: Characacter[] | 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 | Characacter[];
    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 BoundingBox {
    h: number;
    height: number;
    w: number;
    width: number;
    x: number;
    xMax: number;
    y: number;
    yMax: 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 | 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?: undefined | null | string | ArrayBuffer;
    success: boolean;
}
declare global {
    interface Document {
        _isProxy?: boolean;
    }
}

declare function destroy(animation?: string): void;
declare function freeze(): void;
declare function getRegisteredAnimations(): (AnimationItem | undefined)[];
declare function goToAndStop(value: number, isFrame?: boolean, animation?: string): void;
declare function loadAnimation(params: AnimationConfiguration): AnimationItem;
declare function mute(animation?: string): void;
declare function pause(animation?: string): void;
declare function play(animation?: string): void;
declare function registerAnimation(element: HTMLElement | null, animationData?: AnimationData): AnimationItem | null | undefined;
declare function resize(): void;
declare function setDirection(val: AnimationDirection, animation?: string): void;
declare function setSpeed(val: number, animation?: string): void;
declare function setVolume(val: number, animation?: string): void;
declare function stop(animation?: string): void;
declare function togglePause(animation?: string): void;
declare function unfreeze(): void;
declare function unmute(animation?: string): void;

declare const installPlugin: (type: string, plugin: typeof Expressions) => void;
declare const setSubframeRendering: (flag: boolean) => void;
declare const Lottie: {
    destroy: typeof destroy;
    freeze: typeof freeze;
    getRegisteredAnimations: typeof getRegisteredAnimations;
    goToAndStop: typeof goToAndStop;
    installPlugin: (type: string, plugin: typeof Expressions) => void;
    loadAnimation: typeof loadAnimation;
    mute: typeof mute;
    pause: typeof pause;
    play: typeof play;
    registerAnimation: typeof registerAnimation;
    resize: typeof resize;
    setDirection: typeof setDirection;
    setLocationHref: (value: string) => void;
    setPrefix: (value: string) => void;
    setQuality: (value: string | number) => void;
    setSpeed: typeof setSpeed;
    setSubframeRendering: (flag: boolean) => void;
    setVolume: typeof setVolume;
    stop: typeof stop;
    togglePause: typeof togglePause;
    unfreeze: typeof unfreeze;
    unmute: typeof unmute;
    useWebWorker: (flag: boolean) => void;
    version: string;
};

export { AnimationItem, Lottie as default, installPlugin, loadAnimation, setSubframeRendering };
export type { AddAnimationParams, AnimationConfiguration, AnimationData, AnimationDirection, Vector2 as AnimationSegment, AnimationSettings, ConvertParams, LottieAnimation, LottieAsset, LottieManifest, Result, Vector2 };