import * as zod from 'zod';

declare const INTEGER_ARRAY_TYPES: readonly ["signed", "unsigned"];
type IntegerArrayType = (typeof INTEGER_ARRAY_TYPES)[number];
declare const INTEGER_ARRAY_BITS: readonly [8, 16, 32];
type IntegerArrayBit = (typeof INTEGER_ARRAY_BITS)[number];
declare const INTEGER_ARRAY_CATEGORIES: readonly ["clamped", "standard"];
type IntegerArrayCategory = (typeof INTEGER_ARRAY_CATEGORIES)[number];
declare const INT8_ARRAY_SCHEMA: zod.ZodType<Int8Array, zod.ZodTypeDef, Int8Array>;
declare const INT16_ARRAY_SCHEMA: zod.ZodType<Int16Array, zod.ZodTypeDef, Int16Array>;
declare const INT32_ARRAY_SCHEMA: zod.ZodType<Int32Array, zod.ZodTypeDef, Int32Array>;
declare const INT_ARRAY_SCHEMAS: {
    readonly 8: {
        readonly standard: zod.ZodType<Int8Array, zod.ZodTypeDef, Int8Array>;
    };
    readonly 16: {
        readonly standard: zod.ZodType<Int16Array, zod.ZodTypeDef, Int16Array>;
    };
    readonly 32: {
        readonly standard: zod.ZodType<Int32Array, zod.ZodTypeDef, Int32Array>;
    };
};
declare const UINT8_ARRAY_SCHEMA: zod.ZodType<Uint8Array, zod.ZodTypeDef, Uint8Array>;
declare const UINT8_CLAMPED_ARRAY_SCHEMA: zod.ZodType<Uint8ClampedArray, zod.ZodTypeDef, Uint8ClampedArray>;
declare const UINT16_ARRAY_SCHEMA: zod.ZodType<Uint16Array, zod.ZodTypeDef, Uint16Array>;
declare const UINT32_ARRAY_SCHEMA: zod.ZodType<Uint32Array, zod.ZodTypeDef, Uint32Array>;
declare const UINT_ARRAY_SCHEMAS: {
    readonly 8: {
        readonly standard: zod.ZodType<Uint8Array, zod.ZodTypeDef, Uint8Array>;
        readonly clamped: zod.ZodType<Uint8ClampedArray, zod.ZodTypeDef, Uint8ClampedArray>;
    };
    readonly 16: {
        readonly standard: zod.ZodType<Uint16Array, zod.ZodTypeDef, Uint16Array>;
    };
    readonly 32: {
        readonly standard: zod.ZodType<Uint32Array, zod.ZodTypeDef, Uint32Array>;
    };
};
declare const INTEGER_ARRAY_SCHEMAS: {
    readonly signed: {
        readonly 8: {
            readonly standard: zod.ZodType<Int8Array, zod.ZodTypeDef, Int8Array>;
        };
        readonly 16: {
            readonly standard: zod.ZodType<Int16Array, zod.ZodTypeDef, Int16Array>;
        };
        readonly 32: {
            readonly standard: zod.ZodType<Int32Array, zod.ZodTypeDef, Int32Array>;
        };
    };
    readonly unsigned: {
        readonly 8: {
            readonly standard: zod.ZodType<Uint8Array, zod.ZodTypeDef, Uint8Array>;
            readonly clamped: zod.ZodType<Uint8ClampedArray, zod.ZodTypeDef, Uint8ClampedArray>;
        };
        readonly 16: {
            readonly standard: zod.ZodType<Uint16Array, zod.ZodTypeDef, Uint16Array>;
        };
        readonly 32: {
            readonly standard: zod.ZodType<Uint32Array, zod.ZodTypeDef, Uint32Array>;
        };
    };
};
interface IntegerArrays {
    signed: {
        8: {
            standard: Int8Array;
        };
        16: {
            standard: Int16Array;
        };
        32: {
            standard: Int32Array;
        };
    };
    unsigned: {
        8: {
            standard: Uint8Array;
            clamped: Uint8ClampedArray;
        };
        16: {
            standard: Uint16Array;
        };
        32: {
            standard: Uint32Array;
        };
    };
}
type IntArray<Bit extends IntegerArrayBit> = IntegerArrays["signed"][Bit]["standard"];
type UintArray<Bit extends IntegerArrayBit, Category extends IntegerArrayCategory> = Bit extends 8 ? IntegerArrays["unsigned"][8][Category] : IntegerArrays["unsigned"][Bit]["standard"];
type IntegerArray<Type extends IntegerArrayType, Bit extends IntegerArrayBit, Category extends IntegerArrayCategory = Type extends "unsigned" ? Bit extends 8 ? IntegerArrayCategory : "standard" : "standard"> = Type extends "signed" ? IntArray<Bit> : Type extends "unsigned" ? UintArray<Bit, Category> : never;
type IntArrayOptions<Type extends IntegerArrayType, Bit extends IntegerArrayBit> = {
    type: Type;
    bit: Bit;
};
type Uint8ArrayOptions<Clamped extends boolean | undefined = undefined> = {
    type: "unsigned";
    clamped?: Clamped;
    bit: 8;
};
type IntegerArrayOptions<Type extends IntegerArrayType, Bit extends IntegerArrayBit, Clamped extends boolean | undefined = undefined> = Type extends "unsigned" ? Bit extends 8 ? Uint8ArrayOptions<Type extends "unsigned" ? (Bit extends 8 ? Clamped : undefined) : undefined> : IntArrayOptions<Type, Bit> : IntArrayOptions<Type, Bit>;
declare function isUnsigned(type: IntegerArrayType): type is "unsigned";
declare function is8Bit(bit: IntegerArrayBit): bit is 8;
/**
 * FIXME:
 * There's an unwanted case, where the passed options -`{ type: "standard", bit: 8 }`
 * the return value will be: `Uint8Array` | `Uint8ClampedArray`.
 * What is expected: it should pick one, and base it on the `clamped` optional key in options.
 */
