low-level/dist/cjs/binary-data-types/uint.d.ts

import type { ByteArray, New, NumberLike, BinLike, WithArrayBuffer, WithString } from "./utils.js";
export interface BasicUintConstructable<T extends Uint> extends New<T> {
    readonly byteLength?: number;
    alloc(length?: number, fill?: string | Uint8Array | number): T;
    create(input: Buffer | Uint): T;
    from(arrayBuffer: WithArrayBuffer, byteOffset?: number, length?: number): T;
    from(data: WithImplicitCoercion<ByteArray | string>): T;
    from(str: WithString, encoding?: BufferEncoding): T;
    from(number: number, length?: number): T;
}
export declare class Uint {
    protected readonly buffer: Buffer;
    constructor(input: BinLike);
    static create<T>(this: New<T>, input: BinLike): T;
    static alloc<T>(this: New<T>, length: number, fill?: string | Uint8Array | number): T;
    static empty<T>(this: New<T>): T;
    static from<T>(this: New<T>, arrayBuffer: WithArrayBuffer, byteOffset?: number, length?: number): T;
    static from<T>(this: New<T>, data: WithImplicitCoercion<ByteArray | string>): T;
    static from<T>(this: New<T>, str: WithString, encoding?: BufferEncoding): T;
    static from<T>(this: New<T>, number: number, length?: number): T;
    /** @deprecated Use {@link Uint.from}(string) instead */
    static fromHex<T>(this: New<T>, hex: string): T;
    static concat<T>(this: New<T>, list: (Uint | Uint8Array)[], totalLength?: number): T;
    static isUint<T>(this: New<T>, input: any): input is T;
    clone(): this;
    toHex(): string;
    toString(encoding?: BufferEncoding): string;
    valueOf(): number;
    /**
     * Supports only a number up to (2^48)-1
     * For bigger numbers use {@link Uint.toBigInt}
     */
    toInt(): number;
    toBigInt(): bigint;
    getRaw(): Buffer;
    getAB(): ArrayBuffer | SharedArrayBuffer;
    getLen(): number;
    getLen(enc: "uint"): Uint;
    get(offset: number, length?: number): Uint;
    set(list: ArrayLike<number> | Uint, offset?: number): void;
    appendData(data: BinLike): Uint;
    nci_slice<T>(CLS: New<T>, start?: number, end?: number): T;
    nci_split<T>(CLS: New<T>, afterBytes: number): T[];
    slice(start?: number, end?: number): Uint;
    subarray(start?: number, end?: number): Uint;
    split(afterBytes: number): Uint[];
    iadd(value: NumberLike): void;
    add(value: NumberLike): this;
    isub(value: NumberLike): void;
    sub(value: NumberLike): this;
    imul(value: NumberLike): void;
    mul(value: NumberLike): this;
    idiv(value: NumberLike, returnRest?: boolean): number | undefined;
    div(value: NumberLike): this;
    mod(value: NumberLike): number;
    gt(value: NumberLike): boolean;
    gte(value: NumberLike): boolean;
    lt(value: NumberLike): boolean;
    lte(value: NumberLike): boolean;
    eq(value: NumberLike): boolean;
    /**
     * @deprecated Use {@link Uint.eq} with ! operator instead
     */
    eqn(value: NumberLike): boolean;
    protected addUint(value: Uint): void;
    protected addNumber(value: number): void;
    protected subUint(value: Uint): void;
    protected mulUint(value: Uint): void;
    protected mulNumber(value: number): void;
    protected divUint(value: Uint, returnRest: boolean): number | undefined;
    protected divNumber(value: number, returnRest: boolean): number | undefined;
    protected compare(value: NumberLike): 0 | 1 | -1;
    get [Symbol.toStringTag](): string;
    [Symbol.toPrimitive](hint: "string" | "number" | "default"): string | number | bigint;
}