import type { Opts, RoArray, RoNeTuple, RoPair, Brand } from "@xlabs-xyz/const-utils";
import { Rational, Rationalish } from "./rational.js";
export type SymbolSpec = Readonly<{
    symbol: string;
    plural?: string;
    position?: "postfix" | "prefix";
    spacing?: "spaced" | "compact";
}>;
export type DecimalSpec<N extends number = number> = {
    readonly oom: N;
    readonly scale?: never;
};
export type ScaleSpec<N extends Rationalish = Rationalish> = {
    readonly oom?: never;
    readonly scale: N;
};
export type Unit = SymbolSpec & {
    readonly scale: Rational;
    readonly oom?: number;
};
export type SystemInfo<N extends string = string, U extends string = string, D extends boolean = boolean> = {
    name: N;
    symbols: U;
    decimal: D;
};
export type StandardInfo<SY extends string = string, SU extends string = string> = {
    system: SY;
    unit: SU;
};
export type ValidStandardInfo<Y extends SystemInfo> = Y extends SystemInfo<infer N, infer U, boolean> ? StandardInfo<N, U> : never;
export type Kind<U extends string = string, N extends string = string, Y extends SystemInfo = SystemInfo, S extends ValidStandardInfo<Y> = ValidStandardInfo<Y>, H extends U | undefined = U | undefined, A extends U | undefined = U | undefined> = Readonly<{
    name: N;
    units: KindUnits<U>;
    standard: S;
    systems: KindSystems<Y>;
} & ([
    U | undefined
] extends [H] ? {
    human?: U;
} : [H] extends [U] ? {
    human: H;
} : unknown) & ([
    U | undefined
] extends [A] ? {
    atomic?: U;
} : [A] extends [U] ? {
    atomic: A;
} : unknown)>;
export type KindWithHuman<U extends string = string, N extends string = string, Y extends SystemInfo = SystemInfo, S extends ValidStandardInfo<Y> = ValidStandardInfo<Y>, H extends U = U, A extends U | undefined = U | undefined> = Kind<U, N, Y, S, H, A>;
export type KindWithAtomic<U extends string = string, N extends string = string, Y extends SystemInfo = SystemInfo, S extends ValidStandardInfo<Y> = ValidStandardInfo<Y>, H extends U | undefined = U | undefined, A extends U = U> = Kind<U, N, Y, S, H, A>;
export type KindWithHumanAndAtomic<U extends string = string, N extends string = string, Y extends SystemInfo = SystemInfo, S extends ValidStandardInfo<Y> = ValidStandardInfo<Y>, H extends U = U, A extends U = U> = Kind<U, N, Y, S, H, A>;
export type DecimalKind<U extends string = string, N extends string = string, Y extends SystemInfo = SystemInfo, S extends ValidStandardInfo<Y> = ValidStandardInfo<Y>, H extends U = U, A extends U = U> = Brand<Kind<U, N, Y, S, H, A>, "decimalHuman" | "decimalAtomic">;
export type SymbolsOf<K extends Kind> = Extract<keyof K["units"], string> | "standard" | (K["human"] extends string ? "human" : never) | (K["atomic"] extends string ? "atomic" : never);
export type DecimalSymbolsOf<K extends Kind> = DecimalUnitSymbols<K> | DecimalMetaSymbolOf<K>;
export type GetUnitSymbol<K extends Kind, M extends SymbolsOf<K>> = M extends "standard" ? K["standard"]["unit"] : M extends "human" ? K["human"] : M extends "atomic" ? K["atomic"] : M;
export declare function sameKind(a: Kind, b: Kind): boolean;
export declare function getUnit<const K extends Kind, S extends SymbolsOf<K>>(kind: K, unitSymbol: S): Unit;
export declare function getDecimals<const K extends Kind>(kind: K, ...args: K extends DecimalKind ? [opts?: GetDecimalsOpts<K>] : [opts: GetDecimalsOpts<K>]): number;
type MetaBrandTags<H, A, S, I extends KindUnitsInput> = [
    H,
    "human"
] | [A, "atomic"] | [S, "standard"] extends infer M ? M extends [DecimalSymbolsOfSystem<UnitSymbolsOf<UnitsSpecOf<I>>, SystemInfoOf<I>>, MetaSymbols] ? `decimal${Capitalize<M[1]>}` : "" : never;
export declare function kind<N extends string, const I extends KindUnitsInput, H extends string | undefined = undefined, A extends string | undefined = undefined>(name: N, unitsInput: I, opts?: Opts<{
    human: H & UnitSymbolsOf<UnitsSpecOf<I>>;
    atomic: A & UnitSymbolsOf<UnitsSpecOf<I>>;
}>): Brand<Kind<UnitSymbolsOf<UnitsSpecOf<I>>, N, SystemInfoOf<I>, StandardInfoOf<I>, H & UnitSymbolsOf<UnitsSpecOf<I>> extends never ? undefined : H & UnitSymbolsOf<UnitsSpecOf<I>>, A & UnitSymbolsOf<UnitsSpecOf<I>> extends never ? undefined : A & UnitSymbolsOf<UnitsSpecOf<I>>>, MetaBrandTags<H, A, StandardInfoOf<I>["unit"], I>>;
export declare const powerOfTen: (oom: number) => Rational;
export declare function identifyKind<K extends Kind, A extends boolean = false>(kinds: RoArray<K>, str: string, allowAmbiguous?: A): A extends true ? K[] : K | undefined;
type UnitBaseSpec = {
    readonly symbols: RoNeTuple<SymbolSpec>;
};
type UnitSpec<F extends boolean, D extends boolean> = UnitBaseSpec & (F extends true ? D extends true ? Partial<DecimalSpec<0>> : Partial<ScaleSpec<1 | 1n>> : D extends true ? DecimalSpec : ScaleSpec);
type KindUnitsSpec<F extends boolean, D extends boolean> = D extends any ? F extends true ? readonly [UnitSpec<true, D>, ...UnitSpec<false, D>[]] : RoNeTuple<UnitSpec<false, D>> : never;
type KindUnits<U extends string> = {
    readonly [K in U]?: Unit;
};
type KindSystems<Y extends SystemInfo> = {
    readonly [Sys in Y as Sys["name"]]: Readonly<{
        symbols: RoArray<Sys["symbols"]>;
        decimal: Sys["decimal"];
    }>;
};
type UnitSymbolsOf<U extends RoArray<UnitBaseSpec>> = U[number]["symbols"][number] extends infer S ? S extends SymbolSpec ? S["symbol"] | Extract<S["plural"], string> : never : never;
type SystemEntry<F extends boolean = boolean, N extends string = string, S extends KindUnitsSpec<F, boolean> = KindUnitsSpec<F, boolean>> = RoPair<N, S>;
type SystemsSpec = readonly [SystemEntry<true>, ...SystemEntry<false>[]];
type KindUnitsInput = KindUnitsSpec<true, boolean> | SystemsSpec;
type IsSystemDecimal<Spec extends KindUnitsSpec<boolean, boolean>> = Spec[0] extends DecimalSpec ? true : Spec[0] extends ScaleSpec ? false : Spec extends readonly [unknown] | readonly [unknown, DecimalSpec, ...unknown[]] ? true : false;
type SystemInfoOf<I extends KindUnitsInput> = I extends SystemsSpec ? {
    [K in keyof I & `${number}`]: I[K] extends SystemEntry<boolean, infer Name, infer Spec> ? SystemInfo<Name, UnitSymbolsOf<Spec>, IsSystemDecimal<Spec>> : never;
}[keyof I & `${number}`] : I extends KindUnitsSpec<true, boolean> ? SystemInfo<"default", UnitSymbolsOf<I>, IsSystemDecimal<I>> : never;
type UnitsSpecOf<I extends KindUnitsInput> = I extends SystemsSpec ? I[number][1] : I;
type StandardSystemOf<I extends KindUnitsInput> = I extends SystemsSpec ? I[0][0] : "default";
type StandardUnitOf<I extends KindUnitsInput> = I extends SystemsSpec ? I[0][1][0]["symbols"][0]["symbol"] : I extends KindUnitsSpec<boolean, boolean> ? I[0]["symbols"][0]["symbol"] : never;
type StandardInfoOf<I extends KindUnitsInput> = StandardInfo<StandardSystemOf<I>, StandardUnitOf<I>> extends infer S extends ValidStandardInfo<SystemInfoOf<I>> ? S : never;
type MetaSymbols = "standard" | "human" | "atomic";
type DecimalMetaSymbolOf<K extends Kind, M extends MetaSymbols = MetaSymbols> = M extends MetaSymbols ? K extends Brand<any, `decimal${Capitalize<M>}`> ? M : never : never;
type DecimalSymbolsOfSystem<U extends string, Y extends SystemInfo> = Y extends {
    symbols: infer Syms extends U;
    decimal: true;
} ? Syms : never;
type DecimalUnitSymbols<K extends Kind> = K extends Kind<infer U, string, infer Y extends SystemInfo> ? DecimalSymbolsOfSystem<U, Y> : never;
type GetDecimalsOptsImpl<K extends Kind, M extends "human" | "atomic"> = DecimalSymbolsOf<K> extends infer D ? ((M extends "human" ? "of" : "in") extends infer P extends string ? {
    [_ in P]: D;
} : never) extends infer R ? M extends D ? Opts<R> : R : never : never;
type GetDecimalsOpts<K extends Kind> = GetDecimalsOptsImpl<K, "human"> & GetDecimalsOptsImpl<K, "atomic">;
export {};
//# sourceMappingURL=kind.d.ts.map