import type { RoUint8Array, RoPair, RoArray } from "@xlabs-xyz/const-utils";
import type { Endianness, NumberSize, NumSizeToPrimitive, DeriveType, Layout, BytesItem, FixedConversion, CustomConversion } from "./layout.js";
import { defaultEndianness } from "./layout.js";
export type CustomizableBytes = undefined | Layout | RoUint8Array | FixedConversion<RoUint8Array, any> | CustomConversion<RoUint8Array, any> | RoPair<Layout, FixedConversion<any, any> | CustomConversion<any, any>>;
export type BytesBase = ({} | {
    readonly name: string;
}) & Omit<BytesItem, "binary" | "custom" | "layout">;
type CombineObjects<T, U> = {
    readonly [K in keyof T | keyof U]: K extends keyof T ? T[K] : K extends keyof U ? U[K] : never;
};
export type CustomizableBytesReturn<B extends BytesBase, P extends CustomizableBytes> = CombineObjects<B, P extends undefined ? {
    binary: "bytes";
} : P extends Layout ? {
    binary: "bytes";
    layout: P;
} : P extends RoUint8Array | FixedConversion<RoUint8Array, any> | CustomConversion<RoUint8Array, any> ? {
    binary: "bytes";
    custom: P;
} : P extends readonly [Layout, FixedConversion<any, any> | CustomConversion<any, any>] ? {
    binary: "bytes";
    layout: P[0];
    custom: P[1];
} : never>;
export declare const customizableBytes: <const B extends BytesBase, const C extends CustomizableBytes>(base: B, spec?: C) => CustomizableBytesReturn<B, C>;
export declare function boolItem(permissive?: boolean): {
    readonly binary: "uint";
    readonly size: 1;
    readonly custom: {
        readonly to: (encoded: number) => boolean;
        readonly from: (value: boolean) => number;
    };
};
export declare function enumItem<const E extends RoArray<RoPair<string, number>>, const S extends NumberSize = 1, const EN extends Endianness = typeof defaultEndianness>(entries: E, opts?: {
    size?: S;
    endianness?: EN;
}): {
    readonly binary: "uint";
    readonly size: S;
    readonly endianness: EN;
    readonly custom: {
        readonly to: (encoded: number) => E[number][0];
        readonly from: (name: E[number][0]) => number;
    };
};
declare const baseOptionItem: <const T extends CustomizableBytes>(someType: T) => {
    readonly binary: "switch";
    readonly idSize: 1;
    readonly idTag: "isSome";
    readonly layouts: readonly [readonly [readonly [0, false], readonly []], readonly [readonly [1, true], readonly [CustomizableBytesReturn<{
        readonly name: "value";
    }, T>]]];
};
type BaseOptionItem<T extends CustomizableBytes> = DeriveType<ReturnType<typeof baseOptionItem<T>>>;
type BaseOptionValue<T extends CustomizableBytes> = DeriveType<CustomizableBytesReturn<{}, T>> | undefined;
export declare function optionItem<const T extends CustomizableBytes>(optVal: T): {
    readonly binary: "bytes";
    readonly layout: {
        readonly binary: "switch";
        readonly idSize: 1;
        readonly idTag: "isSome";
        readonly layouts: readonly [readonly [readonly [0, false], readonly []], readonly [readonly [1, true], readonly [CustomizableBytesReturn<{
            readonly name: "value";
        }, T>]]];
    };
    readonly custom: {
        to: (obj: BaseOptionItem<T>) => BaseOptionValue<T>;
        from: (value: BaseOptionValue<T>) => BaseOptionItem<T>;
    };
};
export type BitsetKey = string | undefined;
export type Bitset<B extends RoArray<BitsetKey>> = {
    [K in B[number] as K extends "" | undefined ? never : K]: boolean;
};
type ByteSize = [
    never,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    4,
    4,
    4,
    4,
    4,
    4,
    4,
    4,
    5,
    5,
    5,
    5,
    5,
    5,
    5,
    5,
    6,
    6,
    6,
    6,
    6,
    6,
    6,
    6
];
type BitsizeToBytesize<N extends number> = N extends keyof ByteSize ? ByteSize[N] : number;
export type BitsetItem<B extends RoArray<BitsetKey>, S extends number = BitsizeToBytesize<B["length"]>> = {
    binary: "uint";
    size: S;
    custom: {
        to: (encoded: NumSizeToPrimitive<S>) => Bitset<B>;
        from: (obj: Bitset<B>) => NumSizeToPrimitive<S>;
    };
};
export declare function bitsetItem<const B extends RoArray<BitsetKey>, const S extends number = BitsizeToBytesize<B["length"]>>(bitnames: B, size?: S): BitsetItem<B, S>;
export declare const stringConversion: {
    readonly to: (encoded: RoUint8Array) => string;
    readonly from: (decoded: string) => NodeJS.NonSharedUint8Array;
};
export {};
//# sourceMappingURL=items.d.ts.map