dnum/dist/index.d.ts

Small library for big decimal numbers.

export declare function abs(num: Numberish, decimals?: Decimals): Dnum;

export declare function add(num1: Numberish, num2: Numberish, decimals?: Decimals): Dnum;

declare type AliasedOptions<Options extends Record<string, unknown>, AliasName extends keyof Options> = Options | Options[AliasName];

export declare function ceil(num: Numberish, decimals?: Decimals): Dnum;

declare function compare(num1: Numberish, num2: Numberish): 1 | -1 | 0;
export { compare as cmp }
export { compare }

export declare type Decimals = number;

declare function divide(num1: Numberish, num2: Numberish, optionsOrDecimals?: AliasedOptions<{
    decimals?: Decimals;
    rounding?: Rounding;
}, "decimals">): Dnum;
export { divide as div }
export { divide }

export declare type Dnum = readonly [value: Value, decimals: Decimals];

declare function equal(num1: Numberish, num2: Numberish): boolean;
export { equal as eq }
export { equal }

export declare function equalizeDecimals(nums: Dnum[], decimals?: number): Dnum[];

export declare function floor(num: Numberish, decimals?: Decimals): Dnum;

export declare function format(dnum: Dnum, optionsOrDigits?: Parameters<typeof toParts>[1] & {
    compact?: boolean;
    locale?: ConstructorParameters<typeof Intl.NumberFormat>[0];
    signDisplay?: SignDisplay;
}): string;

export declare function from(value: Numberish, decimals?: number | true): Dnum;

export declare function fromJSON(jsonValue: string): Dnum;

declare function greaterThan(num1: Numberish, num2: Numberish): boolean;
export { greaterThan }
export { greaterThan as gt }

declare function greaterThanOrEqual(num1: Numberish, num2: Numberish): boolean;
export { greaterThanOrEqual }
export { greaterThanOrEqual as gte }

export declare function isDnum(value: unknown): value is Dnum;

declare function lessThan(num1: Numberish, num2: Numberish): boolean;
export { lessThan }
export { lessThan as lt }

declare function lessThanOrEqual(num1: Numberish, num2: Numberish): boolean;
export { lessThanOrEqual }
export { lessThanOrEqual as lte }

declare function multiply(num1: Numberish, num2: Numberish, optionsOrDecimals?: AliasedOptions<{
    decimals?: Decimals;
    rounding?: Rounding;
}, "decimals">): Dnum;
export { multiply as mul }
export { multiply }

export declare type Numberish = bigint | number | string | Dnum;

declare function remainder(num1: Numberish, num2: Numberish, decimals?: Decimals): Dnum;
export { remainder as rem }
export { remainder }

export declare function round(num: Numberish, optionsOrDecimals?: AliasedOptions<{
    decimals?: Decimals;
    rounding?: Rounding;
}, "decimals">): Dnum;

export declare type Rounding = "ROUND_HALF" | "ROUND_UP" | "ROUND_DOWN";

export declare function setDecimals(value: Dnum, decimals: Decimals, options?: {
    rounding?: Rounding;
}): Dnum;

declare type SignDisplay = "auto" | "always" | "exceptZero" | "negative" | "never";

declare function subtract(num1: Numberish, num2: Numberish, decimals?: Decimals): Dnum;
export { subtract as sub }
export { subtract }

export declare function toJSON([value, decimals]: Dnum): string;

export declare function toNumber(value: Dnum, optionsOrDigits?: Parameters<typeof toParts>[1]): number;

export declare function toParts(dnum: Dnum, optionsOrDigits?: AliasedOptions<{
    digits?: number;
    trailingZeros?: boolean;
    decimalsRounding?: Rounding;
}, "digits">): [
whole: bigint,
fraction: string | null
];

declare function toString_2(value: Dnum, optionsOrDigits?: Parameters<typeof toParts>[1]): string;
export { toString_2 as toString }

export declare type Value = bigint;

export { }