@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.d.ts

@@ -0,0 +1,815 @@
+/**
+ * [Specification PR](https://github.com/KhronosGroup/glTF/pull/2147)
+ * !!! Experimental Extension Subject to Changes !!!
+ */
+export class KHR_animation_pointer {
+    /**
+     * @internal
+     */
+    constructor(loader: any);
+    /**
+     * The name of this extension.
+     */
+    name: string;
+    _loader: any;
+    /**
+     * Defines whether this extension is enabled.
+     */
+    get enabled(): any;
+    /** @internal */
+    dispose(): void;
+    /**
+     * Loads a glTF animation channel.
+     * @param context The context when loading the asset
+     * @param animationContext The context of the animation when loading the asset
+     * @param animation The glTF animation property
+     * @param channel The glTF animation channel property
+     * @param onLoad Called for each animation loaded
+     * @returns A void promise that resolves when the load is complete or null if not handled
+     */
+    _loadAnimationChannelAsync(context: any, animationContext: any, animation: any, channel: any, onLoad: any): any;
+    /**
+     * The pointer string is represented by a [JSON pointer](https://datatracker.ietf.org/doc/html/rfc6901).
+     * <animationPointer> := /<rootNode>/<assetIndex>/<propertyPath>
+     * <rootNode> := "nodes" | "materials" | "meshes" | "cameras" | "extensions"
+     * <assetIndex> := <digit> | <name>
+     * <propertyPath> := <extensionPath> | <standardPath>
+     * <extensionPath> := "extensions"/<name>/<standardPath>
+     * <standardPath> := <name> | <name>/<standardPath>
+     * <name> := W+
+     * <digit> := D+
+     *
+     * Examples:
+     *  - "/nodes/0/rotation"
+     *  - "/materials/2/emissiveFactor"
+     *  - "/materials/2/pbrMetallicRoughness/baseColorFactor"
+     *  - "/materials/2/extensions/KHR_materials_emissive_strength/emissiveStrength"
+     */
+    _parseAnimationPointer(context: any, pointer: any): {
+        target: any;
+        properties: {
+            nodes: {
+                __array__: {
+                    translation: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").TransformNodeAnimationPropertyInfo[];
+                    rotation: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").TransformNodeAnimationPropertyInfo[];
+                    scale: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").TransformNodeAnimationPropertyInfo[];
+                    weights: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").WeightAnimationPropertyInfo[];
+                    __target__: boolean;
+                };
+            };
+            materials: {
+                __array__: {
+                    __target__: boolean;
+                    pbrMetallicRoughness: {
+                        baseColorFactor: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        metallicFactor: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        roughnessFactor: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        baseColorTexture: {
+                            extensions: {
+                                KHR_texture_transform: {
+                                    scale: {
+                                        buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                        readonly type: number;
+                                        readonly name: string; /**
+                                         * Loads a glTF animation channel.
+                                         * @param context The context when loading the asset
+                                         * @param animationContext The context of the animation when loading the asset
+                                         * @param animation The glTF animation property
+                                         * @param channel The glTF animation channel property
+                                         * @param onLoad Called for each animation loaded
+                                         * @returns A void promise that resolves when the load is complete or null if not handled
+                                         */
+                                        readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                        readonly getStride: (target: any) => number;
+                                        _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                    }[];
+                                    offset: {
+                                        buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                        readonly type: number;
+                                        readonly name: string; /**
+                                         * Loads a glTF animation channel.
+                                         * @param context The context when loading the asset
+                                         * @param animationContext The context of the animation when loading the asset
+                                         * @param animation The glTF animation property
+                                         * @param channel The glTF animation channel property
+                                         * @param onLoad Called for each animation loaded
+                                         * @returns A void promise that resolves when the load is complete or null if not handled
+                                         */
+                                        readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                        readonly getStride: (target: any) => number;
+                                        _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                    }[];
+                                    rotation: {
+                                        buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                        readonly type: number;
+                                        readonly name: string; /**
+                                         * Loads a glTF animation channel.
+                                         * @param context The context when loading the asset
+                                         * @param animationContext The context of the animation when loading the asset
+                                         * @param animation The glTF animation property
+                                         * @param channel The glTF animation channel property
+                                         * @param onLoad Called for each animation loaded
+                                         * @returns A void promise that resolves when the load is complete or null if not handled
+                                         */
+                                        readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                        readonly getStride: (target: any) => number;
+                                        _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                    }[];
+                                };
+                            };
+                        };
+                    };
+                    emissiveFactor: {
+                        buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                        readonly type: number;
+                        readonly name: string; /**
+                         * Loads a glTF animation channel.
+                         * @param context The context when loading the asset
+                         * @param animationContext The context of the animation when loading the asset
+                         * @param animation The glTF animation property
+                         * @param channel The glTF animation channel property
+                         * @param onLoad Called for each animation loaded
+                         * @returns A void promise that resolves when the load is complete or null if not handled
+                         */
+                        readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                        readonly getStride: (target: any) => number;
+                        _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                    }[];
+                    normalTexture: {
+                        scale: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                    };
+                    occlusionTexture: {
+                        strength: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        extensions: {
+                            KHR_texture_transform: {
+                                scale: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                                offset: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                                rotation: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                            };
+                        };
+                    };
+                    emissiveTexture: {
+                        extensions: {
+                            KHR_texture_transform: {
+                                scale: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                                offset: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                                rotation: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                            };
+                        };
+                    };
+                    extensions: {
+                        KHR_materials_ior: {
+                            ior: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_clearcoat: {
+                            clearcoatFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            clearcoatRoughnessFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_sheen: {
+                            sheenColorFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            sheenRoughnessFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_specular: {
+                            specularFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            specularColorFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_emissive_strength: {
+                            emissiveStrength: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_transmission: {
+                            transmissionFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_volume: {
+                            attenuationColor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            attenuationDistance: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            thicknessFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                        KHR_materials_iridescence: {
+                            iridescenceFactor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            iridescenceIor: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            iridescenceThicknessMinimum: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            iridescenceThicknessMaximum: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IMaterial, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                        };
+                    };
+                };
+            };
+            cameras: {
+                __array__: {
+                    __target__: boolean;
+                    orthographic: {
+                        xmag: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        ymag: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        zfar: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        znear: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                    };
+                    perspective: {
+                        yfov: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        zfar: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                        znear: {
+                            buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").ICamera, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                            readonly type: number;
+                            readonly name: string; /**
+                             * Loads a glTF animation channel.
+                             * @param context The context when loading the asset
+                             * @param animationContext The context of the animation when loading the asset
+                             * @param animation The glTF animation property
+                             * @param channel The glTF animation channel property
+                             * @param onLoad Called for each animation loaded
+                             * @returns A void promise that resolves when the load is complete or null if not handled
+                             */
+                            readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                            readonly getStride: (target: any) => number;
+                            _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                        }[];
+                    };
+                };
+            };
+            extensions: {
+                KHR_lights_punctual: {
+                    lights: {
+                        __array__: {
+                            __target__: boolean;
+                            color: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IKHRLightsPunctual_Light, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            intensity: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IKHRLightsPunctual_Light, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            range: {
+                                buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IKHRLightsPunctual_Light, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                readonly type: number;
+                                readonly name: string; /**
+                                 * Loads a glTF animation channel.
+                                 * @param context The context when loading the asset
+                                 * @param animationContext The context of the animation when loading the asset
+                                 * @param animation The glTF animation property
+                                 * @param channel The glTF animation channel property
+                                 * @param onLoad Called for each animation loaded
+                                 * @returns A void promise that resolves when the load is complete or null if not handled
+                                 */
+                                readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                readonly getStride: (target: any) => number;
+                                _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                            }[];
+                            spot: {
+                                innerConeAngle: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IKHRLightsPunctual_Light, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                                outerConeAngle: {
+                                    buildAnimations(target: import("@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js").IKHRLightsPunctual_Light, name: string, fps: number, keys: any[], callback: (babylonAnimatable: import("@babylonjs/core").IAnimatable, babylonAnimation: import("@babylonjs/core").Animation) => void): void;
+                                    readonly type: number;
+                                    readonly name: string; /**
+                                     * Loads a glTF animation channel.
+                                     * @param context The context when loading the asset
+                                     * @param animationContext The context of the animation when loading the asset
+                                     * @param animation The glTF animation property
+                                     * @param channel The glTF animation channel property
+                                     * @param onLoad Called for each animation loaded
+                                     * @returns A void promise that resolves when the load is complete or null if not handled
+                                     */
+                                    readonly getValue: import("@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js").GetValueFn;
+                                    readonly getStride: (target: any) => number;
+                                    _buildAnimation(name: string, fps: number, keys: any[]): import("@babylonjs/core").Animation;
+                                }[];
+                            };
+                        };
+                    };
+                };
+            };
+        } & any[];
+    } | null;
+}