import type { RoUint8Array, RoNeTuple, RoPair, RoArray, TupleWithLength, If } from "@xlabs-xyz/const-utils";
export type NumType = number | bigint;
export type PrimitiveType = NumType | RoUint8Array;
export type LayoutObject = {
    readonly [key: string]: any;
};
export declare const binaryLiterals: readonly ["int", "uint", "bytes", "array", "switch"];
export type BinaryLiterals = typeof binaryLiterals[number];
export type Endianness = "little" | "big";
export declare const defaultEndianness = "big";
export declare const numberMaxSize = 6;
export type NumberSize = 1 | 2 | 3 | 4 | 5 | 6;
export type NumSizeToPrimitive<Size extends number> = Size extends NumberSize ? number : Size & NumberSize extends never ? bigint : number | bigint;
export type FixedConversion<FromType, ToType> = {
    readonly to: ToType;
    readonly from: FromType;
};
export type CustomConversion<FromType, ToType> = {
    readonly to: (val: FromType) => ToType;
    readonly from: (val: ToType) => FromType;
};
export interface ItemBase<BL extends BinaryLiterals> {
    readonly binary: BL;
}
interface FixedOmittableCustom<T extends PrimitiveType> {
    readonly custom: T;
    readonly omit?: boolean;
}
export interface LengthPrefixed {
    readonly lengthSize: NumberSize;
    readonly lengthEndianness?: Endianness;
}
interface NumItemBase<T extends NumType, Signed extends boolean> extends ItemBase<If<Signed, "int", "uint">> {
    readonly size: T extends bigint ? number : NumberSize;
    readonly endianness?: Endianness;
}
export interface FixedPrimitiveNum<T extends NumType, Signed extends boolean> extends NumItemBase<T, Signed>, FixedOmittableCustom<T> {
}
export interface OptionalToFromNum<T extends NumType, Signed extends boolean> extends NumItemBase<T, Signed> {
    readonly custom?: FixedConversion<T, any> | CustomConversion<T, any>;
}
export interface FixedPrimitiveBytes extends ItemBase<"bytes">, FixedOmittableCustom<RoUint8Array> {
}
export interface FlexPureBytes extends ItemBase<"bytes"> {
    readonly custom?: RoUint8Array | FixedConversion<RoUint8Array, any> | CustomConversion<RoUint8Array, any>;
}
export interface FlexLayoutBytes extends ItemBase<"bytes"> {
    readonly custom?: FixedConversion<any, any> | CustomConversion<any, any>;
    readonly layout: Layout;
}
export interface ManualSizePureBytes extends FlexPureBytes {
    readonly size: number;
}
export interface LengthPrefixedPureBytes extends FlexPureBytes, LengthPrefixed {
}
export interface ManualSizeLayoutBytes extends FlexLayoutBytes {
    readonly size: number;
}
export interface LengthPrefixedLayoutBytes extends FlexLayoutBytes, LengthPrefixed {
}
interface ArrayItemBase extends ItemBase<"array"> {
    readonly layout: Layout;
}
export interface FixedLengthArray extends ArrayItemBase {
    readonly length: number;
}
export interface LengthPrefixedArray extends ArrayItemBase, LengthPrefixed {
}
export interface RemainderArray extends ArrayItemBase {
}
type PlainId = number;
type ConversionId = readonly [number, unknown];
type IdProperLayoutPair<Id extends PlainId | ConversionId, P extends ProperLayout = ProperLayout> = RoPair<Id, P>;
type IdProperLayoutPairs = RoArray<IdProperLayoutPair<PlainId>> | RoArray<IdProperLayoutPair<ConversionId>>;
type DistributiveAtLeast1<T> = T extends any ? RoNeTuple<T> : never;
export interface SwitchItem extends ItemBase<"switch"> {
    readonly idSize: NumberSize;
    readonly idEndianness?: Endianness;
    readonly idTag?: string;
    readonly layouts: DistributiveAtLeast1<IdProperLayoutPair<PlainId> | IdProperLayoutPair<ConversionId>>;
}
export type NumItem<Signed extends boolean = boolean> = Signed extends infer S extends boolean ? FixedPrimitiveNum<number, S> | OptionalToFromNum<number, S> | FixedPrimitiveNum<bigint, S> | OptionalToFromNum<bigint, S> : never;
export type UintItem = NumItem<false>;
export type IntItem = NumItem<true>;
export type BytesItem = FixedPrimitiveBytes | FlexPureBytes | ManualSizePureBytes | LengthPrefixedPureBytes | FlexLayoutBytes | ManualSizeLayoutBytes | LengthPrefixedLayoutBytes;
export type ArrayItem = FixedLengthArray | LengthPrefixedArray | RemainderArray;
export type Item = NumItem | BytesItem | ArrayItem | SwitchItem;
export type NamedItem = Item & {
    readonly name: string;
};
export type ProperLayout = RoArray<NamedItem>;
export type Layout = Item | ProperLayout;
type NameOrOmitted<T extends {
    readonly name: string;
}> = T extends {
    readonly omit: true;
} ? never : T["name"];
export type DeriveType<L extends Layout> = Layout extends L ? unknown : L extends infer LI extends Item ? ItemToType<LI> : L extends infer P extends ProperLayout ? {
    readonly [I in P[number] as NameOrOmitted<I>]: ItemToType<I>;
} : never;
type ItemToType<II extends Item> = II extends infer I extends Item ? I extends {
    readonly omit: true;
} ? undefined : I extends NumItem ? NumItemToType<I> : I extends BytesItem ? BytesItemToType<I> : I extends ArrayItem ? ArrayItemToType<I> : I extends SwitchItem ? SwitchItemToType<I> : never : never;
type NumItemToType<I extends NumItem> = I["custom"] extends CustomConversion<infer _From, infer To> ? To : I["custom"] extends FixedConversion<infer _From, infer To> ? To : I["custom"] extends undefined ? NumSizeToPrimitive<I["size"]> : I["custom"] extends NumType ? I["custom"] : NumSizeToPrimitive<I["size"]>;
type BytesItemToType<I extends BytesItem> = I extends {
    readonly layout: Layout;
} ? I["custom"] extends CustomConversion<infer _From, infer To> ? To : I["custom"] extends FixedConversion<infer _From, infer To> ? To : DeriveType<I["layout"]> : I["custom"] extends CustomConversion<RoUint8Array, infer To> ? To : I["custom"] extends FixedConversion<RoUint8Array, infer To> ? To : RoUint8Array;
type ArrayItemToType<I extends ArrayItem> = DeriveType<I["layout"]> extends infer DT ? I extends {
    readonly length: infer AL extends number;
} ? number extends AL ? RoArray<DT> : Readonly<TupleWithLength<DT, AL>> : RoArray<DT> : never;
type MaybeConvert<Id extends PlainId | ConversionId> = Id extends RoPair<number, infer Converted> ? Converted : Id;
type IdLayoutPairToVariant<Pair, IdTag extends string> = Pair extends IdProperLayoutPair<infer MaybeConversionId, infer P extends ProperLayout> ? DeriveType<P> extends infer DT extends LayoutObject ? {
    readonly [K in IdTag | keyof DT]: K extends keyof DT ? DT[K] : MaybeConvert<MaybeConversionId>;
} : never : never;
type IdLayoutPairsToTypeUnion<A extends IdProperLayoutPairs, IdTag extends string> = A extends RoArray<infer Pair> ? IdLayoutPairToVariant<Pair, IdTag> : never;
type SwitchItemToType<I extends SwitchItem> = IdLayoutPairsToTypeUnion<I["layouts"], I["idTag"] extends infer ID extends string ? ID extends undefined ? "id" : ID : never>;
export {};
//# sourceMappingURL=layout.d.ts.map