/**
 * Symbolic CAS (Computer Algebra System) Functions
 *
 * Provides 28 symbolic/semi-symbolic math functions for calculus, transforms,
 * series expansions, equation solving, and advanced algebra. Functions work
 * with expression strings and use numerical evaluation via the expression
 * evaluator when symbolic approaches are not feasible.
 *
 * Categories:
 * - Calculus (8): integrate, limit, partialDerivative, directionalDerivative,
 *   gradientSymbolic, jacobian, laplacian, divergence
 * - Transforms (4): laplace, inverseLaplace, fourierSeries, zTransform
 * - Series (4): taylor, multivariateTaylor, series, seriesCoefficient
 * - Solver (4): solve, implicitDiff, summation, symbolicProduct
 * - Advanced (8): assume, asymptotic, groebnerBasis, minimalPolynomial,
 *   toRadicals, piecewise, odeGeneral, curl
 * - Batch CAS (4): simplify, derivative, expand, factor — with worker fan-out
 *   for arrays of length ≥ 16 (Slice 5.14).
 *
 * @packageDocumentation
 */
import { parse } from '../factories/evaluate.js';
import { Complex } from '@danielsimonjr/mathts-core';
import { type VectorField } from '../numeric/numeric-jacobian.js';
type f64 = number;
type MathNode = ReturnType<typeof parse>;
/**
 * Symbolic/numerical integration.
 *
 * For basic symbolic forms (polynomials, trig, exp), returns the symbolic
 * antiderivative. For definite integrals (a, b provided), falls back to
 * numerical integration using Simpson's rule.
 *
 * @param expr - Expression string to integrate
 * @param varName - Variable of integration
 * @param a - Optional lower bound (definite integral)
 * @param b - Optional upper bound (definite integral)
 * @returns Symbolic antiderivative string or numerical result
 *
 * @example
 * integrate('x^2', 'x')          // => 'x^3/3'
 * integrate('sin(x)', 'x')       // => '-cos(x)'
 * integrate('x^2', 'x', 0, 1)   // => 0.3333...
 */
export declare function integrate(expr: string, varName: string, a?: f64, b?: f64): string | f64;
/**
 * Compute symbolic limits using numerical approach and L'Hopital's rule.
 *
 * Handles standard limits, 0/0 indeterminate forms via L'Hopital,
 * and one-sided limits.
 *
 * @param expr - Expression string
 * @param varName - Variable approaching the limit
 * @param value - Value being approached (can be Infinity or -Infinity)
 * @param dir - Direction: 'left', 'right', or undefined for both
 * @returns The limit value
 *
 * @example
 * limit('sin(x)/x', 'x', 0)        // => 1
 * limit('1/x', 'x', 0, 'right')    // => Infinity
 * limit('(x^2-1)/(x-1)', 'x', 1)   // => 2
 */
export declare function limit(expr: string, varName: string, value: f64, dir?: 'left' | 'right'): f64;
/**
 * Compute the partial derivative of an expression with respect to a variable.
 *
 * Uses numerical differentiation (4th-order central difference).
 * Returns the derivative as a function that can be evaluated at a point.
 *
 * @param expr - Expression string
 * @param varName - Variable to differentiate with respect to
 * @param scope - Variable values at which to evaluate
 * @returns Numerical value of the partial derivative
 *
 * @example
 * partialDerivative('x^2 + y^2', 'x', { x: 3, y: 4 }) // => 6
 * partialDerivative('sin(x*y)', 'x', { x: 0, y: 1 })   // => 1
 */
export declare function partialDerivative(expr: string, varName: string, scope: Record<string, f64>): f64;
/**
 * Compute the directional derivative of an expression.
 *
 * The directional derivative is the dot product of the gradient with
 * the (normalized) direction vector.
 *
 * @param expr - Expression string
 * @param vars - Variable names
 * @param direction - Direction vector (will be normalized)
 * @param scope - Variable values at which to evaluate
 * @returns Directional derivative value
 *
 * @example
 * directionalDerivative('x^2 + y^2', ['x', 'y'], [1, 0], { x: 3, y: 4 }) // => 6
 */
