@nice2dev/ui-tools 1.0.10

package/dist/mathematics.d.ts

@@ -0,0 +1,870 @@
+/**
+ * @file mathematics.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-30 — Mathematics & Advanced Visualization
+ *
+ * Types for formula editors, function plotting, geometry,
+ * linear algebra, statistics, and unit conversion.
+ */
+/** Mathematical expression */
+export interface MathExpression {
+    latex: string;
+    mathml?: string;
+    asciimath?: string;
+    evalResult?: number | Complex | Matrix;
+}
+/** Complex number */
+export interface Complex {
+    real: number;
+    imaginary: number;
+}
+/** Point in 2D */
+export interface Point2D {
+    x: number;
+    y: number;
+}
+/** Point in 3D */
+export interface Point3D {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Vector in 2D */
+export interface Vector2D {
+    x: number;
+    y: number;
+}
+/** Vector in 3D */
+export interface Vector3D {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Matrix */
+export interface Matrix {
+    rows: number;
+    cols: number;
+    data: number[][];
+}
+/** Interval */
+export interface Interval {
+    min: number;
+    max: number;
+    inclusive?: {
+        min: boolean;
+        max: boolean;
+    };
+}
+/** Range for plotting */
+export interface PlotRange {
+    x: Interval;
+    y: Interval;
+    z?: Interval;
+}
+/** Formula editor config */
+export interface FormulaEditorConfig {
+    mode: FormulaEditorMode;
+    initialLatex?: string;
+    symbolPalettes?: SymbolPalette[];
+    templates?: FormulaTemplate[];
+    autoNumbering?: boolean;
+    crossReferences?: boolean;
+    outputFormats?: FormulaOutputFormat[];
+}
+/** Formula editor mode */
+export type FormulaEditorMode = 'visual' | 'latex' | 'hybrid';
+/** Symbol palette */
+export interface SymbolPalette {
+    name: string;
+    category: SymbolCategory;
+    symbols: MathSymbol[];
+}
+/** Symbol category */
+export type SymbolCategory = 'greek_letters' | 'operators' | 'relations' | 'arrows' | 'delimiters' | 'accents' | 'logic' | 'sets' | 'calculus' | 'linear_algebra' | 'geometry' | 'miscellaneous';
+/** Math symbol */
+export interface MathSymbol {
+    name: string;
+    latex: string;
+    unicode?: string;
+    description?: string;
+}
+/** Formula template */
+export interface FormulaTemplate {
+    name: string;
+    category: FormulaTemplateCategory;
+    latex: string;
+    placeholders?: string[];
+    description?: string;
+}
+/** Formula template category */
+export type FormulaTemplateCategory = 'fraction' | 'power' | 'root' | 'integral' | 'sum' | 'product' | 'limit' | 'matrix' | 'equation' | 'piecewise';
+/** Formula output format */
+export type FormulaOutputFormat = 'latex' | 'mathml' | 'asciimath' | 'png' | 'svg' | 'pdf';
+/** Numbered equation */
+export interface NumberedEquation {
+    id: string;
+    number: string;
+    latex: string;
+    label?: string;
+}
+/** Equation solver config */
+export interface EquationSolverConfig {
+    equationType: EquationType;
+    showSteps?: boolean;
+    precision?: number;
+    complexSolutions?: boolean;
+}
+/** Equation type */
+export type EquationType = 'linear' | 'quadratic' | 'polynomial' | 'rational' | 'exponential' | 'logarithmic' | 'trigonometric' | 'system_linear' | 'differential';
+/** Equation solution */
+export interface EquationSolution {
+    equation: string;
+    variable: string;
+    solutions: SolutionValue[];
+    steps?: SolutionStep[];
+    graphData?: FunctionPlotData;
+}
+/** Solution value */
+export interface SolutionValue {
+    value: number | Complex | string;
+    exact?: string;
+    approximate?: number;
+    isComplex?: boolean;
+}
+/** Solution step */
+export interface SolutionStep {
+    stepNumber: number;
+    description: string;
+    equation: string;
+    explanation?: string;
+}
+/** Scientific calculator config */
+export interface ScientificCalculatorConfig {
+    mode: CalculatorMode;
+    angleUnit: AngleUnit;
+    precision: number;
+    scientificNotation?: boolean;
+    showHistory?: boolean;
+    memorySlots?: number;
+}
+/** Calculator mode */
+export type CalculatorMode = 'standard' | 'scientific' | 'programmer' | 'statistics';
+/** Angle unit */
+export type AngleUnit = 'degrees' | 'radians' | 'gradians';
+/** Calculator history entry */
+export interface CalculatorHistoryEntry {
+    id: string;
+    expression: string;
+    result: string;
+    timestamp: Date;
+}
+/** CAS (Computer Algebra System) config */
+export interface CASConfig {
+    backend: CASBackend;
+    timeout?: number;
+    simplifyResults?: boolean;
+    assumeReal?: boolean;
+}
+/** CAS backend */
+export type CASBackend = 'sympy' | 'maxima' | 'mathjs' | 'custom';
+/** CAS operation */
+export type CASOperation = 'simplify' | 'expand' | 'factor' | 'solve' | 'differentiate' | 'integrate' | 'limit' | 'series' | 'substitute';
+/** CAS result */
+export interface CASResult {
+    operation: CASOperation;
+    input: string;
+    output: string;
+    steps?: string[];
+    error?: string;
+}
+/** Function plot 2D config */
+export interface FunctionPlot2DConfig {
+    functions: FunctionDefinition[];
+    range: PlotRange;
+    gridVisible?: boolean;
+    axisLabels?: {
+        x: string;
+        y: string;
+    };
+    aspectRatio?: number;
+    theme?: PlotTheme;
+    interactivity?: PlotInteractivity;
+}
+/** Function definition */
+export interface FunctionDefinition {
+    id: string;
+    expression: string;
+    variable?: string;
+    type: FunctionType;
+    color?: string;
+    lineStyle?: LineStyle;
+    lineWidth?: number;
+    visible?: boolean;
+    label?: string;
+}
+/** Function type */
+export type FunctionType = 'explicit' | 'parametric' | 'polar' | 'implicit';
+/** Line style */
+export type LineStyle = 'solid' | 'dashed' | 'dotted' | 'dashdot';
+/** Plot theme */
+export interface PlotTheme {
+    backgroundColor?: string;
+    axisColor?: string;
+    gridColor?: string;
+    textColor?: string;
+    defaultColors?: string[];
+}
+/** Plot interactivity */
+export interface PlotInteractivity {
+    zoom?: boolean;
+    pan?: boolean;
+    trace?: boolean;
+    tooltip?: boolean;
+    clickToAdd?: boolean;
+}
+/** Function plot data */
+export interface FunctionPlotData {
+    points: Point2D[];
+    discontinuities?: number[];
+    asymptotes?: Asymptote[];
+    criticalPoints?: CriticalPoint[];
+}
+/** Asymptote */
+export interface Asymptote {
+    type: AsymptoteType;
+    value: number;
+    equation?: string;
+}
+/** Asymptote type */
+export type AsymptoteType = 'vertical' | 'horizontal' | 'oblique';
+/** Critical point */
+export interface CriticalPoint {
+    x: number;
+    y: number;
+    type: CriticalPointType;
+}
+/** Critical point type */
+export type CriticalPointType = 'maximum' | 'minimum' | 'inflection' | 'root' | 'undefined';
+/** Area shading */
+export interface AreaShading {
+    function1: string;
+    function2?: string;
+    xRange: Interval;
+    color?: string;
+    opacity?: number;
+}
+/** Function plot 3D config */
+export interface FunctionPlot3DConfig {
+    surfaces: Surface3DDefinition[];
+    range: PlotRange;
+    renderMode: Render3DMode;
+    lighting?: Lighting3D;
+    camera?: Camera3D;
+    interactivity?: Plot3DInteractivity;
+}
+/** Surface 3D definition */
+export interface Surface3DDefinition {
+    id: string;
+    expression: string;
+    type: Surface3DType;
+    colorMap?: ColorMap;
+    opacity?: number;
+    wireframe?: boolean;
+    resolution?: number;
+}
+/** Surface 3D type */
+export type Surface3DType = 'explicit' | 'parametric' | 'implicit';
+/** Render 3D mode */
+export type Render3DMode = 'surface' | 'wireframe' | 'points' | 'contour';
+/** Color map */
+export type ColorMap = 'viridis' | 'plasma' | 'inferno' | 'magma' | 'rainbow' | 'jet' | 'grayscale' | 'coolwarm';
+/** 3D lighting */
+export interface Lighting3D {
+    ambient: number;
+    diffuse: number;
+    specular: number;
+    lightPosition: Point3D;
+}
+/** 3D camera */
+export interface Camera3D {
+    position: Point3D;
+    target: Point3D;
+    up: Vector3D;
+    fov: number;
+}
+/** Plot 3D interactivity */
+export interface Plot3DInteractivity {
+    rotate?: boolean;
+    zoom?: boolean;
+    pan?: boolean;
+    autoRotate?: boolean;
+    rotateSpeed?: number;
+}
+/** Vector field config */
+export interface VectorFieldConfig {
+    expression: VectorFieldExpression;
+    range: PlotRange;
+    density: number;
+    arrowScale?: number;
+    colorByMagnitude?: boolean;
+    colorMap?: ColorMap;
+    showStreamlines?: boolean;
+    streamlineCount?: number;
+}
+/** Vector field expression */
+export interface VectorFieldExpression {
+    u: string;
+    v: string;
+    w?: string;
+}
+/** Complex plot config */
+export interface ComplexPlotConfig {
+    function: string;
+    range: PlotRange;
+    plotType: ComplexPlotType;
+    resolution?: number;
+    contourLevels?: number;
+}
+/** Complex plot type */
+export type ComplexPlotType = 'domain_coloring' | 'modulus' | 'argument' | 'real_part' | 'imaginary_part' | 'riemann_surface';
+/** Geometry canvas config */
+export interface GeometryCanvasConfig {
+    width: number;
+    height: number;
+    coordinateSystem: CoordinateSystem;
+    gridVisible?: boolean;
+    snapToGrid?: boolean;
+    snapToPoints?: boolean;
+    tools?: GeometryTool[];
+    theme?: GeometryTheme;
+}
+/** Coordinate system */
+export interface CoordinateSystem {
+    origin: Point2D;
+    unitLength: number;
+    xRange: Interval;
+    yRange: Interval;
+}
+/** Geometry tool */
+export type GeometryTool = 'select' | 'point' | 'line' | 'ray' | 'segment' | 'circle' | 'arc' | 'ellipse' | 'polygon' | 'angle' | 'perpendicular' | 'parallel' | 'bisector' | 'midpoint' | 'compass' | 'measure' | 'label' | 'trace' | 'locus';
+/** Geometry theme */
+export interface GeometryTheme {
+    backgroundColor?: string;
+    gridColor?: string;
+    axisColor?: string;
+    defaultPointColor?: string;
+    defaultLineColor?: string;
+    defaultFillColor?: string;
+    selectedColor?: string;
+    constructionColor?: string;
+}
+/** Geometry object */
+export interface GeometryObject {
+    id: string;
+    type: GeometryObjectType;
+    label?: string;
+    visible?: boolean;
+    style?: GeometryStyle;
+    dependencies?: string[];
+    definition?: GeometryDefinition;
+}
+/** Geometry object type */
+export type GeometryObjectType = 'point' | 'line' | 'ray' | 'segment' | 'circle' | 'arc' | 'ellipse' | 'polygon' | 'angle' | 'text' | 'measurement';
+/** Geometry style */
+export interface GeometryStyle {
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: LineStyle;
+    fillColor?: string;
+    fillOpacity?: number;
+    pointSize?: number;
+    fontSize?: number;
+}
+/** Geometry definition - union type for different objects */
+export type GeometryDefinition = PointDefinition | LineDefinition | CircleDefinition | PolygonDefinition | AngleDefinition;
+/** Point definition */
+export interface PointDefinition {
+    type: 'point';
+    x: number;
+    y: number;
+    constraint?: PointConstraint;
+}
+/** Point constraint */
+export type PointConstraint = {
+    type: 'free';
+} | {
+    type: 'on_line';
+    lineId: string;
+} | {
+    type: 'on_circle';
+    circleId: string;
+} | {
+    type: 'intersection';
+    object1Id: string;
+    object2Id: string;
+} | {
+    type: 'midpoint';
+    point1Id: string;
+    point2Id: string;
+};
+/** Line definition */
+export interface LineDefinition {
+    type: 'line' | 'ray' | 'segment';
+    point1: Point2D | string;
+    point2: Point2D | string;
+}
+/** Circle definition */
+export interface CircleDefinition {
+    type: 'circle';
+    center: Point2D | string;
+    radius?: number;
+    radiusPoint?: string;
+}
+/** Polygon definition */
+export interface PolygonDefinition {
+    type: 'polygon';
+    vertices: (Point2D | string)[];
+}
+/** Angle definition */
+export interface AngleDefinition {
+    type: 'angle';
+    point1: string;
+    vertex: string;
+    point2: string;
+}
+/** Geometry transformation */
+export interface GeometryTransformation {
+    type: TransformationType;
+    parameters: TransformationParameters;
+}
+/** Transformation type */
+export type TransformationType = 'translate' | 'rotate' | 'reflect' | 'scale' | 'shear';
+/** Transformation parameters */
+export type TransformationParameters = {
+    type: 'translate';
+    vector: Vector2D;
+} | {
+    type: 'rotate';
+    center: Point2D;
+    angle: number;
+} | {
+    type: 'reflect';
+    line: LineDefinition;
+} | {
+    type: 'scale';
+    center: Point2D;
+    factor: number;
+} | {
+    type: 'shear';
+    axis: 'x' | 'y';
+    factor: number;
+};
+/** Triangle calculation input */
+export interface TriangleInput {
+    a?: number;
+    b?: number;
+    c?: number;
+    A?: number;
+    B?: number;
+    C?: number;
+}
+/** Triangle calculation result */
+export interface TriangleResult {
+    sides: {
+        a: number;
+        b: number;
+        c: number;
+    };
+    angles: {
+        A: number;
+        B: number;
+        C: number;
+    };
+    area: number;
+    perimeter: number;
+    inradius: number;
+    circumradius: number;
+    centroid: Point2D;
+    orthocenter: Point2D;
+    incenter: Point2D;
+    circumcenter: Point2D;
+    vertices: {
+        A: Point2D;
+        B: Point2D;
+        C: Point2D;
+    };
+    type: TriangleType;
+}
+/** Triangle type */
+export type TriangleType = 'equilateral' | 'isosceles' | 'scalene' | 'right' | 'acute' | 'obtuse';
+/** Line equation */
+export interface LineEquation {
+    slope?: number;
+    yIntercept?: number;
+    xIntercept?: number;
+    general?: {
+        a: number;
+        b: number;
+        c: number;
+    };
+    parametric?: {
+        x0: number;
+        y0: number;
+        dx: number;
+        dy: number;
+    };
+}
+/** Circle equation */
+export interface CircleEquation {
+    center: Point2D;
+    radius: number;
+    general?: {
+        a: number;
+        b: number;
+        c: number;
+    };
+}
+/** Matrix editor config */
+export interface MatrixEditorConfig {
+    rows: number;
+    cols: number;
+    allowResize?: boolean;
+    maxRows?: number;
+    maxCols?: number;
+    showRowHeaders?: boolean;
+    showColHeaders?: boolean;
+    cellFormat?: MatrixCellFormat;
+}
+/** Matrix cell format */
+export type MatrixCellFormat = 'decimal' | 'fraction' | 'scientific' | 'integer';
+/** Matrix calculator operation */
+export type MatrixOperation = 'add' | 'subtract' | 'multiply' | 'scalar_multiply' | 'transpose' | 'inverse' | 'determinant' | 'rank' | 'trace' | 'power' | 'lu_decomposition' | 'qr_decomposition' | 'svd' | 'eigendecomposition' | 'row_reduce';
+/** Matrix operation result */
+export interface MatrixOperationResult {
+    operation: MatrixOperation;
+    inputs: Matrix[];
+    result: Matrix | number;
+    steps?: MatrixStep[];
+    error?: string;
+}
+/** Matrix step */
+export interface MatrixStep {
+    stepNumber: number;
+    description: string;
+    matrix: Matrix;
+    operation?: string;
+    rowOperations?: RowOperation[];
+}
+/** Row operation */
+export interface RowOperation {
+    type: RowOperationType;
+    row1: number;
+    row2?: number;
+    scalar?: number;
+}
+/** Row operation type */
+export type RowOperationType = 'swap' | 'scale' | 'add_scaled';
+/** Eigenvalue result */
+export interface EigenvalueResult {
+    eigenvalues: (number | Complex)[];
+    eigenvectors: Matrix[];
+    algebraicMultiplicities?: number[];
+    geometricMultiplicities?: number[];
+}
+/** LU decomposition result */
+export interface LUDecompositionResult {
+    L: Matrix;
+    U: Matrix;
+    P?: Matrix;
+}
+/** QR decomposition result */
+export interface QRDecompositionResult {
+    Q: Matrix;
+    R: Matrix;
+}
+/** SVD result */
+export interface SVDResult {
+    U: Matrix;
+    S: number[];
+    V: Matrix;
+}
+/** Linear transformation demo config */
+export interface LinearTransformationDemoConfig {
+    matrix: Matrix;
+    showGrid?: boolean;
+    showUnitSquare?: boolean;
+    showUnitCircle?: boolean;
+    animationDuration?: number;
+    eigenVectorsVisible?: boolean;
+}
+/** Transformation visualization */
+export interface TransformationVisualization {
+    originalPoints: Point2D[];
+    transformedPoints: Point2D[];
+    eigenvalues?: (number | Complex)[];
+    eigenvectors?: Vector2D[];
+}
+/** Distribution type */
+export type DistributionType = 'normal' | 'binomial' | 'poisson' | 'exponential' | 'uniform' | 'chi_squared' | 't_distribution' | 'f_distribution' | 'beta' | 'gamma' | 'geometric' | 'negative_binomial' | 'hypergeometric';
+/** Distribution config */
+export interface DistributionConfig {
+    type: DistributionType;
+    parameters: DistributionParameters;
+}
+/** Distribution parameters */
+export type DistributionParameters = {
+    type: 'normal';
+    mean: number;
+    standardDeviation: number;
+} | {
+    type: 'binomial';
+    n: number;
+    p: number;
+} | {
+    type: 'poisson';
+    lambda: number;
+} | {
+    type: 'exponential';
+    lambda: number;
+} | {
+    type: 'uniform';
+    min: number;
+    max: number;
+} | {
+    type: 'chi_squared';
+    degreesOfFreedom: number;
+} | {
+    type: 't_distribution';
+    degreesOfFreedom: number;
+} | {
+    type: 'f_distribution';
+    df1: number;
+    df2: number;
+} | {
+    type: 'beta';
+    alpha: number;
+    beta: number;
+} | {
+    type: 'gamma';
+    shape: number;
+    rate: number;
+} | {
+    type: 'geometric';
+    p: number;
+} | {
+    type: 'negative_binomial';
+    r: number;
+    p: number;
+} | {
+    type: 'hypergeometric';
+    N: number;
+    K: number;
+    n: number;
+};
+/** Distribution plot config */
+export interface DistributionPlotConfig {
+    distributions: DistributionConfig[];
+    plotType: 'pdf' | 'cdf' | 'both';
+    xRange?: Interval;
+    showMean?: boolean;
+    showStdDev?: boolean;
+    showPercentiles?: number[];
+    areaShading?: ProbabilityAreaShading[];
+    compareMode?: boolean;
+}
+/** Probability area shading */
+export interface ProbabilityAreaShading {
+    distributionIndex: number;
+    lowerBound?: number;
+    upperBound?: number;
+    color?: string;
+    label?: string;
+}
+/** Probability calculation */
+export interface ProbabilityCalculation {
+    type: ProbabilityCalculationType;
+    input: ProbabilityInput;
+    result: number;
+    explanation?: string;
+}
+/** Probability calculation type */
+export type ProbabilityCalculationType = 'combinations' | 'permutations' | 'factorial' | 'bayes' | 'conditional' | 'expected_value' | 'variance';
+/** Probability input */
+export type ProbabilityInput = {
+    type: 'combinations';
+    n: number;
+    r: number;
+} | {
+    type: 'permutations';
+    n: number;
+    r: number;
+} | {
+    type: 'factorial';
+    n: number;
+} | {
+    type: 'bayes';
+    priorA: number;
+    conditionalBA: number;
+    priorNotA: number;
+    conditionalBNotA: number;
+} | {
+    type: 'expected_value';
+    values: number[];
+    probabilities: number[];
+} | {
+    type: 'variance';
+    values: number[];
+    probabilities: number[];
+};
+/** Confidence interval config */
+export interface ConfidenceIntervalConfig {
+    type: ConfidenceIntervalType;
+    confidenceLevel: number;
+    sampleData?: number[];
+    sampleMean?: number;
+    sampleStdDev?: number;
+    sampleSize?: number;
+    sampleProportion?: number;
+    populationStdDev?: number;
+}
+/** Confidence interval type */
+export type ConfidenceIntervalType = 'mean_known_sigma' | 'mean_unknown_sigma' | 'proportion' | 'variance';
+/** Confidence interval result */
+export interface ConfidenceIntervalResult {
+    estimate: number;
+    marginOfError: number;
+    lowerBound: number;
+    upperBound: number;
+    standardError: number;
+    criticalValue: number;
+}
+/** Sample size calculation */
+export interface SampleSizeCalculation {
+    type: 'mean' | 'proportion';
+    confidenceLevel: number;
+    marginOfError: number;
+    stdDev?: number;
+    proportion?: number;
+    result: number;
+}
+/** Hypothesis test config */
+export interface HypothesisTestConfig {
+    testType: HypothesisTestType;
+    alternativeHypothesis: AlternativeHypothesis;
+    significanceLevel: number;
+    sampleData?: number[];
+    sampleData2?: number[];
+    parameters?: HypothesisTestParameters;
+}
+/** Hypothesis test type */
+export type HypothesisTestType = 'z_test_one_sample' | 'z_test_two_sample' | 't_test_one_sample' | 't_test_two_sample' | 't_test_paired' | 'proportion_one_sample' | 'proportion_two_sample' | 'chi_squared_goodness_of_fit' | 'chi_squared_independence' | 'anova_one_way' | 'f_test';
+/** Alternative hypothesis */
+export type AlternativeHypothesis = 'two_tailed' | 'left_tailed' | 'right_tailed';
+/** Hypothesis test parameters */
+export interface HypothesisTestParameters {
+    nullValue?: number;
+    populationStdDev?: number;
+    pooledVariance?: boolean;
+    expectedFrequencies?: number[];
+    observedFrequencies?: number[] | number[][];
+}
+/** Hypothesis test result */
+export interface HypothesisTestResult {
+    testStatistic: number;
+    pValue: number;
+    criticalValue: number;
+    degreesOfFreedom?: number;
+    rejectNull: boolean;
+    confidenceInterval?: ConfidenceIntervalResult;
+    conclusion: string;
+    interpretation: string;
+}
+/** Unit converter config */
+export interface UnitConverterConfig {
+    categories: UnitCategory[];
+    favorites?: string[];
+    customUnits?: CustomUnit[];
+    liveCurrencyRates?: boolean;
+    currencyApiKey?: string;
+}
+/** Unit category */
+export type UnitCategory = 'length' | 'mass' | 'volume' | 'area' | 'temperature' | 'speed' | 'time' | 'force' | 'energy' | 'power' | 'pressure' | 'frequency' | 'data' | 'angle' | 'currency';
+/** Unit definition */
+export interface UnitDefinition {
+    id: string;
+    name: string;
+    symbol: string;
+    category: UnitCategory;
+    siBase?: boolean;
+    toSI: number | ((value: number) => number);
+    fromSI: number | ((value: number) => number);
+}
+/** Custom unit */
+export interface CustomUnit {
+    id: string;
+    name: string;
+    symbol: string;
+    category: UnitCategory;
+    baseUnit: string;
+    conversionFactor: number;
+}
+/** Unit conversion */
+export interface UnitConversion {
+    value: number;
+    fromUnit: string;
+    toUnit: string;
+    result: number;
+    formula?: string;
+}
+/** Dimension analysis */
+export interface DimensionAnalysis {
+    expression: string;
+    dimensions: DimensionVector;
+    isValid: boolean;
+    simplifiedUnit?: string;
+}
+/** Dimension vector (M, L, T, I, Θ, N, J) */
+export interface DimensionVector {
+    mass: number;
+    length: number;
+    time: number;
+    current: number;
+    temperature: number;
+    amount: number;
+    luminosity: number;
+}
+/** Physical constant */
+export interface PhysicalConstant {
+    id: string;
+    name: string;
+    symbol: string;
+    value: number;
+    unit: string;
+    uncertainty?: number;
+    category: ConstantCategory;
+    description?: string;
+    wikiUrl?: string;
+}
+/** Constant category */
+export type ConstantCategory = 'mathematical' | 'fundamental' | 'electromagnetic' | 'atomic' | 'physico_chemical' | 'astronomical' | 'thermodynamic';
+/** Mathematical constant */
+export interface MathematicalConstant {
+    id: string;
+    name: string;
+    symbol: string;
+    value: number;
+    latex?: string;
+    digits?: string;
+    properties?: string[];
+    description?: string;
+}
+/** Constants reference config */
+export interface ConstantsReferenceConfig {
+    categories?: ConstantCategory[];
+    searchEnabled?: boolean;
+    copyFormat?: ConstantCopyFormat;
+    precision?: number;
+}
+/** Constant copy format */
+export type ConstantCopyFormat = 'value' | 'symbol' | 'latex' | 'name_value';
+//# sourceMappingURL=mathematics.d.ts.map