import * as react from 'react';
import * as THREE from 'three';
import { TextOptions as TextOptions$1, ThreeTextGeometryInfo, Text as Text$2 } from './index';

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

declare class Vec3 {
    x: number;
    y: number;
    z: number;
    constructor(x?: number, y?: number, z?: number);
    set(x: number, y: number, z: number): Vec3;
    clone(): Vec3;
    copy(v: Vec3): Vec3;
    add(v: Vec3): Vec3;
    sub(v: Vec3): Vec3;
    multiply(scalar: number): Vec3;
    divide(scalar: number): Vec3;
    length(): number;
    lengthSq(): number;
    normalize(): Vec3;
    dot(v: Vec3): number;
    cross(v: Vec3): Vec3;
    distanceTo(v: Vec3): number;
    distanceToSquared(v: Vec3): number;
    equals(v: Vec3): boolean;
}

interface HarfBuzzGlyph {
    g: number;
    cl: number;
    ax: number;
    ay: number;
    dx: number;
    dy: number;
    x?: number;
    y?: number;
    lineIndex: number;
    absoluteTextIndex: number;
}
interface GlyphCluster {
    text: string;
    glyphs: HarfBuzzGlyph[];
    position: Vec3;
}
type TextAlign = 'left' | 'center' | 'right' | 'justify';
type TextDirection = 'ltr' | 'rtl';
interface LineInfo {
    text: string;
    originalStart: number;
    originalEnd: number;
    xOffset: number;
    adjustmentRatio?: number;
    isLastLine?: boolean;
    naturalWidth?: number;
    endedWithHyphen?: boolean;
}
interface LoadedFont {
    hb: HarfBuzzAPI;
    fontBlob: HarfBuzzBlob;
    face: HarfBuzzFace;
    font: HarfBuzzFont;
    module: HarfBuzzModule;
    upem: number;
    metrics: ExtractedMetrics;
    fontVariations?: {
        [key: string]: number;
    };
    fontFeatures?: {
        [tag: string]: boolean | number;
    };
    isVariable?: boolean;
    variationAxes?: {
        [key: string]: VariationAxis;
    };
    availableFeatures?: string[];
    featureNames?: {
        [tag: string]: string;
    };
    _buffer?: ArrayBuffer;
}
interface HarfBuzzModule {
    addFunction: (func: Function, signature: string) => number;
    exports: any;
    removeFunction: (ptr: number) => void;
}
interface VariationAxis {
    min: number;
    default: number;
    max: number;
    name?: string;
}
interface HarfBuzzAPI {
    createBlob: (data: Uint8Array) => HarfBuzzBlob;
    createFace: (blob: HarfBuzzBlob, index: number) => HarfBuzzFace;
    createFont: (face: HarfBuzzFace) => HarfBuzzFont;
    createBuffer: () => HarfBuzzBuffer;
    shape: (font: HarfBuzzFont, buffer: HarfBuzzBuffer, features?: string) => void;
}
interface HarfBuzzBlob {
    destroy: () => void;
}
interface HarfBuzzFace {
    destroy: () => void;
    getAxisInfos: () => {
        [tag: string]: VariationAxis;
    };
}
interface HarfBuzzFont {
    ptr: number;
    destroy: () => void;
    setScale: (xScale: number, yScale: number) => void;
    setVariations: (variations: {
        [key: string]: number;
    }) => void;
}
interface HarfBuzzBuffer {
    addText: (text: string) => void;
    guessSegmentProperties: () => void;
    setDirection: (direction: string) => void;
    json: (font: HarfBuzzFont) => any[];
    destroy: () => void;
}
interface HarfBuzzInstance {
    hb: HarfBuzzAPI;
    module: HarfBuzzModule;
}
interface ExtractedMetrics {
    isCFF: boolean;
    unitsPerEm: number;
    hheaAscender: number | null;
    hheaDescender: number | null;
    hheaLineGap: number | null;
    typoAscender: number | null;
    typoDescender: number | null;
    typoLineGap: number | null;
    winAscent: number | null;
    winDescent: number | null;
    axisNames: {
        [tag: string]: string;
    } | null;
}
interface FontMetrics {
    ascender: number;
    descender: number;
    lineGap: number;
    unitsPerEm: number;
    naturalLineHeight: number;
}
interface TextLayoutData {
    lines: LineInfo[];
    scaledLineHeight: number;
    letterSpacing: number;
    align: string;
    direction: TextDirection;
    depth: number;
    size: number;
    pixelsPerFontUnit: number;
}
interface TextLayoutResult {
    clustersByLine: GlyphCluster[][];
    layoutData: TextLayoutData;
    options: TextOptions;
    loadedFont: LoadedFont;
    fontId: string;
}
interface TextLayoutHandle extends TextLayoutResult {
    getLoadedFont(): LoadedFont | undefined;
    measureTextWidth(text: string, letterSpacing?: number): number;
    update(options: Partial<TextOptions>): Promise<TextLayoutHandle>;
    dispose(): void;
}
interface ColorByRange {
    start: number;
    end: number;
    color: [number, number, number];
}
interface ColorOptions {
    default?: [number, number, number];
    byText?: {
        [text: string]: [number, number, number];
    };
    byCharRange?: ColorByRange[];
}
interface TextOptions {
    text: string;
    font: string | ArrayBuffer;
    size?: number;
    depth?: number;
    lineHeight?: number;
    letterSpacing?: number;
    perGlyphAttributes?: boolean;
    fontVariations?: {
        [key: string]: number;
    };
    fontFeatures?: {
        [tag: string]: boolean | number;
    };
    maxTextLength?: number;
    removeOverlaps?: boolean;
    curveSteps?: number;
    curveFidelity?: CurveFidelityConfig;
    geometryOptimization?: GeometryOptimizationOptions;
    layout?: LayoutOptions;
    color?: [number, number, number] | ColorOptions;
    /** Enable rotated RGSS-4 adaptive supersampling (4 samples per pixel). Takes effect when the GLSL rendering path is active. */
    adaptiveSupersampling?: boolean;
}
interface HyphenationPatternsMap {
    [language: string]: HyphenationTrieNode;
}
interface CurveFidelityConfig {
    distanceTolerance?: number;
    angleTolerance?: number;
    cuspLimit?: number;
    collinearityEpsilon?: number;
    recursionLimit?: number;
}
interface GeometryOptimizationOptions {
    enabled?: boolean;
    areaThreshold?: number;
}
interface LayoutOptions {
    width?: number;
    align?: TextAlign;
    direction?: TextDirection;
    respectExistingBreaks?: boolean;
    hyphenate?: boolean;
    language?: string;
    patternsPath?: string;
    tolerance?: number;
    pretolerance?: number;
    emergencyStretch?: number;
    autoEmergencyStretch?: number;
    hyphenationPatterns?: HyphenationPatternsMap;
    lefthyphenmin?: number;
    righthyphenmin?: number;
    linepenalty?: number;
    adjdemerits?: number;
    hyphenpenalty?: number;
    exhyphenpenalty?: number;
    doublehyphendemerits?: number;
}

