import type { ClassLike } from 'utilium';
import type { Options } from './attributes.js';
import type { Field, FieldConfigInit, FieldOptions } from './fields.js';
import * as primitive from './primitives.js';
import type { StructConstructor, StructType } from './structs.shared.js';
interface Init {
    fields: Field[];
}
type _DecoratorMetadata = DecoratorMetadata & {
    structInit?: Init;
};
interface DecoratorContext {
    metadata: _DecoratorMetadata;
}
/**
 * Decorates a class as a struct.
 */
export declare function struct(this: Function | Options | void, ...options: Options[]): <T extends ClassLike>(target: T, context: ClassDecoratorContext<T> & DecoratorContext) => T;
export declare namespace struct {
    var packed: typeof struct;
    var align: (alignment: number) => typeof struct;
}
/**
 * deprecated Use the new `union` function instead.
 */
export interface UnionOptions {
    align?: number;
}
/**
 * Decorates a class as a union.
 */
export declare function union(options?: UnionOptions): <T extends ClassLike>(target: T, context: ClassDecoratorContext<T> & DecoratorContext) => T;
/**
 * Decorates a class member as a struct field.
 */
export declare function field<V>(type: FieldConfigInit | StructConstructor<any>, opt?: FieldOptions): (value: Target<V>, context: Context<V>) => Result<V>;
type Target<V> = ClassAccessorDecoratorTarget<any, V>;
type Result<V> = ClassAccessorDecoratorResult<any, V>;
type Context<V> = ClassAccessorDecoratorContext<any, V> & DecoratorContext;
type Decorator<V> = (value: Target<V>, context: Context<V>) => Result<V>;
declare function _shortcut<T extends primitive.ValidName>(typeName: T): {
    <V>(length: number, options?: Omit<FieldOptions, "length">): Decorator<V>;
    <V>(value: Target<V>, context: Context<V>): Result<V>;
};
/**
 * Shortcuts for primitive types
 * Instead of writing `@field(primitive.types[primitive.normalize(<type>)])`, you can write `@types.type`.
 * You can also use `@types.type(length)` for arrays.
 */
export declare const types: { [K in primitive.ValidName]: ReturnType<typeof _shortcut<K>>; };
/**
 * Due to restrictions on decorators, `@struct` can not narrow the type of the class.
 * You must use the function to wrap the base class in the `extends` clause to force the correct type.
 */
export declare function $from<const T extends {}>(t: ClassLike<T>): StructConstructor<T>;
export declare namespace $from {
    var typed: <const T extends TypedArray>(t: ClassLike<T>) => StructFromTypedArray<T>;
}
type TypedArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T> | Int8Array<T> | Int16Array<T> | Int32Array<T> | Float16Array<T> | Float32Array<T> | Float64Array<T> | BigInt64Array<T> | BigUint64Array<T>;
export interface StructFromTypedArray<T extends TypedArray> extends StructType<{}> {
    prototype: T;
    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, byteLength?: number): T;
    new (length: number): T;
    new (array: ArrayLike<number>): T;
    readonly BYTES_PER_ELEMENT?: number;
}
export {};