export declare function directionalDerivative(expr: string, vars: string[], direction: f64[], scope: Record<string, f64>): f64;
/**
 * Compute the symbolic gradient vector of an expression.
 *
 * Returns an array of partial derivative values at the given point.
 *
 * @param expr - Expression string
 * @param vars - Variable names
 * @param scope - Variable values at which to evaluate
 * @returns Array of partial derivative values
 *
 * @example
 * gradientSymbolic('x^2 + y^2', ['x', 'y'], { x: 3, y: 4 }) // => [6, 8]
 */
export declare function gradientSymbolic(expr: string, vars: string[], scope: Record<string, f64>): f64[];
/**
 * Compute the Jacobian matrix of a vector-valued function.
 *
 * Polymorphic: symbolic when `exprs` is an array of expression strings
 * (J[i][j] = partial derivative of exprs[i] with respect to vars[j]);
 * numeric (central differences) when `exprs` is a plain function
 * `f: number[] => number[]` — dispatches to `numericJacobian(f, x0)`.
 *
 * @param exprs - Array of expression strings (vector field components), OR a
 *   numeric vector field `f: (x: number[]) => number[]`
 * @param vars - Variable names (symbolic), OR the numeric evaluation point `x0`
 * @param scope - Variable values at which to evaluate (symbolic path only)
 * @returns 2D array (matrix) of partial derivatives
 *
 * @example
 * jacobian(['x*y', 'x^2'], ['x', 'y'], { x: 2, y: 3 })
 * // => [[3, 2], [4, 0]]
 * @example
 * jacobian((v) => [v[0] * v[1], v[0] ** 2], [2, 3])
 * // => [[3, 2], [4, 0]] (numeric, central differences)
 */
export declare function jacobian(exprs: VectorField, vars: number[]): f64[][];
export declare function jacobian(exprs: string[], vars: string[], scope: Record<string, f64>): f64[][];
/**
 * Compute the Laplacian of a scalar field.
 *
 * The Laplacian is the sum of all second partial derivatives:
 * nabla^2 f = sum_i d^2f/dx_i^2
 *
 * @param expr - Expression string
 * @param vars - Variable names
 * @param scope - Variable values at which to evaluate
 * @returns Laplacian value
 *
 * @example
 * laplacian('x^2 + y^2 + z^2', ['x', 'y', 'z'], { x: 1, y: 2, z: 3 }) // => 6
 */
export declare function laplacian(expr: string, vars: string[], scope: Record<string, f64>): f64;
/**
 * Compute the divergence of a vector field.
 *
 * div(F) = df1/dx1 + df2/dx2 + ... + dfn/dxn
 *
 * @param exprs - Array of expression strings (vector field components)
 * @param vars - Variable names (must match length of exprs)
 * @param scope - Variable values at which to evaluate
 * @returns Divergence value
 *
 * @example
 * divergence(['x^2', 'y^2', 'z^2'], ['x', 'y', 'z'], { x: 1, y: 2, z: 3 })
 * // => 2 + 4 + 6 = 12
 */
export declare function divergence(exprs: string[], vars: string[], scope: Record<string, f64>): f64;
/**
 * Compute the Laplace transform of an expression.
 *
 * Uses a table-based approach for common functions: constants, polynomials,
 * exponentials, sin, cos.
 *
 * @param expr - Time-domain expression string
 * @param t - Time variable name
 * @param s - Frequency variable name
 * @returns Laplace transform as an expression string
 *
 * @example
 * laplace('1', 't', 's')           // => '1/s'
 * laplace('t^2', 't', 's')         // => '2/s^3'
 * laplace('sin(t)', 't', 's')      // => '1/(s^2 + 1)'
 * laplace('exp(-t)', 't', 's')     // => '1/(s + 1)'
 */
export declare function laplace(expr: string, t: string, s: string): string;
/**
 * Compute the inverse Laplace transform of an expression.
 *
 * Uses table lookup and partial fraction patterns.
 *
 * @param expr - Frequency-domain expression string
 * @param s - Frequency variable name
 * @param t - Time variable name
 * @returns Inverse Laplace transform as an expression string
 *
 * @example
 * inverseLaplace('1/s', 's', 't')         // => '1'
 * inverseLaplace('1/(s + 1)', 's', 't')   // => 'exp(-1*t)'
 */
