import type { ArrayType } from './array.js';
import type * as primitive from './primitives.js';
export interface ArrayOf<T, TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends ArrayLike<T>, Iterable<T>, ArrayBufferView<TArrayBuffer> {
    [n: number]: T;
}
export interface TypeArrayConstructor<T = unknown> {
    new (length: number): ArrayOf<T>;
    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer?: TArrayBuffer, byteOffset?: number, byteLength?: number): ArrayOf<T, TArrayBuffer>;
}
/** A definition for a type */
export interface Type<T = unknown> {
    readonly name: string;
    readonly size: number;
    readonly array?: TypeArrayConstructor<T>;
    readonly isDynamic?: boolean;
    /** Get a value from a buffer */
    get(this: void, buffer: ArrayBufferLike, offset: number): T;
    /** Set a value in a buffer */
    set(this: void, buffer: ArrayBufferLike, offset: number, value: T): void;
}
export declare function isArrayType(type: object): type is ArrayType;
export declare function isType<T = any>(type: unknown): type is Type<T>;
export declare function assertType<T>(t: unknown): asserts t is Type<T>;
/**
 * Resolve a type by name.
 * Useful for serialization (e.g. with JSON)
 */
export declare function resolveType<V>(typename: string): Type<V> | undefined;
/**
 * Register a type.
 * Structs and unions are registered automatically.
 * You should also be able to use this as a decorator.
 */
export declare function registerType(t: Type): void;
export type TypeLike = Type | {
    constructor: Type;
} | primitive.ValidName | undefined | null;
export type Value<T extends Type> = T extends Type<infer V> ? V : never;
export declare const Void: {
    readonly name: "void";
    readonly size: 0;
    readonly get: () => void;
    readonly set: () => void;
};
export type Void = typeof Void;