declare function validateIntegerArray<Type extends IntegerArrayType, Bit extends IntegerArrayBit, Clamped extends boolean | undefined = undefined>(value: unknown, options: IntegerArrayOptions<Type, Bit, Clamped>): asserts value is IntegerArray<Type, Bit, IntegerArrayCategory>;
/**
 * FIXME:
 * There's an unwanted case, where the passed options -`{ type: "standard", bit: 8 }`
 * the return value will be: `Uint8Array` | `Uint8ClampedArray`.
 * What is expected: it should pick one, and base it on the `clamped` optional key in options.
 */
declare function isIntegerArray<Type extends IntegerArrayType, Bit extends IntegerArrayBit, Clamped extends boolean | undefined = undefined>(value: unknown, options: IntegerArrayOptions<Type, Bit, Clamped>): value is IntegerArray<Type, Bit, IntegerArrayCategory>;

export { INT16_ARRAY_SCHEMA, INT32_ARRAY_SCHEMA, INT8_ARRAY_SCHEMA, INTEGER_ARRAY_BITS, INTEGER_ARRAY_CATEGORIES, INTEGER_ARRAY_SCHEMAS, INTEGER_ARRAY_TYPES, INT_ARRAY_SCHEMAS, IntArray, IntegerArray, IntegerArrayBit, IntegerArrayCategory, IntegerArrayOptions, IntegerArrayType, IntegerArrays, UINT16_ARRAY_SCHEMA, UINT32_ARRAY_SCHEMA, UINT8_ARRAY_SCHEMA, UINT8_CLAMPED_ARRAY_SCHEMA, UINT_ARRAY_SCHEMAS, UintArray, is8Bit, isIntegerArray, isUnsigned, validateIntegerArray };