export declare function inverseLaplace(expr: string, s: string, t: string): string;
/**
 * Compute Fourier series coefficients of a periodic function.
 *
 * Computes a0, an, bn coefficients for the Fourier series representation:
 * f(x) ~ a0/2 + sum_{k=1}^{n} [a_k cos(k*x) + b_k sin(k*x)]
 *
 * Assumes period 2*pi. Coefficients computed numerically.
 *
 * @param expr - Expression string (function of varName)
 * @param varName - Variable name
 * @param n - Number of harmonics
 * @returns Object with a0, an[], bn[] coefficients
 *
 * @example
 * fourierSeries('x', 'x', 3)
 * // => { a0: 0, an: [0, 0, 0], bn: [-2, 1, -0.667] } (approx)
 */
export declare function fourierSeries(expr: string, varName: string, n: number): {
    a0: f64;
    an: f64[];
    bn: f64[];
};
/**
 * Compute the Z-transform of a sequence expression.
 *
 * Uses table-based lookup for common sequences.
 *
 * @param expr - Expression in terms of n (sequence element)
 * @param n - Sequence index variable
 * @param z - Z-domain variable
 * @returns Z-transform as an expression string
 *
 * @example
 * zTransform('1', 'n', 'z')       // => 'z/(z - 1)'
 * zTransform('n', 'n', 'z')       // => 'z/(z - 1)^2'
 */
export declare function zTransform(expr: string, n: string, z: string): string;
/**
 * Compute the Taylor series expansion of an expression around a point.
 *
 * Coefficients are computed exactly via the Cauchy integral on a complex
 * contour around x0 (see {@link taylorCoefficients}), not finite
 * differences — machine-precise for analytic expressions.
 *
 * @param expr - Expression string
 * @param varName - Variable name
 * @param x0 - Center of expansion (default 0, i.e., Maclaurin series)
 * @param n - Order of expansion (default 5)
 * @returns Taylor polynomial as an expression string
 *
 * @example
 * taylor('sin(x)', 'x', 0, 5)  // => 'x - 0.1666666667*x^3 + 0.008333333333*x^5'
 * taylor('exp(x)', 'x', 0, 4)  // => '1 + x + 0.5*x^2 + 0.1666666667*x^3 + 0.04166666667*x^4'
 */
export declare function taylor(expr: string, varName: string, x0?: f64, n?: number): string;
/**
 * Compute a multivariate Taylor expansion.
 *
 * Returns first-order (linear) approximation for multiple variables:
 * f(x0) + sum_i df/dx_i * (x_i - x0_i) + ...
 *
 * @param expr - Expression string
 * @param vars - Variable names
 * @param x0 - Center point values
 * @param n - Order (currently supports order 1)
 * @returns Taylor approximation as expression string
 *
 * @example
 * multivariateTaylor('x*y', ['x', 'y'], [1, 1], 1) // => '1 + (x - 1)*y0 + (y - 1)*x0'
 */
export declare function multivariateTaylor(expr: string, vars: string[], x0: f64[], n?: number): string;
/**
 * Power series expansion (alias for taylor).
 *
 * @param expr - Expression string
 * @param varName - Variable name
 * @param x0 - Center of expansion (default 0)
 * @param n - Order (default 5)
 * @returns Power series as expression string
 */
export declare function series(expr: string, varName: string, x0?: f64, n?: number): string;
/**
 * Extract the kth coefficient of the Taylor series expansion.
 *
 * Returns c_k where f(x) = sum c_k * (x - x0)^k.
 *
 * @param expr - Expression string
 * @param varName - Variable name
 * @param x0 - Center of expansion
 * @param k - Index of coefficient to extract
 * @returns The kth Taylor coefficient
 *
 * @example
 * seriesCoefficient('exp(x)', 'x', 0, 3) // => 1/6 = 0.1667
 * seriesCoefficient('sin(x)', 'x', 0, 1) // => 1
 */
