type TModularScalesOptions = {
    base: number;
    ratio: [number];
    units: number;
    convert?: boolean;
};
type TSequencesOptions = {
    base: number;
    units: number;
    steps: number;
    decimal: boolean;
};
interface ITemplateValues {
    name?: string;
    base?: string | number;
    ratio?: number;
    units?: number;
    steps?: number;
    decimal?: boolean;
    variations?: {
        alpha?: boolean;
        shade?: boolean;
        tint?: boolean;
    };
}
interface ITemplatePayload {
    type: string;
    values: ITemplateValues[];
    data?: any[];
}

interface IComposedLibraryItem {
    name?: string;
    base?: number | IColorVariation;
    alpha?: any[] | [];
    tint?: any[] | [];
    shade?: any[] | [];
    units?: number;
    ratio?: number;
    variant?: TScaleVariant;
    values?: ISequenceVariation[] | IScaleVariation[] | [];
}
interface IDesignTokensSet {
    color: IComposedLibraryItem[];
    measurement: IComposedLibraryItem[];
    fontsize: IComposedLibraryItem[];
    depth: IComposedLibraryItem[];
    opacity: IComposedLibraryItem[];
}
interface IDesignTokensLibrary {
    name: string;
    design_tokens: IDesignTokensSet;
}

type TMeasureVariant = "fontsize" | "measurement";
declare enum RatioEnum {
    MinorSecond = 1.0666666666666667,
    MajorSecond = 1.125,
    MinorThird = 1.2,
    MajorThird = 1.25,
    PerfectFourth = 1.3333333333333333,
    PerfectFifth = 1.5,
    GoldenRatio = 1.618
}
type TScaleVariant = "fontsize" | "measurement";
interface IScaleVariation {
    px: number;
    rem: number;
    pt: number;
}
interface IScaleProperties {
    units: number;
    ratio: number;
    variant?: TScaleVariant;
    values: IScaleVariation[] | [];
}

interface IStackOrder {
    label: string;
    score: number;
}
interface ISequenceVariation {
    value: number;
    usage: string[];
    contrast_score?: IContrastScore;
    stack_order?: IStackOrder;
}
interface ISequenceProperties {
    base: number;
    units: number;
    steps: number;
    name: string;
    values: ISequenceVariation[];
}

declare enum LuminanceFactorsEnum {
    Lum0 = 0,
    Lum10 = 0.1,
    Lum20 = 0.2,
    Lum30 = 0.3,
    Lum40 = 0.4,
    Lum50 = 0.5,
    Lum60 = 0.6,
    Lum70 = 0.7,
    Lum80 = 0.8,
    Lum90 = 0.9,
    Lum100 = 1
}
type THex = string;
type TTone = number;
type TMode = "darken" | "lighten";
type TLuminance = LuminanceFactorsEnum | undefined;
interface IContrastScore {
    light: string;
    dark: string;
}
interface IColorVariation {
    hex?: string;
    rgb?: string;
    hsl?: string;
    contrast_score?: IContrastScore;
}
interface IColorProperties {
    alpha?: IColorVariation[] | [];
    tint?: IColorVariation[] | [];
    shade?: IColorVariation[] | [];
}

declare function applyColorLuminance(hex: THex, luminance: TLuminance): string;
declare function setLuminanceTone(tone: TTone, mode?: TMode): number;
declare const luminanceAmountFormatter: (array: string | unknown[]) => number;
declare const getRelativeLuminance: (rgb: [number, number, number]) => number;
declare const generateAlpha: (Hex: string, amount?: number) => {
    hex: string;
    rgb: string;
    hsl: string;
}[];
declare const generateVariation: (Hex: string, mode: TMode, amount?: number) => IColorVariation[];

declare const MeasurementRatios: {
    name: string;
    value: RatioEnum;
}[];
declare const generateModularScales: (options: TModularScalesOptions) => IScaleVariation[] | number[];
declare const generateSequences: (options: TSequencesOptions) => number[];

