@akala/core/dist/esm/helpers.d.ts

import type { LoggerWrapper } from "./logging/index.browser.js";
export type Remote<T> = {
    [key in keyof T]: T[key] extends (...args: any[]) => infer X ? X extends Promise<unknown> ? X : Promise<X> : (T[key] | undefined);
};
export type Serializable = string | number | string[] | number[] | boolean | boolean[] | SerializableObject | SerializableObject[];
export type TypedSerializable<T> = T extends Array<infer U> ? TypedSerializable<U>[] : string | number | boolean | TypedSerializableObject<T>;
export type SerializableObject = {
    [key: string]: Serializable;
};
export type TypedSerializableObject<T> = {
    [key in keyof T]: TypedSerializable<T>;
};
export interface Context<TState = unknown> {
    state?: TState;
    logger: LoggerWrapper;
    abort: AbortController;
}
export declare let defaultContext: Context;
export declare function setDefaultContext(context: Context): void;
export declare function noop(): void;
export declare function lazy<T>(factory: () => T): () => T;
export declare function spread<A>(a: A): A;
export declare function spread<A, B>(a: A, b: B): A & B;
export declare function spread<A, B, C>(a: A, b: B, c: C): A & B & C;
export declare function spread<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
export declare function spread<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): A & B & C & D & E;
export declare function spread(...args: object[]): object;
export interface Translator {
    locale: string | Intl.Locale;
    translate(key: string): string;
    translate(format: string, ...parameters: unknown[]): string;
    translate(obj: {
        key: string;
        fallback: string;
    }): string;
    translate(obj: {
        key: string;
        fallback: string;
    }, ...parameters: unknown[]): string;
}
export type BufferEncoding = "ascii" | "utf8" | "utf-8" | "base64" | "base64url" | "binary" | "hex";
export declare class IsomorphicBuffer implements Iterable<number, number, number> {
    private readonly offset?;
    private readonly end?;
    private readonly buffer;
    constructor(buffer: Uint8Array<ArrayBufferLike> | number | number[], offset?: number, end?: number);
    readonly length: number;
    static fromBuffer(buffer: Uint8Array<ArrayBufferLike>): IsomorphicBuffer;
    static fromArrayBuffer(abuffer: ArrayBufferLike): IsomorphicBuffer;
    copy(source: IsomorphicBuffer, offset: number, sourceOffset?: number, length?: number): void;
    toArray(): Uint8Array<ArrayBuffer>;
    indexOf(value: number, offset?: number): number;
    static concat(buffers: IsomorphicBuffer[]): IsomorphicBuffer;
    static getInitLength(s: string, encoding?: BufferEncoding): number;
    static from(s: string, encoding?: BufferEncoding): IsomorphicBuffer;
    toString(encoding: BufferEncoding, offset?: number, end?: number): string;
    toJSON(): {
        type: "Buffer";
        data: number[];
    };
    write(s: string, offset: number, length?: number, encoding?: BufferEncoding): any;
    private ensureOffset;
    fill(value: number, start?: number, end?: number): void;
    readInt8(index?: number): number;
    writeInt8(value: number, index?: number): void;
    readUInt8(index?: number): number;
    writeUInt8(value: number, index?: number): void;
    readDoubleBE(index?: number): number;
    writeDoubleBE(value: number, index?: number): void;
    readDoubleLE(index?: number): number;
    writeDoubleLE(value: number, index?: number): void;
    readFloatBE(index?: number): number;
    writeFloatBE(value: number, index?: number): void;
    readFloatLE(index?: number): number;
    writeFloatLE(value: number, index?: number): void;
    readUInt16LE(index?: number): number;
    writeUInt16LE(value: number, index?: number): void;
    readUInt16BE(index?: number): number;
    writeUInt16BE(value: number, index?: number): void;
    readInt16LE(index?: number): number;
    writeInt16LE(value: number, index?: number): void;
    readInt16BE(index?: number): number;
    writeInt16BE(value: number, index?: number): void;
    readUInt32LE(index?: number): number;
    writeUInt32LE(value: number, index?: number): void;
    readUInt32BE(index?: number): number;
    writeUInt32BE(value: number, index?: number): void;
    readInt32BE(index?: number): number;
    writeInt32BE(value: number, index?: number): void;
    readInt32LE(index?: number): number;
    writeInt32LE(value: number, index?: number): void;
    readBigUInt64LE(index?: number): bigint;
    writeBigUInt64LE(value: bigint, index?: number): void;
    readBigUInt64BE(index?: number): bigint;
    writeBigUInt64BE(value: bigint, index?: number): void;
    readBigInt64LE(index?: number): bigint;
    writeBigInt64LE(value: bigint, index?: number): void;
    readBigInt64BE(index?: number): bigint;
    writeBigInt64BE(value: bigint, index?: number): void;
    readUIntLE(index: number, byteLength: number): number;
    writeUIntLE(value: number, index: number, byteLength: number): void;
    readUIntBE(index: number, byteLength: number): number;
    writeUIntBE(value: number, index: number, byteLength: number): void;
    subarray(start: number, end?: number): IsomorphicBuffer;
    [Symbol.iterator](): Iterator<number, number, number>;
    inspect(): any;
    valueOf(): {
        type: 'Buffer';
        data: number[];
    };
    equals(other: IsomorphicBuffer): boolean;
}
export declare function throttle<T>(threshold: number): (handler: () => Promise<T>) => Promise<T>;