export declare function seriesCoefficient(expr: string, varName: string, x0: f64, k: number): f64;
/**
 * Solve an equation or expression for a variable, returning its distinct roots.
 *
 * Accepts either an expression (treated as `expr = 0`) or a full equation with a
 * single `=` sign. Polynomials of degree ≤ 3 yield exact closed-form roots —
 * including complex conjugates — while higher-degree and transcendental
 * equations fall back to a numeric scan for real roots. Real roots are returned
 * first (cleaned of float noise and sorted ascending), followed by any complex
 * roots.
 *
 * @example
 * solve('x^2 - 4', 'x')       // => [-2, 2]
 * solve('x^2 + 1 = 0', 'x')   // => [Complex(0, 1), Complex(0, -1)]
 * solve('2*x - 6', 'x')       // => [3]
 * solve('x^3 - 8', 'x')       // => [2, Complex(-1, 1.732…), Complex(-1, -1.732…)]
 * solve('cos(x)', 'x')        // => numeric real roots
 *
 * @param equation - Expression (`expr = 0`) or equation with one `=` sign.
 * @param varName  - Variable to solve for.
 * @returns Distinct roots: real numbers (sorted) then Complex.
 */
export declare function solve(equation: string, varName: string): Array<f64 | Complex>;
/**
 * Compute dy/dx from an implicit equation F(x, y) = 0.
 *
 * Uses the implicit function theorem: dy/dx = -(dF/dx) / (dF/dy)
 *
 * @param expr - Expression F(x, y)
 * @param x - x-variable name
 * @param y - y-variable name
 * @param scope - Point at which to evaluate
 * @returns dy/dx at the given point
 *
 * @example
 * // Circle: x^2 + y^2 - 25 = 0 at (3, 4)
 * implicitDiff('x^2 + y^2 - 25', 'x', 'y', { x: 3, y: 4 }) // => -0.75
 */
export declare function implicitDiff(expr: string, x: string, y: string, scope: Record<string, f64>): f64;
/**
 * Compute a finite numerical summation.
 *
 * Evaluates expr at each integer k from a to b (inclusive) and accumulates
 * the sum. Both bounds must be finite numbers; there is no symbolic or
 * closed-form (e.g. Faulhaber) path — a non-numeric bound throws rather
 * than silently returning 0.
 *
 * @param expr - Expression to sum (function of varName)
 * @param varName - Summation index variable
 * @param a - Lower bound (finite integer)
 * @param b - Upper bound (finite integer)
 * @returns Sum value
 *
 * @example
 * summation('k', 'k', 1, 100)     // => 5050
 * summation('k^2', 'k', 1, 10)    // => 385
 * summation('1', 'k', 1, 50)      // => 50
 */
export declare function summation(expr: string, varName: string, a: number, b: number): f64;
/**
 * Compute a symbolic product.
 *
 * Computes the product of expr for varName from a to b.
 *
 * @param expr - Expression to multiply (function of varName)
 * @param varName - Product index variable
 * @param a - Lower bound (integer)
 * @param b - Upper bound (integer)
 * @returns Product value
 *
 * @example
 * symbolicProduct('k', 'k', 1, 5)    // => 120 (= 5!)
 * symbolicProduct('2*k', 'k', 1, 4)  // => 384
 */
export declare function symbolicProduct(expr: string, varName: string, a: number, b: number): f64;
/**
 * Declare an assumption about a variable's properties.
 *
 * Stores assumptions that can be queried by other CAS functions
 * (e.g., simplification, integration).
 *
 * @param varName - Variable name
 * @param property - Property to assume ('real', 'positive', 'negative', 'integer', 'nonzero')
 *
 * @example
 * assume('x', 'positive')
 * assume('n', 'integer')
 */
export declare function assume(varName: string, property: string): void;
/**
 * Query assumptions about a variable.
 *
 * @param varName - Variable name
 * @returns Set of assumed properties, or empty set if none
 */
export declare function getAssumptions(varName: string): Set<string>;
/**
 * Clear all assumptions about a variable (or all variables).
 *
 * @param varName - Variable name, or undefined to clear all
 */
export declare function clearAssumptions(varName?: string): void;
/**
 * Compute the asymptotic expansion of an expression.
 *
 * Finds the leading-order behavior as the variable approaches
 * the specified limit (typically infinity).
 *
 * @param expr - Expression string
 * @param varName - Variable name
 * @param towards - Limit point (default: Infinity)
 * @returns Object with leadingTerm and order
 *
 * @example
 * asymptotic('(x^2 + 1) / x', 'x', Infinity)
 * // => { leadingTerm: 'x', order: 1 }
 */
