import type { PhpInput } from './_phpTypes.ts';
declare function createBcLibrary(): {
    PLUS: string;
    MINUS: string;
    BASE: number;
    scale: number;
    /**
     * Basic number structure
     */
    bc_num: () => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    /**
     * Base add function
     *
     //  Here is the full add routine that takes care of negative numbers.
     //  N1 is added to N2 and the result placed into RESULT.  SCALE_MIN
     //  is the minimum scale for the result.
     *
     * @param {bc_num} n1
     * @param {bc_num} n2
     * @param {int} scaleMin
     * @return bc_num
     */
    bc_add: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, scaleMin: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    /**
     * This is the "user callable" routine to compare numbers N1 and N2.
     * @param {bc_num} n1
     * @param {bc_num} n2
     * @return int -1, 0, 1  (n1 < n2, ===, n1 > n2)
     */
    bc_compare: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }) => -1 | 0 | 1;
    _one_mult: (num: number[], nPtr: number, size: number, digit: number, result: number[], rPtr: number) => void;
    bc_divide: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, scale: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    } | -1;
    MUL_BASE_DIGITS: number;
    MUL_SMALL_DIGITS: number;
    /**
     * @param n1 bc_num
     * @param n2 bc_num
     * @param scale [int] optional
     */
    bc_multiply: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, scale: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    new_sub_num: (length: number, scale: number, value: number[], ptr?: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    _bc_simp_mul: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n1len: number, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2len: number, fullScale: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    _bc_shift_addsub: (accum: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, val: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, shift: number, sub: number | boolean) => boolean;
    _bc_rec_mul: (u: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, ulen: number, v: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, vlen: number, fullScale: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    /**
     *
     * @param {bc_num} n1
     * @param {bc_num} n2
     * @param {boolean} useSign
     * @param {boolean} ignoreLast
     * @return -1, 0, 1 (see bc_compare)
     */
    _bc_do_compare: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, useSign: boolean, ignoreLast: boolean) => -1 | 0 | 1;
    bc_sub: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, scaleMin: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    _bc_do_add: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, scaleMin: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    /**
     * Perform a subtraction
     *
     * Perform subtraction: N2 is subtracted from N1 and the value is
     *  returned.  The signs of N1 and N2 are ignored.  Also, N1 is
     *  assumed to be larger than N2.  SCALE_MIN is the minimum scale
     *  of the result.
     *
     * Basic school maths says to subtract 2 numbers..
     * 1. make them the same length, the decimal places, and the integer part
     * 2. start from the right and subtract the two numbers from each other
     * 3. if the sum of the 2 numbers < 0, carry -1 to the next set and add 10
     * (ie 18 > carry 1 becomes 8). thus 0.9 + 0.9 = 1.8
     *
     * @param {bc_num} n1
     * @param {bc_num} n2
     * @param {int} scaleMin
     * @return bc_num
     */
    _bc_do_sub: (n1: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, n2: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }, scaleMin: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    /**
     *
     * @param {int} length
     * @param {int} scale
     * @return bc_num
     */
    bc_new_num: (length: number, scale: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    safe_emalloc: (size: number, len: number, extra: number) => number[];
    /**
     * Create a new number
     */
    bc_init_num: () => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    _bc_rm_leading_zeros: (num: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }) => void;
    /**
     * Convert to bc_num detecting scale
     */
    php_str2num: (str: string) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    CH_VAL: (c: string) => number;
    BCD_CHAR: (d: number) => string;
    isdigit: (c: string) => boolean;
    bc_str2num: (strIn: string, scale: number) => {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    };
    cint: (v: PhpInput) => number;
    /**
     * Basic min function
     * @param {int} a
     * @param {int} b
     */
    MIN: (a: number, b: number) => number;
    /**
     * Basic max function
     * @param {int} a
     * @param {int} b
     */
    MAX: (a: number, b: number) => number;
    /**
     * Basic odd function
     * @param {int} a
     */
    ODD: (a: number) => number;
    /**
     * replicate c function
     * @param {array} r     return (by reference)
     * @param {int} ptr
     * @param {string} chr    char to fill
     * @param {int} len       length to fill
     */
    memset: (r: number[], ptr: number, chr: number, len: number) => void;
    /**
     * Replacement c function
     * Obviously can't work like c does, so we've added an "offset"
     * param so you could do memcpy(dest+1, src, len) as memcpy(dest, 1, src, len)
     * Also only works on arrays
     */
    memcpy: (dest: number[], ptr: number, src: number[], srcptr: number, len: number) => boolean;
    /**
     * Determine if the number specified is zero or not
     * @param {bc_num} num    number to check
     * @return boolean      true when zero, false when not zero.
     */
    bc_is_zero: (num: {
        n_sign: string;
        n_len: number;
        n_scale: number;
        n_value: number[];
        toString: () => string;
    }) => boolean;
    bc_out_of_memory: () => never;
};
export declare function _bc(): ReturnType<typeof createBcLibrary>;
export {};