declare const generateCSSVariables: (payload: IDesignTokensLibrary) => {
    color: string[] | string[][];
    alpha: string[] | string[][];
    tint: string[] | string[][];
    shade: string[] | string[][];
    fontsize: string[] | string[][];
    measurement: string[] | string[][];
    depth: string[] | string[][];
    opacity: string[] | string[][];
};

interface Size extends IScaleProperties {
    name: string;
}
interface Color extends IColorProperties {
    name: string;
}
declare const generateSizeClasses: (sizes: Size[]) => string;
declare const generateFontSizesClasses: (fs: Size[]) => string;
declare const generateOpacityClasses: (opacity: ISequenceProperties[]) => string;
declare const generateColorClasses: (color: Color[]) => string;
declare const generateLayoutClasses: () => string;
declare const generateDimensionClasses: () => string;

declare const generateColorTokens: (name: string, hex: string, variations: {
    alpha?: boolean;
    tint?: boolean;
    shade?: boolean;
}) => {
    name: string;
    base: {
        hex: string;
        rgb: string | [number, number, number];
        hsl: string | number[];
        contrast_score: {
            light: string;
            dark: string;
        };
    };
    alpha: {
        hex: string;
        rgb: string;
        hsl: string;
    }[];
    tint: IColorVariation[];
    shade: IColorVariation[];
};
declare const generateMeasurementTokens: (name: string, base: number, units: number, ratio: number, _variant?: TMeasureVariant) => {
    name: string;
    base: number;
    units: number;
    ratio: number;
    values: IScaleVariation[] | number[];
};
declare const generateSequenceVariation: ({ contrast, sequence, index, }: any) => {
    usage: string[];
    stack_order: {
        label: string;
        score: number;
    };
} | {
    usage: string[];
    contrast_score: {
        light: string;
        dark: string;
    };
};
declare const generateSequenceTokens: (name: string, base: number, units: number, steps: number, decimal: boolean) => {
    name: string;
    base: number;
    units: number;
    steps: number;
    values: ({
        usage: string[];
        stack_order: {
            label: string;
            score: number;
        };
        value: number;
    } | {
        usage: string[];
        contrast_score: {
            light: string;
            dark: string;
        };
        value: number;
    })[];
};
declare const generateTokensFromTemplate: (payload: any) => any;
declare const generateTokensLibrary: (name: string, template: ITemplatePayload[]) => IDesignTokensLibrary;

declare const getContrastRatio: (textRgb: [number, number, number], backgroundRgb: [number, number, number]) => number;
declare const calculateContrastScore: (textColor: string, backgroundColor: string) => string;
declare const calculateStackOrder: (index: number, sequence: number[]) => {
    label: string;
    score: number;
};
declare const getSequenceUsages: (contrastScore: any | null, stackOrder?: any) => string[];

declare const PXToREM: (value: number) => number;
declare const PXToPT: (value: number) => number;
declare const HEXToRGB: (Hex: THex, raw?: boolean) => [number, number, number] | string;
declare const RGBAToHEX: (rgba: string, backgroundHex: string) => string;
declare const RGBToHSL: (r: number, g: number, b: number) => number[];
declare const HEXToHSL: (hex: string, raw?: boolean) => number[] | string;

export { HEXToHSL, HEXToRGB, MeasurementRatios, PXToPT, PXToREM, RGBAToHEX, RGBToHSL, applyColorLuminance, calculateContrastScore, calculateStackOrder, generateAlpha, generateCSSVariables, generateColorClasses, generateColorTokens, generateDimensionClasses, generateFontSizesClasses, generateLayoutClasses, generateMeasurementTokens, generateModularScales, generateOpacityClasses, generateSequenceTokens, generateSequenceVariation, generateSequences, generateSizeClasses, generateTokensFromTemplate, generateTokensLibrary, generateVariation, getContrastRatio, getRelativeLuminance, getSequenceUsages, luminanceAmountFormatter, setLuminanceTone };