export declare function asymptotic(expr: string, varName: string, towards?: f64): {
    leadingTerm: string;
    order: f64;
    coefficient: f64;
};
/**
 * Compute a Groebner basis for a system of polynomial equations.
 *
 * Implements Buchberger's algorithm for small systems (up to 3 variables,
 * low degree). Polynomials are represented as expression strings set to 0.
 *
 * This is a simplified implementation that works with monomials represented
 * internally as coefficient maps.
 *
 * @param polys - Array of polynomial expression strings
 * @param vars - Variable names
 * @returns Array of Groebner basis polynomial strings
 *
 * @example
 * groebnerBasis(['x^2 + y - 1', 'x + y^2 - 1'], ['x', 'y'])
 */
export declare function groebnerBasis(polys: string[], vars: string[]): string[];
/**
 * Compute the minimal polynomial of a numerical algebraic expression.
 *
 * Given a numerical value (expressed as a string that evaluates to a number),
 * attempts to find a polynomial with integer coefficients that has this
 * value as a root.
 *
 * Uses the LLL-like approach of checking polynomials of increasing degree.
 *
 * @param expr - Expression string that evaluates to a number
 * @param varName - Variable name for the resulting polynomial
 * @returns Minimal polynomial as a string, or null if not found
 *
 * @example
 * minimalPolynomial('sqrt(2)', 'x')  // => 'x^2 - 2'
 * minimalPolynomial('1.618033988749895', 'x') // => 'x^2 - x - 1' (golden ratio)
 */
export declare function minimalPolynomial(expr: string, varName: string): string | null;
/**
 * Express a polynomial solution in radical form.
 *
 * Applies the quadratic formula, Cardano's formula (cubic), and
 * Ferrari's method (quartic) to express roots using radicals.
 *
 * @param expr - Polynomial expression string (set equal to 0)
 * @returns Array of root expressions in radical form
 *
 * @example
 * toRadicals('x^2 - 2')  // => ['sqrt(2)', '-sqrt(2)']
 * toRadicals('x^2 + x - 1') // => ['(-1 + sqrt(5))/2', '(-1 - sqrt(5))/2']
 */
export declare function toRadicals(expr: string): string[];
/**
 * Construct a piecewise function.
 *
 * Returns a function that evaluates the appropriate expression based
 * on the condition that is satisfied.
 *
 * @param conditions - Array of condition expression strings
 * @param values - Array of value expression strings (one more than conditions for default)
 * @returns A function that evaluates the piecewise expression
 *
 * @example
 * const f = piecewise(
 *   ['x < 0', 'x >= 0'],
 *   ['-x', 'x']
 * );
 * f({ x: -3 }); // => 3
 * f({ x: 5 });  // => 5
 */
export declare function piecewise(conditions: string[], values: string[]): (scope: Record<string, f64>) => f64;
/**
 * Solve an ordinary differential equation.
 *
 * Handles separable and linear first/second-order ODEs numerically
 * using the Runge-Kutta 4th order method.
 *
 * For an ODE dy/dx = f(x, y), returns solution values at specified points.
 *
 * @param ode - Right-hand side expression f(x, y) where dy/dx = f(x, y)
 * @param y - Dependent variable name
 * @param x - Independent variable name
 * @param x0 - Initial x value
 * @param y0 - Initial y value (or [y0, dy0] for 2nd order)
 * @param xEnd - End x value
 * @param steps - Number of steps (default 100)
 * @returns Array of {x, y} points
 *
 * @example
 * odeGeneral('y', 'y', 'x', 0, 1, 1, 100) // dy/dx = y, y(0)=1 => e^x
 */
export declare function odeGeneral(ode: string, y: string, x: string, x0: f64, y0: f64, xEnd: f64, steps?: number): Array<{
    x: f64;
    y: f64;
}>;
/**
 * Compute the curl of a 3D vector field.
 *
 * curl(F) = (dF3/dy - dF2/dz, dF1/dz - dF3/dx, dF2/dx - dF1/dy)
 *
 * @param exprs - Three expression strings [F1, F2, F3]
 * @param vars - Three variable names [x, y, z]
 * @param scope - Point at which to evaluate
 * @returns Three-element array [curl_x, curl_y, curl_z]
 *
 * @example
 * // F = (y, -x, 0), curl = (0, 0, -2)
 * curl(['y', '-x', '0'], ['x', 'y', 'z'], { x: 0, y: 0, z: 0 })
 * // => [0, 0, -2]
 */
