export { assert, assertDefined, defined, Required, assertHasProperty, assertHasMethod, hasProperty, isObject, assertIsObject, notImplemented, zip, chunk, chunkString, pad, fill, arrayEqual, mapObject, mapToObject, mapEntries, zipObjects, assertExtendsShape, isSubclass, stringLength, mod, ByteUtils, };
declare function assert(condition: boolean, message?: string | (() => string | undefined)): asserts condition;
declare function assertDefined<T>(input: T | undefined, message?: string): asserts input is T;
declare function defined<T>(input: T | undefined, message?: string): T;
declare function Required<T extends {}>(t: T): {
    [P in keyof T]-?: T[P];
};
declare function isObject(obj: unknown): obj is Record<string, unknown>;
declare function assertIsObject(obj: unknown, message?: string): asserts obj is object | Function;
declare function assertHasProperty<K extends string>(obj: unknown, key: K, message?: string): asserts obj is Record<K, unknown>;
declare function assertHasMethod<K extends string>(obj: unknown, key: K, message?: string): asserts obj is Record<K, Function>;
declare function hasProperty<K extends string>(obj: unknown, key: K): obj is Record<K, unknown>;
declare function notImplemented(): never;
declare function zip<T, S>(a: T[], b: S[]): [T, S][];
declare function chunk<T>(array: T[], size: number): T[][];
declare function chunkString(str: string, size: number): string[];
declare function pad<T>(array: T[], size: number, value: T | (() => T)): T[];
declare function fill<T>(size: number, value: T | (() => T)): T[];
declare function arrayEqual(aI: unknown[] | Uint8Array | ArrayBuffer, bI: unknown[] | Uint8Array | ArrayBuffer): boolean;
declare function mapObject<T extends Record<string, any>, S extends Record<keyof T, any>>(obj: T, fn: <K extends keyof T>(value: T[K], key: K) => S[K]): S;
declare function mapToObject<Key extends string | number | symbol, F extends <K extends Key>(key: K, i: number) => any>(keys: Key[], fn: F): { [K in Key]: ReturnType<F>; };
declare function zipObjects<T extends Record<string, any>, S extends Record<keyof T, any>>(t: T, s: S): { [K in keyof T]: [T[K], S[K]]; };
declare function mapEntries<T extends Record<string, any>, S>(obj: T, fn: (key: keyof T & string, value: T[keyof T & string]) => S): S[];
declare function assertExtendsShape<B extends Record<string, any>>(a: object, b: B): asserts a is Record<keyof B, any>;
type Constructor<T> = new (...args: any) => T;
declare function isSubclass<B extends Constructor<any>>(constructor: unknown, base: B): constructor is B;
declare function stringLength(str: string): number;
declare function mod(x: bigint, p: bigint): bigint;
declare const ByteUtils: {
    fromString(str: string): Uint8Array<ArrayBufferLike>;
    toString(bytes: Uint8Array): string;
    fromHex(hex: string): Uint8Array<ArrayBuffer>;
    toHex(bytes: Uint8Array): string;
    padStart(bytes: Uint8Array, size: number, value: number): Uint8Array;
    padEnd(bytes: Uint8Array, size: number, value: number): Uint8Array;
    concat(...arrays: Uint8Array[]): Uint8Array;
};