import { Text as Text$1 } from '../core/Text';
import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont, TextOptions } from '../core/types';
export { LoadedFont, TextOptions, VectorGlyphInfo } from '../core/types';
import * as THREE from 'three';

interface BoundingBox {
    min: {
        x: number;
        y: number;
        z: number;
    };
    max: {
        x: number;
        y: number;
        z: number;
    };
}

interface QuadraticSegment {
    p0x: number;
    p0y: number;
    p1x: number;
    p1y: number;
    p2x: number;
    p2y: number;
}
interface ContourVertex {
    x: number;
    y: number;
}
interface VectorContour {
    vertices: ContourVertex[];
    segments: QuadraticSegment[];
}
interface VectorGlyphAttributes {
    glyphCenter: Float32Array;
    glyphIndex: Float32Array;
    glyphProgress: Float32Array;
    glyphLineIndex: Float32Array;
    glyphBaselineY: Float32Array;
}
interface GlyphRange {
    interiorIndexStart: number;
    interiorIndexCount: number;
    curveVertexStart: number;
    curveVertexCount: number;
}
interface VectorGeometryData {
    interiorPositions: Float32Array;
    interiorIndices: Uint32Array;
    curvePositions: Float32Array;
    fillPositions: Float32Array;
    fillIndices: Uint32Array;
    glyphRanges: GlyphRange[];
    interiorGlyphAttrs?: VectorGlyphAttributes;
    curveGlyphAttrs?: VectorGlyphAttributes;
    fillGlyphAttrs?: VectorGlyphAttributes;
    planeBounds: BoundingBox;
    stats: {
        glyphCount: number;
        contourCount: number;
        interiorTriangleCount: number;
        curveTriangleCount: number;
    };
}
interface LoopBlinnGlyphInput {
    offsetX: number;
    offsetY: number;
    segments: QuadraticSegment[];
    bounds: {
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
    };
    lineIndex: number;
    baselineY: number;
}
interface LoopBlinnInput {
    glyphs: LoopBlinnGlyphInput[];
    planeBounds: BoundingBox;
}
declare function extractContours(segments: QuadraticSegment[]): VectorContour[];
declare function buildVectorGeometry(input: LoopBlinnInput): VectorGeometryData;

interface HyphenationTrieNode {
    patterns: number[] | null;
    children: {
        [char: string]: HyphenationTrieNode;
    };
}

interface VectorTextResult {
    glyphs: VectorGlyphInfo[];
    geometryData: VectorGeometryData;
    query(options: TextQueryOptions): TextRange[];
    getLoadedFont(): LoadedFont | undefined;
    measureTextWidth(text: string, letterSpacing?: number): number;
    update(options: Partial<TextOptions>): Promise<VectorTextResult>;
    dispose(): void;
}
declare class Text {
    static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
    static setHarfBuzzBuffer: typeof Text$1.setHarfBuzzBuffer;
    static init: typeof Text$1.init;
    static registerPattern: typeof Text$1.registerPattern;
    static preloadPatterns: typeof Text$1.preloadPatterns;
    static setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
    static enableWoff2: typeof Text$1.enableWoff2;
    static create(options: TextOptions): Promise<VectorTextResult>;
}

interface VectorMeshOptions {
    color?: THREE.ColorRepresentation;
    positionNode?: any;
    colorNode?: any;
    center?: boolean;
}
interface VectorMeshes {
    group: THREE.Group;
    interiorMesh: THREE.Object3D;
    curveMesh: THREE.Object3D;
    fillMesh: THREE.Mesh;
    interiorGeometry: THREE.BufferGeometry;
    curveGeometry: THREE.BufferGeometry;
    fillGeometry: THREE.BufferGeometry;
    setOffset(x: number, y: number, z?: number): void;
    updateMaterials(options?: VectorMeshOptions): void;
    dispose(): void;
}
declare const loopBlinnFragment: any;
declare function createVectorMeshes(data: VectorGeometryData, options?: VectorMeshOptions | THREE.ColorRepresentation): VectorMeshes;

export { GlyphRange, HyphenationTrieNode, LoopBlinnGlyphInput, LoopBlinnInput, QuadraticSegment, Text, VectorTextResult as TextGeometryInfo, VectorContour, VectorGeometryData, VectorGlyphAttributes, VectorMeshOptions, VectorMeshes, VectorTextResult, buildVectorGeometry, createVectorMeshes, extractContours, loopBlinnFragment };