export declare function curl(exprs: string[], vars: string[], scope: Record<string, f64>): [f64, f64, f64];
/**
 * Compute the inverse Laplace transform using a lookup table of known transform pairs.
 *
 * Given an expression F(s) in the s-domain, returns the time-domain
 * function f(t) by matching known Laplace transform pairs numerically.
 *
 * Supported patterns:
 *   - 1/s               → 1          (unit step)
 *   - 1/s^2             → t          (ramp)
 *   - c/s^n             → c * t^(n-1) / (n-1)!  (power)
 *   - 1/(s - a)         → e^(at)     (exponential)
 *   - c/(s - a)         → c * e^(at) (scaled exponential)
 *   - s/(s^2 + b^2)     → cos(b*t)
 *   - b/(s^2 + b^2)     → sin(b*t)
 *   - s/(s^2 - a^2)     → cosh(a*t)
 *   - a/(s^2 - a^2)     → sinh(a*t)
 *
 * For sums/differences, each term is transformed independently.
 *
 * @param expr - Expression in the s-domain (string or parsed Node)
 * @param sVar - Name of the s-domain variable (default: 's')
 * @param tVar - Name of the time variable (default: 't')
 * @returns Time-domain expression as a string
 *
 * @example
 * inverseLaplaceTransform('1/s', 's', 't')          // => '1'
 * inverseLaplaceTransform('1/s^2', 's', 't')        // => 't'
 * inverseLaplaceTransform('1/(s - 2)', 's', 't')    // => 'e^(2 * t)'
 * inverseLaplaceTransform('s/(s^2 + 4)', 's', 't')  // => 'cos(2 * t)'
 * inverseLaplaceTransform('2/(s^2 + 4)', 's', 't')  // => 'sin(2 * t)'
 */
export declare function inverseLaplaceTransform(expr: string | MathNode, sVar?: string, tVar?: string): string;
/**
 * CAS batch size threshold (deprecated).
 * Formerly used to trigger worker pool fan-out. Kept for API compatibility.
 */
export declare const CAS_BATCH_THRESHOLD = 16;
/**
 * Simplify a single expression (CAS batch-capable variant).
 *
 * Named `casSimplify` to avoid ambiguity with the factory-generated
 * `simplify` from the mathjs compatibility layer.  Both perform algebraic
 * simplification; this one uses string-level pattern matching and supports
 * a batch-array overload for array inputs.
 *
 * @param expr - Expression string or parsed MathNode
 * @returns Simplified expression string
 *
 * @example
 * casSimplify('x + x')   // => '2*x'
 * casSimplify('1*y')     // => 'y'
 * casSimplify('2 * 3')   // => '6'
 */
export declare function casSimplify(expr: string | MathNode): string;
/**
 * Simplify an array of expressions (batch overload).
 *
 * Arrays are processed synchronously in-process.
 *
 * @param exprs - Array of expression strings (or MathNodes)
 * @returns Promise resolving to an array of simplified expression strings
 *
 * @example
 * await casSimplify(['x + x', '2 * 3']) // => ['2*x', '6']
 */
export declare function casSimplify(exprs: Array<string | MathNode>): Promise<string[]>;
/**
 * Compute the symbolic derivative of a single expression (CAS batch-capable variant).
 *
 * Named `casDerivative` to avoid ambiguity with the factory-generated
 * `derivative` from the mathjs compatibility layer.
 *
 * Uses power rule, trig (sin/cos), exp, and ln patterns.  Unrecognised terms
 * are left as `d/d<variable>(<term>)` placeholders.
 *
 * @param expr - Expression string or parsed MathNode
 * @param variable - Variable to differentiate with respect to
 * @returns Derivative expression string
 *
 * @example
 * casDerivative('x^2', 'x')   // => '2*x^1'
 * casDerivative('sin(x)', 'x') // => 'cos(x)'
 * casDerivative('exp(x)', 'x') // => 'exp(x)'
 */
