nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/errors.d.ts

@@ -0,0 +1,316 @@
+/** Thrown when tokenization encounters invalid adjacency, punctuation, or bracket structure. */
+export declare class UnexpectedTokenError extends Error {
+}
+/** Thrown when an operation receives a Nerdamer entity of the wrong runtime type. */
+export declare class UnexpectedDataType extends Error {
+}
+/** Used when input parses successfully but does not have the form an operation requires. */
+export declare class UnexpectedInputError extends Error {
+}
+/** Thrown for exact division by zero. Small nonzero numerical values are not treated as zero. */
+export declare class DivisionByZeroError extends Error {
+}
+/** Used for invalid parser-operator definitions and operator dispatch failures. */
+export declare class OperatorError extends Error {
+}
+/** General parser error for construction, evaluation, and registered-function failures. */
+export declare class ParserError extends Error {
+}
+/** Thrown when evaluation requires a value but a construct produces no value. */
+export declare class NullError extends Error {
+}
+/** Used when a mathematical operation has no defined value in the handled domain. */
+export declare class UndefinedError extends Error {
+}
+/** Thrown when input cannot be represented as a polynomial under the requested requirements. */
+export declare class PolynomialError extends Error {
+}
+/** Thrown when an operation is known but unsupported for the supplied form or domain. */
+export declare class UnsupportedOperationError extends Error {
+}
+/** Parser syntax error kept separate from lower-level tokenization failures. */
+export declare class ParserSyntaxError extends Error {
+}
+/** General mathematical precondition error for cases without a more specific error type. */
+export declare class MathError extends Error {
+}
+/** Thrown when a required numeric conversion produces `NaN`. */
+export declare class NaNError extends Error {
+}
+/** Thrown when vector, matrix, or structured-entity dimensions are incompatible. */
+export declare class DimensionError extends Error {
+}
+/** Used for recognized operations that have not been implemented yet. */
+export declare class NotImplementedError extends Error {
+}
+/** Thrown when a named converter or pattern reference cannot be resolved. */
+export declare class MissingReferenceError extends Error {
+}
+/** Thrown for the indeterminate symbolic form `0^0`. */
+export declare class ZeroToZeroPowerError extends Error {
+}
+/** Thrown when code attempts to assign to a reserved or otherwise non-assignable parser name. */
+export declare class AssignmentError extends Error {
+}
+/** Internal localized message templates used when constructing Nerdamer errors. */
+export declare const EnglishErrorMessages: {
+    readonly notImplemented: "This method has not yet been implemented.";
+    readonly noInverse: "Unable to calculate inverse!";
+    readonly undefinedValue: "The requested value is undefined!";
+    readonly nullValue: "Value expected but received null.";
+    readonly univariateInputOnly: "The input for this function must be univariate!";
+    readonly differentSignsAtEndPointsRequired: "Function must have opposite signs at endpoints a and b!";
+    readonly integerRequired: "This function requires the coefficient to be an integer!";
+    readonly plainVariableExpected: "Expected plain variable! Received {{input}}.";
+    readonly missingReference: "The reference \"{{ref}}\" does not exist on this pattern!!";
+    readonly undefinedDivision: "Division not defined expression of this type! {{type}}";
+    readonly restrictedVariableName: "Cannot assign the requested value to the reserved name \"{{name}}\"!";
+    readonly noVariableInExpression: "No variable found in expression!";
+    readonly quadraticExpressionExpected: "Expression must be quadratic!";
+    readonly wrongInput: "Wrong input! Expected {{expected}} but received {{received}}.";
+    readonly unsupportedFunction: "Unsupported function {{function}}";
+    readonly functionMinArgs: "{{function}} requires a minimum of {{min}} arguments but {{actual}} provided!";
+    readonly functionMaxArgs: "{{function}} allows a maximum of {{max}} arguments but {{actual}} provided!";
+    readonly invalidFunctionDeclaration: "Invalid function declaration {{declaration}}.";
+    readonly indexOutOfBounds: "Index {{index}} out of bounds for {{type}} of length {{length}}";
+    readonly matrixRowIndexOutOfBounds: "Row index {{index}} out of bounds for Matrix with {{length}} rows";
+    readonly matrixColumnIndexOutOfBounds: "Column index {{index}} out of bounds for Matrix with {{length}} columns";
+    readonly dictionaryKeyNotFound: "Key \"{{key}}\" not found in Dictionary. Available keys: {{keys}}";
+    readonly rangeValuesFinite: "Range values must be finite.";
+    readonly rangeStepNonzero: "Step cannot be zero";
+    readonly rangeStepNoAdvance: "Step does not advance range at current precision";
+    readonly sparseVariableCountInvalid: "SparsePolynomial variableCount must be a non-negative safe integer.";
+    readonly sparseExponentVectorLengthMismatch: "SparsePolynomial exponent vector length must equal variableCount.";
+    readonly sparseExponentsNonNegativeBigInt: "SparsePolynomial exponents must be non-negative bigints.";
+    readonly sparseVariableIndexOutOfRing: "SparsePolynomial variable index is outside the polynomial ring.";
+    readonly sparseAdditionRingMismatch: "SparsePolynomial addition requires the same polynomial ring.";
+    readonly sparseCoefficientExponentNonNegative: "SparsePolynomial coefficient exponent must be non-negative.";
+    readonly sparseZeroMonomialDivision: "SparsePolynomial cannot divide by a zero monomial.";
+    readonly sparseZeroScalarDivision: "SparsePolynomial cannot divide by zero.";
+    readonly sparseScalarDivisionExact: "SparsePolynomial scalar division must be exact for every coefficient.";
+    readonly sparseDivisionRingMismatch: "SparsePolynomial division requires the same polynomial ring.";
+    readonly sparseZeroPolynomialDivision: "SparsePolynomial cannot divide by the zero polynomial.";
+    readonly sparseMonomialOrderUnsupported: "SparsePolynomial monomial order is not supported.";
+    readonly sparseMultiplicationRingMismatch: "SparsePolynomial multiplication requires the same polynomial ring.";
+    readonly sparseExponentNonNegative: "SparsePolynomial exponent must be non-negative.";
+    readonly sparseSubtractionRingMismatch: "SparsePolynomial subtraction requires the same polynomial ring.";
+    readonly invalidDecimal: "Invalid Decimal: \"{{value}}\"";
+    readonly invalidInterval: "Invalid interval: ({{start}}, {{end}})";
+    readonly invalidAssumption: "Invalid assumption: \"{{input}}\"";
+    readonly assumptionIdentifierExpected: "Expected identifier";
+    readonly assumptionOperatorMissing: "Missing operator";
+    readonly assumptionValueMissing: "Missing value";
+    readonly assumptionOperatorUnsupported: "Unsupported operator \"{{operator}}\"";
+    readonly matrixStringKeyUnsupported: "Matrix does not support string key access";
+    readonly matrixTraceUnavailable: "Unable to calculate trace for the matrix";
+    readonly defintMaxEvals: "defint: maxEvals exceeded ({{max}}).";
+    readonly defintNonFiniteValue: "defint: non-finite f(x) at x={{x}}";
+    readonly defintEndpointSingularity: "defint: endpoint singularity could not be regularized near x={{x}}";
+    readonly defintSingularity: "defint: singular/non-finite encountered near [{{a}}, {{b}}]";
+    readonly defintInfiniteBounds: "defint: infinite bounds require allowInfinite: true";
+    readonly defintUnsupportedInfiniteBounds: "defint: unsupported infinite bound configuration";
+    readonly symbolicAccessNamedTargetRequired: "Symbolic indexed access requires a named Vector or Matrix target.";
+    readonly symbolicVectorIndexCount: "Symbolic Vector access requires exactly one index.";
+    readonly symbolicMatrixRowNonScalar: "Symbolic Matrix row access is not scalar and cannot be deferred as an Expression.";
+    readonly symbolicMatrixCellIndexCount: "Symbolic Matrix cell access requires exactly two indices.";
+    readonly symbolicAccessMaxIndices: "Symbolic indexed access supports at most two unresolved indices.";
+    readonly symbolicAccessIndexScalar: "Symbolic accessor indices must evaluate to scalar expressions.";
+    readonly symbolicAccessTargetType: "Symbolic indexed access target must resolve to a Vector or Matrix.";
+    readonly expectedOperatorOrFunction: "Expected operator or function name but \"{{value}}\" found!";
+    readonly missingOpeningBracket: "Missing opening bracket for \"{{bracket}}\":{{position}}";
+    readonly missingClosingBracket: "Missing closing bracket for \"{{bracket}}\":{{position}}";
+    readonly prefixOperatorExpected: "Prefix operator expected but {{operator}} encountered.";
+    readonly groebnerBasisSizeBudgetExceeded: "Groebner budget exceeded: basis size > {{max}}";
+    readonly groebnerPairsBudgetExceeded: "Groebner budget exceeded: pairsPopped > {{max}}";
+    readonly unsupportedParserEntity: "Unsupported parser entity";
+    readonly factorialNegativeUndefined: "Factorial is undefined for negative integers.";
+    readonly erfConvergenceFailed: "erf not converging. Exiting!";
+    readonly defintInfiniteBoundsDecimal: "defint: infinite bounds require allowInfinite:true";
+    readonly seqStartsAtInteger: "startsAt must be an integer";
+    readonly seqPolynomialOrMaxPower: "Sequence is not a polynomial or exceeds maxPower";
+    readonly seqInsufficientData: "Insufficient data points for detected degree";
+    readonly arithPowNegativeExponent: "pow: negative exponent";
+    readonly arithPowNNonnegativeInteger: "powN: exponent must be a nonnegative integer";
+    readonly arithBigIntSqrtNegative: "bigIntSqrt: negative input";
+    readonly arithNthRootPositiveInteger: "intNthRootExact: n must be a positive integer";
+    readonly arithDivisorsPositive: "getDivisors: n must be positive";
+    readonly arithModNormNonzeroModulus: "modNorm: modulus must be nonzero";
+    readonly arithModSymmetricNonzeroModulus: "modSymmetric: modulus must be nonzero";
+    readonly arithModInvZeroNoninvertible: "modInv: non-invertible (0)";
+    readonly arithModInvNoninvertible: "modInv: non-invertible";
+    readonly integerSqrtNonnegative: "Integer square root requires a non-negative value.";
+    readonly modularExponentiationPositiveModulus: "Modular exponentiation requires a positive modulus.";
+    readonly modularExponentiationNonnegativeExponent: "Modular exponentiation requires a non-negative exponent.";
+    readonly maxBigIntRequiresArgument: "maxBigInt() requires at least one argument";
+    readonly minBigIntEmpty: "Min of empty list is not defined for BigInt.";
+    readonly binomBigIntNonnegativeN: "binomBigInt: n must be non-negative";
+    readonly invalidDecimalValue: "Invalid decimal value: {{value}}";
+    readonly subtractionNotDefined: "Subtraction not defined for {{leftType}}-{{rightType}} | {{left}}-{{right}}";
+    readonly sparseAdapterVariablesUnique: "Sparse polynomial adapter variables must be unique.";
+    readonly sparseAdapterVariablesIncludeEvery: "Sparse polynomial adapter variables must include every polynomial variable.";
+    readonly sparseExpressionConversionNameCount: "Sparse polynomial expression conversion requires one name per ring variable.";
+    readonly converterMissingArgumentScope: "Missing argument scope for function {{function}}";
+    readonly converterMissingPrefixOperand: "Missing operand for prefix operator {{operator}}";
+    readonly converterMissingOperandMetadata: "Missing operand or metadata for operator {{operator}}";
+    readonly converterMissingLeftOperand: "Missing left operand for operator {{operator}}";
+    readonly converterTexConversionFailed: "Unable to convert source expression to TeX";
+    readonly unknownOperator: "Unknown operator {{operator}}";
+    readonly polynomialMaximumIterations: "Maximum iterations reached";
+    readonly polyRequires: "{{operation}} requires {{requirement}}.";
+    readonly polyVariablesUnique: "{{operation}} variables must be unique.";
+    readonly polyVariablesRingOrder: "{{operation}} variables must follow polynomial-ring order.";
+    readonly polyVariablesIncludeActive: "{{operation}} variables must include every active variable.";
+    readonly polyInputsSelectedOnly: "{{operation}} inputs may use only the selected variables.";
+    readonly polyCannotFactorZeroPolynomial: "{{operation}} cannot factor the zero polynomial.";
+    readonly polyCannotFactorZero: "{{operation}} cannot factor zero.";
+    readonly polyModulusGreaterThanOne: "ModularSparsePolynomial modulus must be greater than one.";
+    readonly polyVariableCountMatch: "ModularSparsePolynomial variableCount must match the supplied sparse polynomial.";
+    readonly polyInterpolationCannotDepend: "ModularSparsePolynomial interpolation samples cannot depend on the interpolated variable.";
+    readonly polyInterpolationInvertibleDifferences: "ModularSparsePolynomial interpolation points must have invertible pairwise differences.";
+    readonly polyCoefficientExponentNonnegative: "ModularSparsePolynomial coefficient exponent must be non-negative.";
+    readonly polyCannotDivideZero: "ModularSparsePolynomial cannot divide by the zero polynomial.";
+    readonly polyDivisorLeadingCoefficientInvertible: "ModularSparsePolynomial divisor leading coefficient is not invertible.";
+    readonly polyLeadingCoefficientInvertible: "ModularSparsePolynomial leading coefficient is not invertible.";
+    readonly polyExponentNonnegative: "ModularSparsePolynomial exponent must be non-negative.";
+    readonly polyDegreeMatrixLimit: "Modular factorization degree exceeds the supported matrix dimension.";
+    readonly polyExtendedGcdTwoZeroUndefined: "Modular extended GCD is undefined for two zero polynomials.";
+    readonly polyHenselPrimeExceedsTailDegree: "Multivariate Hensel lifting prime must exceed every tail-variable degree.";
+    readonly polyHenselTargetNotSmaller: "Hensel lifting target modulus cannot be smaller than the base prime.";
+    readonly polyHenselTargetRepeatedSquaring: "Hensel lifting target modulus must be obtained by repeated squaring of the base prime.";
+    readonly polyHenselFactorsReconstructModuloBase: "Hensel lifting factors do not reconstruct the integer polynomial modulo the base prime.";
+    readonly polyZassenhausFactorsReconstructModuloLift: "Zassenhaus recombination factors do not reconstruct the input modulo the lift modulus.";
+    readonly polyWangCannotSpecializeZero: "Wang evaluation search cannot specialize zero.";
+    readonly polyModularContentExactDivision: "Modular polynomial content must divide the polynomial exactly.";
+    readonly factorizationNoFactors: "Nonconstant factorization returned no factors.";
+    readonly polyCrtModuliInvertible: "Polynomial CRT moduli must be invertible.";
+    readonly polyIntegerFactorPrimeZero: "Integer factorization cannot choose a prime for zero.";
+    readonly polySquareFreeNonExactDivision: "Square-free factorization encountered a non-exact polynomial division.";
+    readonly polyZassenhausLostRemaining: "Zassenhaus recombination lost the remaining polynomial.";
+    readonly polyZassenhausReconstructionFailed: "Zassenhaus recombination factors do not reconstruct the integer polynomial.";
+    readonly polyIntegerFactorLostLeading: "Integer factorization lost the leading term.";
+    readonly parserMalformedSymbolicAccessor: "Malformed internal symbolic accessor.";
+    readonly parserMalformedSymbolicAccessorIndex: "Malformed internal symbolic accessor index.";
+    readonly unknownOperatorAction: "Unknown operator action {{action}}";
+    readonly parserBracketTokenMissingCharacter: "Bracket token is missing its character.";
+    readonly polyWangLeadingEvaluationInteger: "Wang leading-coefficient evaluation did not produce an integer.";
+    readonly polyWangSpecializedLeadingInteger: "Wang specialized factor did not have an integer leading coefficient.";
+    readonly polyMultivariateContentDivisionFailed: "Multivariate factorization could not divide a square-free block by its main-variable content.";
+    readonly polyMultivariateContentVariableMissing: "Multivariate main-variable content did not retain an active coefficient variable.";
+    readonly polyMultivariateReconstructionFailed: "Complete multivariate factorization does not reconstruct the input polynomial.";
+    readonly polyBerlekampNoninvertiblePivot: "Berlekamp elimination encountered a noninvertible pivot.";
+    readonly polyHenselZeroFactorGroup: "Hensel lifting cannot lift a zero factor group.";
+    readonly polyHenselCannotLiftZero: "Hensel lifting cannot lift the zero polynomial.";
+    readonly polyHenselModulusExceeded: "Hensel lifting exceeded the requested prime-power modulus.";
+    readonly polyHenselLeadingLost: "Hensel lifting lost the target leading coefficient.";
+    readonly polyHenselReconstructionFailed: "Hensel-lifted factors do not reconstruct the target polynomial.";
+    readonly polyBerlekampNonExactSplit: "Berlekamp splitting produced a non-exact factor division.";
+    readonly polyBerlekampIncompleteSplit: "Berlekamp factorization did not fully split the polynomial.";
+    readonly polyBerlekampReconstructionFailed: "Berlekamp factors do not reconstruct the input polynomial.";
+    readonly expressionKeyValueUnsupported: "The function 'keyValue' is not implemented for type {{type}}.";
+    readonly solveLinearNonlinearDegree: "Nonlinear term detected in equation {{equation}}: degree {{degree}} term found. solveLinearSystem only handles linear systems.";
+    readonly solveLinearNonPolynomialVariable: "Nonlinear term detected in equation {{equation}}: variable \"{{variable}}\" appears in a non-polynomial position. solveLinearSystem only handles linear systems.";
+    readonly polyReqPrimeModulus: "a prime modulus";
+    readonly polyReqUnivariatePolynomial: "a univariate polynomial";
+    readonly polyReqSquareFreeInput: "square-free input";
+    readonly polyReqSamePolynomialRing: "the same polynomial ring";
+    readonly polyReqAtLeastOneVariable: "at least one variable";
+    readonly polyReqAtLeastTwoSelectedVariables: "at least two selected variables";
+    readonly polyReqOneEvaluationPerTailVariable: "one evaluation value per tail variable";
+    readonly polyReqMatchingFactorLeadingLists: "matching factor and leading-coefficient lists";
+    readonly polyReqPairwiseCoprimeModularFactors: "pairwise coprime modular factors";
+    readonly polyReqPrimeBaseModulus: "a prime base modulus";
+    readonly polyReqAtLeastOneModularFactor: "at least one modular factor";
+    readonly polyReqUnivariateIntegerPolynomial: "a univariate integer polynomial";
+    readonly polyReqFactorsSameRingAndPrime: "factors from the same integer polynomial ring and base prime";
+    readonly polyReqUnivariateFactors: "univariate factors";
+    readonly polyReqMonicModularFactors: "monic modular factors";
+    readonly polyReqPrimitiveIntegerPolynomial: "a primitive integer polynomial";
+    readonly polyReqPositiveLeadingCoefficient: "a positive leading coefficient";
+    readonly polyReqLiftedModularFactors: "lifted modular factors";
+    readonly polyReqLiftedFactorsSameRing: "lifted factors from one polynomial ring";
+    readonly polyReqUnivariateLiftedFactors: "univariate lifted factors";
+    readonly polyReqMonicLiftedFactors: "monic lifted factors";
+    readonly polyReqLargerHenselModulus: "a larger Hensel lifting modulus";
+    readonly polyReqPrimitivePolynomial: "a primitive polynomial";
+    readonly polyReqPositiveLexLeadingSign: "positive lexicographic leading sign";
+    readonly polyReqSquareFreeMainVariable: "square-free input in the main variable";
+    readonly polyReqExactlyTwoSelectedVariables: "exactly two selected variables";
+    readonly polyReqExactlyTwoVariables: "exactly two variables";
+    readonly polyReqOneValuePerNonMainVariable: "one value for every non-main selected variable";
+    readonly polyReqOneValuePerTailVariable: "one value for every tail variable";
+    readonly polyReqPositiveDegreeMainVariable: "positive degree in the main variable";
+    readonly polyReqAllOtherVariablesDormant: "all other variables to be dormant";
+    readonly polyReqPositiveModuli: "positive moduli";
+    readonly polyReqCoprimeModuli: "coprime moduli";
+    readonly polyReqAtLeastOneSample: "at least one sample";
+    readonly polyReqInvertibleLeadingCoefficient: "an invertible leading coefficient";
+    readonly polyReqIntegerLeadingCoefficientInvertible: "the integer leading coefficient to be invertible modulo the base prime";
+    readonly infinityMinusInfinityUndefined: "Infinity-Infinity is undefined!";
+    readonly inconsistentAssumptions: "Assumptions are inconsistent (empty intersection)!";
+    readonly unsupportedType: "The provided type ({{type}}) is not supported for this function!";
+    readonly unsupportedOperation: "This operation is currently not supported!";
+    readonly buildFunctionUnsupportedFunction: "buildFunction cannot compile the function \"{{function}}\" to JavaScript number arithmetic!";
+    readonly buildFunctionComplexUnsupported: "buildFunction cannot compile expressions containing the imaginary unit to JavaScript number arithmetic!";
+    readonly nonMatchingDimensions: "This operation cannot be completed because the dimensions don't match!";
+    readonly malformedExpression: "Unable to parse malformed expression!";
+    readonly unsupportedCharacter: "Unsupported character \"{{character}}\" at position {{position}}.";
+    readonly missingCommentDelimiter: "Missing closing comment delimiter \"{{delimiter}}\".";
+    readonly divisionByZero: "Division by zero is not defined!";
+    readonly zeroToZeroPower: "0^0 is undefined!";
+    readonly infinityToPowerZero: "Infinity^0 is not defined!";
+    readonly infinityTimesZero: "0*Infinity is not defined!";
+    readonly infinityToInfinity: "Infinity^Infinity is not defined!";
+    readonly valueToInfinityUndefined: "{{value}}^Infinity is not defined!";
+    readonly atan2Undefined: "atan2 is undefined for 0, 0!";
+    readonly tanUndefined: "tan is undefined for multiples of pi/2!";
+    readonly loopIterationLimitExceeded: "Loop exceeded the maximum of {{max}} iterations.";
+    readonly breakOutsideLoop: "break can only be used inside a loop.";
+    readonly continueOutsideLoop: "continue can only be used inside a loop.";
+    readonly letRequiresBindingsAndBody: "let requires one or more name/value pairs followed by a body expression.";
+    readonly secUndefined: "sec is undefined for odd multiples of pi/2!";
+    readonly cscUndefined: "csc is undefined for multiples of pi!";
+    readonly cotUndefined: "cot is undefined for multiples of pi!";
+    readonly cothUndefined: "coth is undefined for 0!";
+    readonly cschUndefined: "csch is undefined for 0!";
+    readonly atanhUndefined: "atanh is undefined for 0!";
+    readonly cannotCreateArrayFromNaN: "Cannot create array from NaN!";
+    readonly expressionExpected: "Expression expected!. Received {{type}}!";
+    readonly unrecognizedMode: "\"{{mode}}\" is is not a valid mode!";
+    readonly notAPolynomial: "The expression is not a valid polynomial!";
+    readonly multidegreeMismatch: "The number of variables must match the multidegree of the polynomial!";
+    readonly cannotCreateMatrix: "Unable to create Matrix. Row dimensions do not match!";
+    readonly cannotMultiplyMatrix: "Cannot multiply matrix!";
+    readonly squareMatrixRequired: "The matrix must be square!";
+    readonly rowsMustMatch: "The rows of the matrices must match!";
+    readonly columnsMustMatch: "The columns of the matrices must match!";
+    readonly singularMatrix: "The provided matrix is singular!";
+    readonly matrixExpected: "Matrix expected! Received {{type}}.";
+    readonly mismatchedDimensions: "The dimensions must match for the function \"{{function}}\"!";
+    readonly incorrectCrossDimension: "The cross product is only defined for vectors of dimension 3!";
+    readonly vectorExpected: "Expected Vector! Received {{type}}.";
+    readonly univariatePolynomialOnly: "This function is only supported for univariate polynomials!";
+    readonly unknownVariable: "Unknown variable! \"{{variable}}\"";
+    readonly convergenceFailed: "Failed to converge! {{iters}} iterations were tried.";
+    readonly endPointIsRoot: "End point is root.";
+    readonly zeroDerivative: "The derivative is zero at x = {{x}}. Cannot continue.";
+    readonly tooManyUnknowns: "Too many unknowns!";
+    readonly solveSystemInfiniteSolutions: "This system does not have a finite isolated solution set!";
+    readonly solveSystemPolynomialOnly: "solveSystem currently supports only linear or polynomial systems!";
+    readonly solveSystemNonRationalUnsupported: "This nonlinear polynomial system requires non-rational or non-symbolic solving, which is not yet supported!";
+    readonly setJSFunctionExpectsFunction: "The function parameter when setting a JS function must be of type function!";
+    readonly functionRequiresMinAndMaxArgs: "You must provide a min and max arg when setting the function!";
+};
+export type ErrorType = keyof typeof EnglishErrorMessages;
+export type Language = 'eng' | 'spa' | 'fra' | 'deu' | 'por' | 'ita' | 'nld';
+export type MessageCatalog = {
+    [K in ErrorType]: string;
+};
+export declare const ErrorMessages: Partial<Record<Language, MessageCatalog>> & {
+    eng: MessageCatalog;
+};
+/** Registers one optional localized message catalog. */
+export declare function registerLanguage(language: Exclude<Language, 'eng'>, catalog: MessageCatalog): void;
+/** Formats an internal localized error message with named template values. */
+export declare function message(e: ErrorType, values?: {
+    [name: string]: string;
+}): string;