import { type INode, AccessorType, MeshPrimitiveMode } from "babylonjs-gltf2interface";
import { type FloatArray, type DataArray, type IndicesArray, type DeepImmutable } from "@babylonjs/core/types.js";
import { type Vector4, Quaternion, Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
import { type AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
import { type Node } from "@babylonjs/core/node.js";
import { TargetCamera } from "@babylonjs/core/Cameras/targetCamera.js";
import { type ShadowLight } from "@babylonjs/core/Lights/shadowLight.js";
import { type AreaLight } from "@babylonjs/core/Lights/areaLight.js";
export declare const DefaultTranslation: import("@babylonjs/core/types.js").DeepImmutableObject<Vector3>;
export declare const DefaultRotation: DeepImmutable<Quaternion>;
export declare const DefaultScale: import("@babylonjs/core/types.js").DeepImmutableObject<Vector3>;
/**
 * Get the information necessary for enumerating a vertex buffer.
 * @param vertexBuffer the vertex buffer to enumerate
 * @param meshes the meshes that use the vertex buffer
 * @returns the information necessary to enumerate the vertex buffer
 */
export declare function GetVertexBufferInfo(vertexBuffer: VertexBuffer, meshes: AbstractMesh[]): {
    byteOffset: number;
    byteStride: number;
    componentCount: number;
    type: number;
    count: number;
    normalized: boolean;
    totalVertices: number;
    kind: string;
};
export declare function GetAccessorElementCount(accessorType: AccessorType): number;
export declare function FloatsNeed16BitInteger(floatArray: FloatArray): boolean;
export declare function IsStandardVertexAttribute(type: string): boolean;
export declare function GetAccessorType(kind: string, hasVertexColorAlpha: boolean): AccessorType;
export declare function GetAttributeType(kind: string): string;
export declare function GetPrimitiveMode(fillMode: number): MeshPrimitiveMode;
export declare function IsTriangleFillMode(fillMode: number): boolean;
export declare function NormalizeTangent(tangent: Vector4 | Vector3): void;
export declare function ConvertToRightHandedPosition(value: Vector3): Vector3;
/** @internal */
export declare function ConvertToRightHandedTransformMatrix(matrix: Matrix): Matrix;
/**
 * Converts, in-place, a left-handed quaternion to a right-handed quaternion via a change of basis.
 * @param value the unit quaternion to convert
 * @returns the converted quaternion
 */
export declare function ConvertToRightHandedRotation(value: Quaternion): Quaternion;
/**
 * Pre-multiplies a 180-degree Y rotation to the quaternion, in order to match glTF's flipped forward direction for cameras.
 * @param rotation Target camera rotation.
 */
export declare function Rotate180Y(rotation: Quaternion): void;
/**
 * Collapses GLTF parent and node into a single node, ignoring scaling.
 * This is useful for removing nodes that were added by the GLTF importer.
 * @param node Original GLTF node (Light or Camera).
 * @param parentNode Target parent node.
 */
export declare function CollapseChildIntoParent(node: INode, parentNode: INode): void;
/**
 * Checks whether a camera or light node is candidate for collapsing with its parent node.
 * This is useful for roundtrips, as the glTF Importer parents a new node to
 * lights and cameras to store their original transformation information.
 * @param babylonNode Babylon light or camera node.
 * @param parentBabylonNode Target Babylon parent node.
 * @returns True if the two nodes can be merged, false otherwise.
 */
export declare function IsChildCollapsible(babylonNode: ShadowLight | TargetCamera | AreaLight, parentBabylonNode: Node): boolean;
/**
 * Converts an IndicesArray into either a Uint32Array or Uint16Array.
 * If the `start` and `count` parameters specify a subset of the array, a new view is created.
 * If the input is a number[], the data is copied into a new buffer.
 * @param indices input array to be converted
 * @param start starting index
 * @param count number of indices
 * @param is32Bits whether the output should be Uint32Array (true) or Uint16Array (false) when indices is an `Array`
 * @returns a Uint32Array or Uint16Array
 * @internal
 */
export declare function IndicesArrayToTypedSubarray(indices: IndicesArray, start: number, count: number, is32Bits: boolean): Uint32Array | Uint16Array;
export declare function DataArrayToUint8Array(data: DataArray): Uint8Array;
export declare function GetMinMax(data: DataArray, vertexBuffer: VertexBuffer, start: number, count: number): {
    min: number[];
    max: number[];
};
/**
 * Removes, in-place, object properties which have the same value as the default value.
 * Useful for avoiding unnecessary properties in the glTF JSON.
 * @param object the object to omit default values from
 * @param defaultValues a partial object with default values
 * @returns object with default values omitted
 */
export declare function OmitDefaultValues<T extends object>(object: T, defaultValues: Partial<T>): T;