@aesthetic/core/dts/types.d.ts

Aesthetic is a powerful type-safe, framework agnostic, CSS-in-JS library for styling components.

import { Utilities } from '@aesthetic/system';
import { ColorScheme, ContrastLevel, Direction, DirectionConverter, Engine, PropertyHandlerMap, RenderOptions, RenderResult, ThemeName, ThemeRule, Unit, UnitFactory, VendorPrefixer } from '@aesthetic/types';
import type { FeatureSheet } from './FeatureSheet';
import type { Sheet } from './Sheet';
export interface SheetRenderResultItem<Output> extends Partial<RenderResult<Output>> {
    variantTypes?: Set<string>;
}
export declare type InferKeys<T> = T extends string ? T : string;
export declare type InferKeysFromSheets<T> = T extends ComponentSheet<infer K, any, any>[] ? K : string;
export declare type SheetRenderResult<Output, Keys = string> = Record<InferKeys<Keys>, SheetRenderResultItem<Output>>;
export declare type WrapFalsy<T> = T | false | null | undefined;
export declare type WrapArray<T> = T extends (infer I)[] ? WrapFalsy<I>[] : WrapFalsy<T>[];
export declare type ResultComposerArgs<Keys, Output> = (WrapArray<Output> | WrapFalsy<Keys>)[];
export declare type ResultComposerVariants = Record<string, number | string | false | undefined>;
export interface ResultComposer<Keys, Output, GeneratedOutput = Output> {
    (variants: ResultComposerVariants, ...args: ResultComposerArgs<Keys, Output>): GeneratedOutput;
    (...args: ResultComposerArgs<Keys, Output>): GeneratedOutput;
    result: SheetRenderResult<Output, Keys>;
}
export declare type ResultGenerator<Keys, Output> = (args: ResultComposerArgs<Keys, Output>, variants: Set<string>, renderResult: SheetRenderResult<Output>) => Output[];
export interface SheetParams {
    contrast?: ContrastLevel;
    deterministic?: boolean;
    direction?: Direction;
    scheme?: ColorScheme;
    theme?: ThemeName;
    unit?: Unit;
    vendor?: boolean;
}
export declare type SheetFactory<Input extends object> = (utils: Utilities<Input>) => object;
export declare type SheetRenderer<Input extends object, Output, Block> = (engine: Engine<Input, Output>, styles: Block, options: RenderOptions) => SheetRenderResult<Output>;
export declare type ThemeRuleNeverize<T, B> = {
    [K in keyof T]: K extends keyof B ? T[K] : never;
};
export declare type ThemeSheetFactory<Shape, Input extends object> = (utils: Utilities<Input>) => Shape extends unknown ? ThemeRule<Input> : ThemeRule<Input> & ThemeRuleNeverize<Shape, Input>;
export declare type ThemeSheet<_Selectors, Input extends object, Output> = Sheet<Input, Output, ThemeSheetFactory<unknown, Input>>;
export declare type ElementRuleMap<Block extends object> = Record<string, Block>;
export declare type ElementRuleNeverize<T, B> = {
    [K in keyof T]: K extends keyof B ? T[K] : never;
};
export declare type ElementRuleMapNeverize<T, B> = {
    [K in keyof T]: ElementRuleNeverize<T[K], B>;
};
export declare type ElementSheetFactory<Input extends object> = (utils: Utilities<Input>) => Input;
export declare type ComponentSheetFactory<Shape, Input extends object> = (utils: Utilities<Input>) => Shape extends unknown ? ElementRuleMap<Input> : ElementRuleMap<Input> & ElementRuleMapNeverize<Shape, Input>;
export declare type ComponentSheet<_Selectors, Input extends object, Output> = FeatureSheet<Input, Output, ComponentSheetFactory<unknown, Input>>;
export interface AestheticOptions {
    customProperties?: PropertyHandlerMap;
    defaultUnit?: Unit | UnitFactory;
    deterministicClasses?: boolean;
    directionConverter?: DirectionConverter | null;
    rootVariables?: boolean;
    vendorPrefixer?: VendorPrefixer | null;
}
export declare type EventType = 'change:direction' | 'change:theme';
export declare type EventListener = (...args: unknown[]) => void;
export declare type OnChangeDirection = (newDir: Direction) => void;
export declare type OnChangeTheme = (newTheme: ThemeName, results: unknown[]) => void;
//# sourceMappingURL=types.d.ts.map