export declare function casDerivative(expr: string | MathNode, variable: string): string;
/**
 * Compute the symbolic derivative of an array of expressions (batch overload).
 *
 * Arrays are processed synchronously in-process.
 *
 * @param exprs - Array of expression strings (or MathNodes)
 * @param variable - Variable to differentiate with respect to
 * @returns Promise resolving to an array of derivative expression strings
 *
 * @example
 * await casDerivative(['x^2', 'sin(x)', 'exp(x)'], 'x')
 * // => ['2*x^1', 'cos(x)', 'exp(x)']
 */
export declare function casDerivative(exprs: Array<string | MathNode>, variable: string): Promise<string[]>;
/**
 * Expand an expression, distributing products over sums and collecting like
 * terms (CAS batch-capable variant).
 *
 * Delegates to the real polynomial engine {@link algebraExpand} (`expand` from
 * `algebra.ts`): polynomials in one OR MORE variables are expanded EXACTLY
 * (`'(x+1)^2'` → `'1*x^2 + 2*x + 1'`, `'(x+y)^2'` → `'1*y^2 + 2*x*y + 1*x^2'`).
 * Non-polynomial pieces fall back to that engine's regex distributor.
 *
 * (Formerly a crude string stub that emitted uncollected products like
 * `'x*x + x*1 + 1*x + 1*1'`; now wired to the maintained engine.)
 *
 * @param expr - Expression string or parsed MathNode
 * @returns Expanded expression string
 *
 * @example
 * casExpand('(x+1)^2')     // => '1*x^2 + 2*x + 1'
 * casExpand('(x+y)*(x-y)') // => '-1*y^2 + 1*x^2'
 */
export declare function casExpand(expr: string | MathNode): string;
/**
 * Expand an array of expressions (batch overload).
 *
 * Each element is expanded via the real engine {@link algebraExpand}. Kept
 * async (resolves to `string[]`) for API compatibility; because the engine
 * relies on the polynomial parser it runs in-process rather than fanning out
 * to workers (a worker cannot import it), so batch results are always
 * identical to the per-element single-expression call.
 *
 * @param exprs - Array of expression strings (or MathNodes)
 * @returns Promise resolving to an array of expanded expression strings
 *
 * @example
 * await casExpand(['(x+1)^2', '(a+b)^3'])
 */
export declare function casExpand(exprs: Array<string | MathNode>): Promise<string[]>;
/**
 * Factor an expression (CAS batch-capable variant).
 *
 * Delegates to the real factoring engine {@link algebraFactor} (`factor` from
 * `algebra.ts`): univariate polynomials are factored over ℚ via the
 * rational-root theorem (`'x^2 - 1'` → `'(x - 1)*(x + 1)'`), multivariate
 * polynomials get integer-content / common-monomial / difference-of-squares
 * extraction (`'x^2*y + x*y^2'` → `'x*y*(x + y)'`), and anything else falls
 * back to integer-GCD extraction (`'2*x + 4*y'` → `'2*(x + 2*y)'`).
 *
 * (Formerly a crude integer-GCD-only stub; now wired to the maintained engine.)
 *
 * @param expr - Expression string or parsed MathNode
 * @returns Factored expression string
 *
 * @example
 * casFactor('2*x + 4*y')  // => '2*(x + 2*y)'
 * casFactor('x^2 - 1')    // => '(x - 1)*(x + 1)'
 */
export declare function casFactor(expr: string | MathNode): string;
/**
 * Factor an array of expressions (batch overload).
 *
 * Each element is factored via the real engine {@link algebraFactor}. Kept
 * async (resolves to `string[]`) for API compatibility; runs in-process (the
 * engine cannot be serialised to a worker), so batch results are always
 * identical to the per-element single-expression call.
 *
 * @param exprs - Array of expression strings (or MathNodes)
 * @returns Promise resolving to an array of factored expression strings
 *
 * @example
 * await casFactor(['2*x + 4*y', '3*a + 6*b'])
 */
export declare function casFactor(exprs: Array<string | MathNode>): Promise<string[]>;
export {};
//# sourceMappingURL=cas.d.ts.map