import { type Eq, type Order } from './compare';
import { Failure } from './failures';
import { type HashEq } from './hash';
import { type Result } from './result';
type MachineNumericKind = 'f64' | 'f32' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64';
type HostKind = 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined';
type NumericLikeInput = Numeric | number | bigint;
type IntegerLeafKind = 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64';
type BinaryNumericOperator = '+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '<<' | '>>' | '>>>';
type UnaryNumericOperator = '+' | '-' | '~';
export interface MachineNumericValue<Leaf extends MachineNumericKind> {
    readonly __soundscript_numeric_kind: Leaf;
    // #[effects(add: [], unknown: [direct])]
    toJSON(): {
        $numeric: Leaf;
        value: string;
    };
    // #[effects(add: [], unknown: [direct])]
    toString(): string;
    // #[effects(add: [], unknown: [direct])]
    valueOf(): never;
    [Symbol.toPrimitive](hint: string): string;
}
export type f64 = MachineNumericValue<'f64'>;
export type f32 = MachineNumericValue<'f32'>;
export type i8 = MachineNumericValue<'i8'>;
export type i16 = MachineNumericValue<'i16'>;
export type i32 = MachineNumericValue<'i32'>;
export type i64 = MachineNumericValue<'i64'>;
export type u8 = MachineNumericValue<'u8'>;
export type u16 = MachineNumericValue<'u16'>;
export type u32 = MachineNumericValue<'u32'>;
export type u64 = MachineNumericValue<'u64'>;
export type Numeric = f64 | f32 | i8 | i16 | i32 | i64 | u8 | u16 | u32 | u64;
export type Int = i8 | i16 | i32 | i64 | u8 | u16 | u32 | u64;
export type Float = f32 | f64;
type NumericByKind<Leaf extends MachineNumericKind> = Extract<Numeric, MachineNumericValue<Leaf>>;
export type MachineNumericOrHostKind = MachineNumericKind | HostKind;
export interface NumericFactory<T extends Numeric> {
    // #[effects(add: [], unknown: [direct])]
    (value: NumericLikeInput): T;
    readonly MAX_VALUE: T;
    readonly MIN_VALUE: T;
    // #[effects(add: [], unknown: [direct])]
    compare(left: T, right: T): number;
    // #[effects(add: [], unknown: [direct])]
    format(value: T): string;
    // #[effects(add: [], unknown: [direct])]
    parse(text: string): T;
    // #[effects(add: [], unknown: [direct])]
    tryParse(text: string): T | undefined;
}
export interface FloatFactory<T extends Float> extends NumericFactory<T> {
    // #[effects(add: [], unknown: [direct])]
    isFinite(value: T): boolean;
    // #[effects(add: [], unknown: [direct])]
    isNaN(value: T): boolean;
}
export interface IntegerFactory<T extends Int> extends NumericFactory<T> {
    // #[effects(add: [], unknown: [direct])]
    checkedAdd(left: T, right: T): Result<T, NumericOverflowFailure>;
    // #[effects(add: [], unknown: [direct])]
    checkedSub(left: T, right: T): Result<T, NumericOverflowFailure>;
    // #[effects(add: [], unknown: [direct])]
    checkedMul(left: T, right: T): Result<T, NumericOverflowFailure>;
    // #[effects(add: [], unknown: [direct])]
    checkedDiv(left: T, right: T): Result<T, NumericOverflowFailure | NumericDivisionByZeroFailure>;
    // #[effects(add: [], unknown: [direct])]
    checkedRem(left: T, right: T): Result<T, NumericDivisionByZeroFailure>;
    // #[effects(add: [], unknown: [direct])]
    checkedNeg(value: T): Result<T, NumericOverflowFailure>;
}
export declare class NumericOverflowFailure extends Failure {
    readonly leaf: IntegerLeafKind;
    readonly operation: 'add' | 'sub' | 'mul' | 'div' | 'rem' | 'neg';
    // #[effects(add: [mut])]
    constructor(leaf: IntegerLeafKind, operation: 'add' | 'sub' | 'mul' | 'div' | 'rem' | 'neg');
}
export declare class NumericDivisionByZeroFailure extends Failure {
    readonly leaf: IntegerLeafKind;
    readonly operation: 'div' | 'rem';
    // #[effects(add: [mut])]
    constructor(leaf: IntegerLeafKind, operation: 'div' | 'rem');
}
export declare const F64: FloatFactory<f64>;
export declare const F32: FloatFactory<f32>;
export declare const I8: IntegerFactory<i8>;
export declare const I16: IntegerFactory<i16>;
export declare const I32: IntegerFactory<i32>;
export declare const I64: IntegerFactory<i64>;
export declare const U8: IntegerFactory<u8>;
export declare const U16: IntegerFactory<u16>;
export declare const U32: IntegerFactory<u32>;
export declare const U64: IntegerFactory<u64>;
// #[effects(add: [])]
export declare function kindOf(value: unknown): MachineNumericOrHostKind;
// #[effects(add: [])]
export declare function isNumeric(value: unknown): value is Numeric;
// #[effects(add: [])]
export declare function isInt(value: unknown): value is Int;
// #[effects(add: [])]
export declare function isFloat(value: unknown): value is Float;
export declare const isF64: (value: unknown) => value is MachineNumericValue<"f64">;
export declare const isF32: (value: unknown) => value is MachineNumericValue<"f32">;
export declare const isI8: (value: unknown) => value is MachineNumericValue<"i8">;
export declare const isI16: (value: unknown) => value is MachineNumericValue<"i16">;
export declare const isI32: (value: unknown) => value is MachineNumericValue<"i32">;
export declare const isI64: (value: unknown) => value is MachineNumericValue<"i64">;
export declare const isU8: (value: unknown) => value is MachineNumericValue<"u8">;
export declare const isU16: (value: unknown) => value is MachineNumericValue<"u16">;
export declare const isU32: (value: unknown) => value is MachineNumericValue<"u32">;
export declare const isU64: (value: unknown) => value is MachineNumericValue<"u64">;
// #[effects(add: [], unknown: [direct])]
export declare function fitsF32(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsI8(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsI16(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsI32(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsI64(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsU8(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsU16(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsU32(value: unknown): boolean;
// #[effects(add: [], unknown: [direct])]
export declare function fitsU64(value: unknown): boolean;
// #[effects(add: [fails.throws], unknown: [direct])]
export declare function toHostNumber(value: Numeric): number;
// #[effects(add: [fails.throws], unknown: [direct])]
export declare function toHostBigInt(value: Int): bigint;
// #[effects(add: [], forward: [{ from: value.toString }], unknown: [direct])]
export declare function format(value: Numeric | number | bigint): string;
// #[effects(add: [fails.throws], unknown: [direct])]
export declare function keyOf(value: Numeric): string;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readF64(view: DataView, byteOffset: number, littleEndian?: boolean): f64;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readF32(view: DataView, byteOffset: number, littleEndian?: boolean): f32;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readI8(view: DataView, byteOffset: number): i8;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readI16(view: DataView, byteOffset: number, littleEndian?: boolean): i16;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readI32(view: DataView, byteOffset: number, littleEndian?: boolean): i32;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readI64(view: DataView, byteOffset: number, littleEndian?: boolean): i64;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readU8(view: DataView, byteOffset: number): u8;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readU16(view: DataView, byteOffset: number, littleEndian?: boolean): u16;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readU32(view: DataView, byteOffset: number, littleEndian?: boolean): u32;
// #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
export declare function readU64(view: DataView, byteOffset: number, littleEndian?: boolean): u64;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeF64(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeF32(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeI8(view: DataView, byteOffset: number, value: NumericLikeInput): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeI16(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeI32(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeI64(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeU8(view: DataView, byteOffset: number, value: NumericLikeInput): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeU16(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeU32(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
// #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
export declare function writeU64(view: DataView, byteOffset: number, value: NumericLikeInput, littleEndian?: boolean): void;
declare abstract class MachineNumericArrayView<Leaf extends MachineNumericKind> implements Iterable<NumericByKind<Leaf>> {
    [index: number]: NumericByKind<Leaf>;
    readonly BYTES_PER_ELEMENT: number;
    readonly buffer: ArrayBufferLike;
    readonly byteLength: number;
    readonly byteOffset: number;
    readonly length: number;
    protected readonly _view: DataView;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructor(buffer: ArrayBufferLike, bytesPerElement: number, byteOffset?: number, length?: number);
    // #[effects(add: [])]
    protected dataView(): DataView;
    // #[effects(add: [], unknown: [direct])]
    protected abstract leafKind(): Leaf;
    // #[effects(add: [], unknown: [direct])]
    protected abstract readFromView(view: DataView, byteOffset: number): NumericByKind<Leaf>;
    // #[effects(add: [], unknown: [direct])]
    protected abstract writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [], unknown: [direct])]
    protected abstract constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): MachineNumericArrayView<Leaf>;
    // #[effects(add: [], unknown: [direct])]
    protected coerceToLeaf(value: NumericLikeInput): NumericByKind<Leaf>;
    // #[effects(add: [], unknown: [direct])]
    at(index: number): NumericByKind<Leaf> | undefined;
    // #[effects(add: [fails.throws], unknown: [direct])]
    setAt(index: number, value: NumericLikeInput): void;
    // #[effects(add: [], unknown: [direct])]
    fill(value: NumericLikeInput, start?: number, end?: number): this;
    // #[effects(add: [fails.throws], unknown: [direct])]
    set(source: ArrayLike<NumericLikeInput> | Iterable<NumericLikeInput>, offset?: number): void;
    // #[effects(add: [], unknown: [direct])]
    copyWithin(target: number, start: number, end?: number): this;
    // #[effects(add: [suspend.yield])]
    keys(): IterableIterator<number>;
    // #[effects(add: [suspend.yield], unknown: [direct])]
    values(): IterableIterator<NumericByKind<Leaf>>;
    // #[effects(add: [suspend.yield], unknown: [direct])]
    entries(): IterableIterator<[
        number,
        NumericByKind<Leaf>
    ]>;
    // #[effects(add: [], unknown: [direct])]
    includes(searchElement: NumericLikeInput, fromIndex?: number): boolean;
    // #[effects(add: [], unknown: [direct])]
    indexOf(searchElement: NumericLikeInput, fromIndex?: number): number;
    // #[effects(add: [], unknown: [direct])]
    lastIndexOf(searchElement: NumericLikeInput, fromIndex?: number): number;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): MachineNumericArrayView<Leaf>;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): MachineNumericArrayView<Leaf>;
    [Symbol.iterator](): IterableIterator<NumericByKind<Leaf>>;
}
export declare class I8Array extends MachineNumericArrayView<'i8'> {
    static readonly BYTES_PER_ELEMENT = 1;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Int8Array): I8Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number);
    // #[effects(add: [])]
    protected leafKind(): 'i8';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): i8;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): I8Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): I8Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): I8Array;
    // #[effects(add: [], unknown: [direct])]
    toHostView(): Int8Array;
}
export declare class U8Array extends MachineNumericArrayView<'u8'> {
    static readonly BYTES_PER_ELEMENT = 1;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Uint8Array): U8Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number);
    // #[effects(add: [])]
    protected leafKind(): 'u8';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): u8;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): U8Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): U8Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): U8Array;
    // #[effects(add: [], unknown: [direct])]
    toHostView(): Uint8Array;
}
export declare class I16Array extends MachineNumericArrayView<'i16'> {
    static readonly BYTES_PER_ELEMENT = 2;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Int16Array): I16Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'i16';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): i16;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): I16Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): I16Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): I16Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): Int16Array;
}
export declare class U16Array extends MachineNumericArrayView<'u16'> {
    static readonly BYTES_PER_ELEMENT = 2;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Uint16Array): U16Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'u16';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): u16;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): U16Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): U16Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): U16Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): Uint16Array;
}
export declare class I32Array extends MachineNumericArrayView<'i32'> {
    static readonly BYTES_PER_ELEMENT = 4;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Int32Array): I32Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'i32';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): i32;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): I32Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): I32Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): I32Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): Int32Array;
}
export declare class U32Array extends MachineNumericArrayView<'u32'> {
    static readonly BYTES_PER_ELEMENT = 4;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Uint32Array): U32Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'u32';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): u32;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): U32Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): U32Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): U32Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): Uint32Array;
}
export declare class I64Array extends MachineNumericArrayView<'i64'> {
    static readonly BYTES_PER_ELEMENT = 8;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: BigInt64Array): I64Array;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'i64';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): i64;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): I64Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): I64Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): I64Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): BigInt64Array;
}
export declare class U64Array extends MachineNumericArrayView<'u64'> {
    static readonly BYTES_PER_ELEMENT = 8;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: BigUint64Array): U64Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'u64';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): u64;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): U64Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): U64Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): U64Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): BigUint64Array;
}
export declare class F32Array extends MachineNumericArrayView<'f32'> {
    static readonly BYTES_PER_ELEMENT = 4;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Float32Array): F32Array;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'f32';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): f32;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): F32Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): F32Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): F32Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): Float32Array;
}
export declare class F64Array extends MachineNumericArrayView<'f64'> {
    static readonly BYTES_PER_ELEMENT = 8;
    protected readonly _littleEndian: boolean;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    static fromHostView(view: Float64Array): F64Array;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number, littleEndian?: boolean);
    // #[effects(add: [])]
    protected leafKind(): 'f64';
    // #[effects(add: [], forward: [{ from: view.getBigInt64 }, { from: view.getBigUint64 }, { from: view.getFloat32 }, { from: view.getFloat64 }, { from: view.getInt16 }, { from: view.getInt32 }, { from: view.getInt8 }, { from: view.getUint16 }, { from: view.getUint32 }, { from: view.getUint8 }], unknown: [direct])]
    protected readFromView(view: DataView, byteOffset: number): f64;
    // #[effects(add: [fails.throws], forward: [{ from: view.setBigInt64 }, { from: view.setBigUint64 }, { from: view.setFloat32 }, { from: view.setFloat64 }, { from: view.setInt16 }, { from: view.setInt32 }, { from: view.setInt8 }, { from: view.setUint16 }, { from: view.setUint32 }, { from: view.setUint8 }], unknown: [direct])]
    protected writeToView(view: DataView, byteOffset: number, value: NumericLikeInput): void;
    // #[effects(add: [fails.throws, mut], unknown: [direct])]
    protected constructSubarray(buffer: ArrayBufferLike, byteOffset: number, length: number): F64Array;
    // #[effects(add: [], unknown: [direct])]
    subarray(begin?: number, end?: number): F64Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    slice(begin?: number, end?: number): F64Array;
    // #[effects(add: [fails.throws], unknown: [direct])]
    toHostView(): Float64Array;
}
// #[effects(add: [], forward: [leaf])]
export declare function equalAs<T extends Numeric>(leaf: NumericFactory<T>, left: NumericLikeInput, right: NumericLikeInput): boolean;
// #[effects(add: [], forward: [leaf, { from: leaf.compare }])]
export declare function compareAs<T extends Numeric>(leaf: NumericFactory<T>, left: NumericLikeInput, right: NumericLikeInput): number;
// #[effects(add: [])]
export declare function eqAs<T extends Numeric>(leaf: NumericFactory<T>): Eq<NumericLikeInput>;
// #[effects(add: [])]
export declare function orderAs<T extends Numeric>(leaf: NumericFactory<T>): Order<NumericLikeInput>;
// #[effects(add: [])]
export declare function hashEqAs<T extends Numeric>(leaf: NumericFactory<T>): HashEq<NumericLikeInput>;
// #[effects(add: [], forward: [leaf, { from: leaf.compare }])]
export declare function minAs<T extends Numeric>(leaf: NumericFactory<T>, values: Iterable<NumericLikeInput>): T | undefined;
// #[effects(add: [], forward: [leaf, { from: leaf.compare }])]
export declare function maxAs<T extends Numeric>(leaf: NumericFactory<T>, values: Iterable<NumericLikeInput>): T | undefined;
// #[effects(add: [fails.throws], forward: [leaf, { from: leaf.compare }], unknown: [direct])]
export declare function clampAs<T extends Numeric>(leaf: NumericFactory<T>, value: NumericLikeInput, minimum: NumericLikeInput, maximum: NumericLikeInput): T;
// #[effects(add: [], forward: [leaf, { from: leaf.compare }])]
export declare function binarySearchAs<T extends Numeric>(leaf: NumericFactory<T>, values: ArrayLike<NumericLikeInput>, target: NumericLikeInput): number;
// #[effects(add: [fails.throws, mut], unknown: [direct])]
export declare function __numericBinary<T extends Numeric>(operator: BinaryNumericOperator, left: T, right: T): T;
// #[effects(add: [fails.throws, mut], unknown: [direct])]
export declare function __numericUnary<T extends Numeric>(operator: UnaryNumericOperator, value: T): T;
// #[effects(add: [])]
export declare function __numericWasmLeaf<T>(value: unknown): T;
export {};
