import type { WithAliasValue } from './Alias.js';
import type { TokenSignature } from './TokenSignature.js';
declare const colorTypeName = "color";
export declare const colorSpaceValues: readonly ["srgb", "srgb-linear", "hsl", "hwb", "lab", "lch", "oklab", "oklch", "display-p3", "a98-rgb", "prophoto-rgb", "rec2020", "xyz-d65", "xyz-d50"];
export declare namespace Color {
    type TypeName = typeof colorTypeName;
    type RawValue = {
        colorSpace: typeof colorSpaceValues[number];
        components: [number | 'none', number | 'none', number | 'none'];
        alpha?: number;
        hex?: `#${string}`;
    };
    type Value = WithAliasValue<Color.RawValue>;
    type Token = TokenSignature<Color.TypeName, Color.Value>;
}
declare const dimensionTypeName = "dimension";
export declare namespace Dimension {
    type TypeName = typeof dimensionTypeName;
    type RawValue = {
        value: number;
        unit: 'px' | 'rem';
    };
    type Value = WithAliasValue<Dimension.RawValue>;
    type Token = TokenSignature<Dimension.TypeName, Dimension.Value>;
}
declare const fontFamilyTypeName = "fontFamily";
export declare namespace FontFamily {
    type TypeName = typeof fontFamilyTypeName;
    type RawValue = string | Array<string>;
    type Value = WithAliasValue<FontFamily.RawValue>;
    type Token = TokenSignature<FontFamily.TypeName, FontFamily.Value>;
}
declare const fontWeightTypeName = "fontWeight";
export declare const fontWeightValues: readonly ["thin", "hairline", "extra-light", "ultra-light", "light", "normal", "regular", "book", "medium", "semi-bold", "demi-bold", "bold", "extra-bold", "ultra-bold", "black", "heavy", "extra-black", "ultra-black"];
export declare namespace FontWeight {
    type TypeName = typeof fontWeightTypeName;
    type RawValue = (typeof fontWeightValues)[number] | number;
    type Value = WithAliasValue<FontWeight.RawValue>;
    type Token = TokenSignature<FontWeight.TypeName, FontWeight.Value>;
}
declare const durationTypeName = "duration";
export declare namespace Duration {
    type TypeName = typeof durationTypeName;
    type RawValue = {
        value: number;
        unit: 'ms' | 's';
    };
    type Value = WithAliasValue<Duration.RawValue>;
    type Token = TokenSignature<Duration.TypeName, Duration.Value>;
}
declare const cubicBezierTypeName = "cubicBezier";
export declare namespace CubicBezier {
    type TypeName = typeof cubicBezierTypeName;
    type RawValue = [number, number, number, number];
    type Value = WithAliasValue<CubicBezier.RawValue>;
    type Token = TokenSignature<CubicBezier.TypeName, CubicBezier.Value>;
}
declare const numberTypeName = "number";
export declare namespace Number {
    type TypeName = typeof numberTypeName;
    type RawValue = number;
    type Value = WithAliasValue<Number.RawValue>;
    type Token = TokenSignature<Number.TypeName, Number.Value>;
}
declare const strokeStyleTypeName = "strokeStyle";
export declare const strokeStyleStringValues: readonly ["solid", "dashed", "dotted", "double", "groove", "ridge", "outset", "inset"];
export declare const strokeStyleLineCapValues: readonly ["round", "butt", "square"];
export declare namespace StrokeStyle {
    type TypeName = typeof strokeStyleTypeName;
    type RawValue = (typeof strokeStyleStringValues)[number] | {
        dashArray: Dimension.Value[];
        lineCap: (typeof strokeStyleLineCapValues)[number];
    };
    type Value = WithAliasValue<StrokeStyle.RawValue>;
    type Token = TokenSignature<StrokeStyle.TypeName, StrokeStyle.Value>;
}
declare const borderTypeName = "border";
export declare namespace Border {
    type TypeName = typeof borderTypeName;
    type RawValue = {
        color: Color.Value;
        width: Dimension.Value;
        style: StrokeStyle.Value;
    };
    type Value = WithAliasValue<Border.RawValue>;
    type Token = TokenSignature<Border.TypeName, Border.Value>;
}
declare const transitionTypeName = "transition";
export declare namespace Transition {
    type TypeName = typeof transitionTypeName;
    type RawValue = {
        duration: Duration.Value;
        delay: Duration.Value;
        timingFunction: CubicBezier.Value;
    };
    type Value = WithAliasValue<Transition.RawValue>;
    type Token = TokenSignature<Transition.TypeName, Transition.Value>;
}
declare const shadowTypeName = "shadow";
export declare namespace Shadow {
    type TypeName = typeof shadowTypeName;
    type RawValue = Array<{
        color: Color.Value;
        offsetX: Dimension.Value;
        offsetY: Dimension.Value;
        blur: Dimension.Value;
        spread: Dimension.Value;
        inset?: boolean;
    }> | {
        color: Color.Value;
        offsetX: Dimension.Value;
        offsetY: Dimension.Value;
        blur: Dimension.Value;
        spread: Dimension.Value;
        inset?: boolean;
    };
    type Value = WithAliasValue<Shadow.RawValue>;
    type Token = TokenSignature<Shadow.TypeName, Shadow.Value>;
}
declare const gradientTypeName = "gradient";
export declare namespace Gradient {
    type TypeName = typeof gradientTypeName;
    type RawValue = Array<{
        color: Color.Value;
        position: Number.Value;
    }>;
    type Value = WithAliasValue<Gradient.RawValue>;
    type Token = TokenSignature<Gradient.TypeName, Gradient.Value>;
}
declare const typographyTypeName = "typography";
export declare namespace Typography {
    type TypeName = typeof typographyTypeName;
    type RawValue = {
        fontFamily: FontFamily.Value;
        fontSize: Dimension.Value;
        fontWeight: FontWeight.Value;
        letterSpacing: Dimension.Value;
        lineHeight: Number.Value;
    };
    type Value = WithAliasValue<Typography.RawValue>;
    type Token = TokenSignature<Typography.TypeName, Typography.Value>;
}
export declare const tokenTypeNames: readonly ["color", "dimension", "fontFamily", "fontWeight", "duration", "cubicBezier", "number", "strokeStyle", "border", "transition", "shadow", "gradient", "typography"];
export declare const tokenTypeNamesMapping: {
    number: "number";
    color: "color";
    dimension: "dimension";
    fontFamily: "fontFamily";
    fontWeight: "fontWeight";
    duration: "duration";
    cubicBezier: "cubicBezier";
    strokeStyle: "strokeStyle";
    border: "border";
    transition: "transition";
    shadow: "shadow";
    gradient: "gradient";
    typography: "typography";
};
export type TokenTypeName = Color.TypeName | Dimension.TypeName | FontFamily.TypeName | FontWeight.TypeName | Duration.TypeName | CubicBezier.TypeName | Number.TypeName | StrokeStyle.TypeName | Border.TypeName | Transition.TypeName | Shadow.TypeName | Gradient.TypeName | Typography.TypeName;
export type DesignToken = Color.Token | Dimension.Token | FontFamily.Token | FontWeight.Token | Duration.Token | CubicBezier.Token | Number.Token | StrokeStyle.Token | Border.Token | Transition.Token | Shadow.Token | Gradient.Token | Typography.Token;
export type PickTokenByType<T extends TokenTypeName> = {
    color: Color.Token;
    dimension: Dimension.Token;
    fontFamily: FontFamily.Token;
    fontWeight: FontWeight.Token;
    duration: Duration.Token;
    cubicBezier: CubicBezier.Token;
    number: Number.Token;
    strokeStyle: StrokeStyle.Token;
    border: Border.Token;
    transition: Transition.Token;
    shadow: Shadow.Token;
    gradient: Gradient.Token;
    typography: Typography.Token;
}[T];
export {};