declare global {
    interface Window {
        hbjs?: any;
        createHarfBuzz?: () => Promise<any>;
    }
}
declare class Text$1 {
    private static patternCache;
    private static hbInitPromise;
    private static fontCache;
    private static fontLoadPromises;
    private static fontRefCounts;
    private static fontCacheMemoryBytes;
    private static maxFontCacheMemoryBytes;
    private static fontIdCounter;
    static enableWoff2(decoder: (data: ArrayBuffer | Uint8Array) => Uint8Array | Promise<Uint8Array>): void;
    private static stableStringify;
    private fontLoader;
    private loadedFont?;
    private currentFontId;
    private currentFontCacheKey?;
    private textShaper?;
    private textLayout?;
    private constructor();
    static setHarfBuzzPath(path: string): void;
    static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
    static init(): Promise<HarfBuzzInstance>;
    static create(options: TextOptions): Promise<TextLayoutHandle>;
    private static retainFont;
    private static releaseFont;
    private static resolveFont;
    private static loadAndCacheFont;
    private static trackFontCacheAdd;
    private static trackFontCacheRemove;
    private static enforceFontCacheMemoryLimit;
    private static generateFontContentHash;
    private setLoadedFont;
    private releaseCurrentFont;
    private loadFont;
    private createLayout;
    private prepareHyphenation;
    private validateOptions;
    private updateFontVariations;
    private prepareLayout;
    getFontMetrics(): FontMetrics;
    static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
    static registerPattern(language: string, pattern: HyphenationTrieNode): void;
    static setMaxFontCacheMemoryMB(limitMB: number): void;
    getLoadedFont(): LoadedFont | undefined;
    measureTextWidth(text: string, letterSpacing?: number): number;
    private resetHelpers;
    destroy(): void;
}

interface ThreeTextProps extends Omit<TextOptions$1, 'text'> {
    children: string;
    font: string | ArrayBuffer;
    material?: THREE.Material;
    position?: [number, number, number];
    rotation?: [number, number, number];
    scale?: [number, number, number];
    onLoad?: (geometry: THREE.BufferGeometry, info: ThreeTextGeometryInfo) => void;
    onError?: (error: Error) => void;
    vertexColors?: boolean;
}

declare const Text: react.ForwardRefExoticComponent<ThreeTextProps & react.RefAttributes<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>> & {
    setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
    setHarfBuzzBuffer: typeof Text$1.setHarfBuzzBuffer;
    init: typeof Text$1.init;
    registerPattern: typeof Text$1.registerPattern;
    preloadPatterns: typeof Text$1.preloadPatterns;
    setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
    enableWoff2: typeof Text$1.enableWoff2;
    create: typeof Text$2.create;
};

export { Text, ThreeTextProps };