twind/twind.d.ts

compiles tailwind like shorthand syntax into css at runtime

import { PropertiesFallback, PropertiesHyphenFallback, AtRule, SimplePseudos } from 'csstype';

interface CSSCustomProperties {
    '--tw-bg-opacity'?: string;
    '--tw-text-opacity'?: string;
    '--tw-border-opacity'?: string;
    '--tw-divide-opacity'?: string;
    '--tw-placeholder-opacity'?: string;
    '--tw-shadow'?: string;
    '--tw-ring-inset'?: string;
    '--tw-ring-color'?: string;
    '--tw-ring-opacity'?: string;
    '--tw-ring-shadow'?: string;
    '--tw-ring-offset-color'?: string;
    '--tw-ring-offset-shadow'?: string;
    '--tw-ring-offset-width'?: string;
    '--tw-gradient-from'?: string;
    '--tw-gradient-to'?: string;
    '--tw-gradient-stops'?: string;
    '--tw-divide-y-reverse'?: string;
    '--tw-divide-x-reverse'?: string;
    '--tw-space-y-reverse'?: string;
    '--tw-space-x-reverse'?: string;
    '--tw-translate-x'?: string;
    '--tw-translate-y'?: string;
    '--tw-rotate'?: string;
    '--tw-skew-x'?: string;
    '--tw-skew-y'?: string;
    '--tw-scale-x'?: string;
    '--tw-scale-y'?: string;
    '--tw-ordinal'?: string;
    '--tw-slashed-zero'?: string;
    '--tw-numeric-figure'?: string;
    '--tw-numeric-spacing'?: string;
    '--tw-numeric-fraction'?: string;
}
interface CSSProperties extends PropertiesFallback<string, string>, PropertiesHyphenFallback<string, string>, CSSCustomProperties {
}
interface FontFace extends AtRule.FontFaceFallback<string, string>, AtRule.FontFaceHyphenFallback<string, string> {
}
interface CounterStyle extends AtRule.CounterStyleFallback<string, string>, AtRule.CounterStyleHyphenFallback<string, string> {
}

declare type Falsy = '' | 0 | -0 | false | null | undefined | void;
declare type MaybeArray<T> = T | readonly T[];

declare type MaybeObjInterpolationGeneric<T> = T[] | [TemplateStringsArray, ...T[]];
declare type MaybeTokenInterpolation = MaybeObjInterpolationGeneric<Token>;
interface TWCallable {
    (strings: TemplateStringsArray, ...interpolations: Token[]): string;
    (...tokens: Token[]): string;
}
interface TW extends TWCallable {
    theme: ThemeResolver;
}
interface Context {
    /** Allow composition */
    readonly tw: TWCallable;
    /** Access to theme values */
    readonly theme: ThemeResolver;
    /** Create unique identifier (group, custom properties) */
    readonly tag: (key: string) => string;
    readonly css: (rule: Rule[] | string) => CSSRules;
}
interface Instance {
    readonly tw: TW;
    readonly setup: (options?: Configuration) => void;
}
declare type MaybeThunk<T> = T | ((context: Context) => T);
interface Preflight {
    (preflight: CSSRules, context: Context): MaybeThunk<CSSRules | undefined | void>;
}
interface ThemeConfiguration extends Partial<Theme> {
    extend?: Partial<Theme>;
}
interface SheetConfig<T = unknown> {
    /**
     * Sets a cryptographic nonce (number used once) on the enclosing `<style>` tag when generating a page on demand.
     *
     * Useful for enforcing a [Content Security Policy (CSP)](https://developer.mozilla.org/docs/Web/HTTP/CSP).
     */
    nonce?: string;
    /** Target to insert rules into. */
    target?: T;
}
interface Sheet<T = unknown> {
    readonly target: T;
    insert: (rule: string, index: number) => void;
    init?: SheetInit;
}
declare type SheetInitCallback<T = unknown> = (value?: T | undefined) => T;
interface SheetInit {
    /**
     * Register a function that should be called to use a snapshot state or create a new state.
     */
    <T>(callback: SheetInitCallback<T>): T;
}
declare type Prefixer = (property: string, value: string, important?: boolean) => string;
declare type Hasher = (value: string) => string;
declare type DarkMode = 'media' | 'class' | false;
interface Configuration {
    /**
     * Determines the dark mode strategy (default: `"media"`).
     */
    darkMode?: DarkMode;
    theme?: ThemeConfiguration;
    plugins?: Record<string, Plugin | undefined>;
    /**
     * ```js
     * {
     *   ':new-variant': '& .selector',
     * }
     * ```
     */
    variants?: Record<string, string>;
    /**
     * Sets a cryptographic nonce (number used once) on the enclosing `<style>` tag when generating a page on demand.
     *
     * Useful for enforcing a [Content Security Policy (CSP)](https://developer.mozilla.org/docs/Web/HTTP/CSP).
     */
    nonce?: string;
    /** Style insertion methodology to be used. */
    sheet?: Sheet;
    /** Called right before the first rule is injected. */
    preflight?: Preflight | boolean | CSSRules;
    /** Auto-prefixer method for CSS property–value pairs. */
    prefix?: Prefixer | boolean;
    hash?: Hasher | boolean;
    mode?: Mode | 'strict' | 'warn' | 'silent';
    /**
     * Control whether or not utilities should be marked with `!important`
     */
    important?: boolean;
}
declare type ReportInfo = {
    id: 'LATE_SETUP_CALL';
} | {
    id: 'UNKNOWN_DIRECTIVE';
    rule: string;
} | {
    id: 'UNKNOWN_THEME_VALUE';
    key: string | undefined;
} | {
    id: 'INJECT_CSS_ERROR';
    error: Error;
    css: string;
};
interface Mode {
    /** Called for unknown theme values */
    unknown: <Section extends keyof Theme>(section: Section, key: string[] | undefined, optional: boolean, context: Context) => ThemeSectionType<Theme[Section]> | undefined | void;
    /**
     * Notify error (missing plugin, duplicate directives? )
     *
     * Why id?
     * - can generate an url with more info
     * - reduce bundle size by omitting large error messages
     */
    report(info: ReportInfo, context: Context): void;
}
declare type Plugin = string | CSSRules | DirectiveHandler;
interface DirectiveHandler {
    /**
     * Creates CSSRules based on `parameters`
     */
    (parameters: string[], context: Context, id: string): InlineDirective | CSSRules | string | Falsy;
}
interface Rule {
    /**
     * The variants: `[":sm", ":dark", ":hover"]`
     */
    v: string[];
    /**
     * The directive: `"text-sm"`, `"rotate-45"`
     */
    d: string | InlineDirective;
    /** Is this rule negated: `"-rotate-45"` =\> `true` */
    n: boolean | undefined;
    /** Is this rule marked as important: `"!stroke-4"` =\> `true` */
    i: boolean | undefined;
    /**
     * The id is the tailwind rule including variants, negate and directive
     *
     * Initialy this is set to an empty string.
     *
     * This is used to cache the id of static rules (from template literals).
     */
    $: string;
}
interface Directive<T> {
    /** Can be used as a inline directive */
    (context: Context): T;
    /** Can be used as a plugin */
    (params: string[], context: Context): T;
}
interface InlineDirective {
    (context: Context): CSSRules | string | Falsy | TypescriptCompat;
}
interface TokenGrouping extends Record<string, Token> {
}
declare type TypescriptCompat = boolean | number;
declare type Token = Token[] | TokenGrouping | InlineDirective | string | Falsy | TypescriptCompat;
/**
 * Pseudo class
 * watch out for ':root' - that could use '*' instead
 */
declare type CSSSimplePseudos = {
    [K in SimplePseudos as `&${string & K}`]?: CSSRulesThunk | MaybeArray<CSSRules>;
};
interface CSSPseudos extends CSSSimplePseudos {
    '&:nth-child(2n)'?: CSSRules;
    '&:nth-child(odd)'?: CSSRules;
}
declare type CSSAtMedia = Record<string, MaybeArray<CSSRules>>;
declare type CSSAtSupports = Record<string, MaybeArray<CSSRules>>;
declare type CSSAtKeyframes = Record<string, CSSProperties | ((context: Context) => CSSProperties)>;
/**
 * See: https://drafts.csswg.org/css-nesting/#nest-selector
 *
 * ```
 * "& > * + *": {
 *   marginLeft: 16
 * },
 *
 * // In a comma-separated list, each individual selector shall start with "&"
 * "&:focus, &:active": {
 *   outline: "solid"
 * },
 *
 * // Self-references are also supported
 * "& + &": {
 *   color: "green"
 * }
 * ```
 */
interface CSSRules {
    '@import'?: CSSRulesThunk<MaybeArray<string>> | MaybeArray<string>;
    '@font-face'?: CSSRulesThunk<MaybeArray<FontFace>> | MaybeArray<FontFace>;
    '@keyframes'?: CSSRulesThunk<CSSAtKeyframes> | CSSAtKeyframes;
    '@apply'?: MaybeArray<string | Falsy | TypescriptCompat>;
    '@global'?: CSSRulesThunk<MaybeArray<CSSRules>> | MaybeArray<CSSRules>;
    ':global'?: CSSRulesThunk<MaybeArray<CSSRules>> | MaybeArray<CSSRules>;
    /** Global defaults */
    [key: string]: CSSRuleValue;
}
declare type CSSRuleValue = CSSAtMedia | CSSAtSupports | CSSAtKeyframes | CSSRulesThunk | MaybeArray<CSSProperties | CSSRules | FontFace | string | Falsy | TypescriptCompat>;
interface CSSRulesThunk<Value = CSSRuleValue> {
    (context: Context): Value;
}

interface ThemeResolver {
    <Section extends keyof Theme>(section: Section): Record<string, ThemeSectionType<Theme[Section]>>;
    <Section extends keyof Theme>(keypath: `${Section}.${string}`): ThemeSectionType<Theme[Section]> | undefined;
    <Section extends keyof Theme>(keypath: `${Section}.${string}`, defaultValue: NonNullable<ThemeSectionType<Theme[Section]>>): NonNullable<ThemeSectionType<Theme[Section]>>;
    <Section extends keyof Theme>(section: Section, key: string | string[]): ThemeSectionType<Theme[Section]> | undefined;
    <Section extends keyof Theme>(section: Section, key: string | string[], defaultValue: NonNullable<ThemeSectionType<Theme[Section]>>): NonNullable<ThemeSectionType<Theme[Section]>>;
}
interface ThemeHelper {
    <Section extends keyof Theme>(section: Section): (context: Context) => Record<string, ThemeSectionType<Theme[Section]>>;
    <Section extends keyof Theme>(keypath: `${Section}.${string}`): (context: Context) => ThemeSectionType<Theme[Section]> | undefined;
    <Section extends keyof Theme>(keypath: `${Section}.${string}`, defaultValue: NonNullable<ThemeSectionType<Theme[Section]>>): (context: Context) => NonNullable<ThemeSectionType<Theme[Section]>>;
    <Section extends keyof Theme>(section: Section, key: string | string[]): (context: Context) => ThemeSectionType<Theme[Section]> | undefined;
    <Section extends keyof Theme>(section: Section, key: string | string[], defaultValue: NonNullable<ThemeSectionType<Theme[Section]>>): (context: Context) => NonNullable<ThemeSectionType<Theme[Section]>>;
}
declare type Unwrap<T> = T extends string[] ? string : T extends Record<string, infer R> ? R : T;
declare type ThemeSectionType<T> = T extends ThemeSection<infer R> ? Unwrap<R> : Exclude<T, ThemeSectionResolver<T>>;
interface ThemeSectionResolverContext {
    /**
     * No-op function as negated values are automatically infered and do _not_ not to be in the theme.
     */
    readonly negative: (records: Record<string, string | undefined>) => Record<string, string | undefined>;
    readonly breakpoints: (records: Record<string, ThemeScreen | undefined>) => Record<string, string | undefined>;
}
declare type ThemeSectionRecord<T = string> = Record<string, T | undefined>;
declare type ThemeSectionResolver<T = string> = (theme: ThemeResolver, context: ThemeSectionResolverContext) => ThemeSectionRecord<T>;
declare type ThemeSection<T = string> = ThemeSectionRecord<T> | ThemeSectionResolver<T>;
interface ThemeContainer {
    screens?: Record<string, string | undefined>;
    center?: boolean;
    padding?: string | Record<string, string | undefined>;
}
declare type ThemeScreenValue = string | {
    raw: string;
} | {
    min: string;
    max?: string;
} | {
    min?: string;
    max: string;
};
declare type ThemeScreen = MaybeArray<ThemeScreenValue>;
interface ThemeColorObject extends Record<string, ThemeColor> {
}
declare type ThemeColor = string | ThemeColorObject;
declare type ThemeFontSize = string | [size: string, lineHeight: string] | [size: string, options: {
    lineHeight?: string;
    letterSpacing?: string;
}];
declare type ThemeOutline = [outline: string, offset: string] | string[];
interface Theme {
    colors: ThemeSection<ThemeColor>;
    spacing: ThemeSection;
    durations: ThemeSection<string | string[]>;
    screens: ThemeSection<ThemeScreen>;
    animation: ThemeSection<string | string[]>;
    backdropBlur: ThemeSection;
    backdropBrightness: ThemeSection;
    backdropContrast: ThemeSection;
    backdropGrayscale: ThemeSection;
    backdropHueRotate: ThemeSection;
    backdropInvert: ThemeSection;
    backdropOpacity: ThemeSection;
    backdropSaturate: ThemeSection;
    backdropSepia: ThemeSection;
    backgroundColor: ThemeSection<ThemeColor>;
    backgroundImage: ThemeSection<string | string[]>;
    backgroundOpacity: ThemeSection;
    backgroundPosition: ThemeSection;
    backgroundSize: ThemeSection;
    blur: ThemeSection;
    borderColor: ThemeSection<ThemeColor>;
    borderOpacity: ThemeSection;
    borderRadius: ThemeSection;
    borderWidth: ThemeSection;
    boxShadow: ThemeSection<string | string[]>;
    brightness: ThemeSection;
    container: ThemeContainer | ThemeSectionResolver<ThemeContainer>;
    contrast: ThemeSection;
    cursor: ThemeSection;
    divideColor: ThemeSection<ThemeColor>;
    divideOpacity: ThemeSection;
    divideWidth: ThemeSection;
    dropShadow: ThemeSection<string | string[]>;
    fill: ThemeSection<ThemeColor>;
    flex: ThemeSection;
    flexGrow: ThemeSection<number>;
    flexShrink: ThemeSection<number>;
    fontFamily: ThemeSection<string | string[]>;
    fontSize: ThemeSection<ThemeFontSize>;
    fontWeight: ThemeSection;
    gap: ThemeSection;
    gradientColorStops: ThemeSection<ThemeColor>;
    grayscale: ThemeSection;
    gridAutoColumns: ThemeSection;
    gridAutoRows: ThemeSection;
    gridColumn: ThemeSection;
    gridColumnEnd: ThemeSection;
    gridColumnStart: ThemeSection;
    gridRow: ThemeSection;
    gridRowEnd: ThemeSection;
    gridRowStart: ThemeSection;
    gridTemplateColumns: ThemeSection;
    gridTemplateRows: ThemeSection;
    height: ThemeSection;
    hueRotate: ThemeSection;
    inset: ThemeSection;
    invert: ThemeSection;
    keyframes: ThemeSection<Record<string, CSSProperties>>;
    letterSpacing: ThemeSection;
    lineHeight: ThemeSection;
    listStyleType: ThemeSection;
    margin: ThemeSection;
    maxHeight: ThemeSection;
    maxWidth: ThemeSection;
    minHeight: ThemeSection;
    minWidth: ThemeSection;
    objectPosition: ThemeSection;
    opacity: ThemeSection;
    order: ThemeSection;
    outline: ThemeSection<ThemeOutline>;
    padding: ThemeSection;
    placeholderColor: ThemeSection<ThemeColor>;
    placeholderOpacity: ThemeSection;
    ringColor: ThemeSection<ThemeColor>;
    ringOffsetColor: ThemeSection<ThemeColor>;
    ringOffsetWidth: ThemeSection;
    ringOpacity: ThemeSection;
    ringWidth: ThemeSection;
    rotate: ThemeSection;
    saturate: ThemeSection;
    scale: ThemeSection;
    sepia: ThemeSection;
    skew: ThemeSection;
    space: ThemeSection;
    stroke: ThemeSection<ThemeColor>;
    strokeWidth: ThemeSection;
    textColor: ThemeSection<ThemeColor>;
    textOpacity: ThemeSection;
    transformOrigin: ThemeSection;
    transitionDelay: ThemeSection<string | string[]>;
    transitionDuration: ThemeSection<string | string[]>;
    transitionProperty: ThemeSection<string | string[]>;
    transitionTimingFunction: ThemeSection<string | string[]>;
    translate: ThemeSection;
    width: ThemeSection;
    zIndex: ThemeSection;
}

declare type InterpolateKind = `theme(${keyof Theme})` | `range(${number},${number},${number})` | `string` | `number` | `nonzero`;
declare type Interpolate<Kind extends InterpolateKind> = `{{${Kind}}}`;
declare type FromTheme<Section extends keyof Theme> = Interpolate<`theme(${Section})`>;
declare type NonEmptyString = Interpolate<'string'>;
declare type Range<From extends number, To extends number, Step extends number = 1> = Interpolate<`range(${From},${To},${Step})`>;
declare type Negatable<Value extends string> = Value | `-${Value}`;
declare type SimplePseudoClasses = 'active' | 'any-link' | 'autofill' | 'checked' | 'default' | 'disabled' | 'empty' | 'enabled' | 'first-child' | 'first-of-type' | 'focus' | 'focus-visible' | 'focus-within' | 'future' | 'hover' | 'in-range' | 'indeterminate' | 'invalid' | 'last-child' | 'last-of-type' | 'link' | 'local-link' | 'only-child' | 'only-of-type' | 'optional' | 'out-of-range' | 'past' | 'paused' | 'placeholder-shown' | 'playing' | 'read-only' | 'read-write' | 'required' | 'target' | 'target-within' | 'user-invalid' | 'valid' | 'visited';
declare type SimplePseudoElements = 'after' | 'before' | 'cue' | 'cue-region' | 'file-selector-button' | 'first-letter' | 'first-line' | 'marker' | 'placeholder' | 'selection' | 'target-text';
declare type CoreVariants = 'dark' | 'sticky' | 'motion-reduce' | 'motion-safe' | 'first' | 'last' | 'even' | 'odd' | 'children' | 'siblings' | 'sibling' | 'override';
declare type Empty = never | '' | 'DEFAULT';
declare type Join<Prefix extends string | never, Suffix extends string | never, Separator extends string = '-'> = Suffix extends Empty ? Prefix extends Empty ? never : Prefix : Prefix extends Empty ? Suffix : Prefix extends Suffix ? never : Suffix extends `-${infer S}` ? `-${Prefix}${Separator}${S}` : `${Prefix}${Separator}${Suffix}`;
declare type Corners = 't' | 'r' | 'b' | 'l' | 'tl' | 'tr' | 'bl' | 'br';
declare type Edges = 'x' | 'y' | 't' | 'r' | 'b' | 'l' | 'tl' | 'tr' | 'tb' | 'bl' | 'br' | 'lr';
declare type BorderStyle = 'solid' | 'dashed' | 'dotted' | 'double' | 'none';
declare type GlobalValue = 'inherit' | 'initial' | 'unset';
declare type BlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
interface CorePlugins {
    group: '' | NonEmptyString;
    container: '';
    decoration: 'slice' | 'clone' | GlobalValue;
    box: 'border' | 'content';
    block: '';
    inline: '' | 'block' | 'flex' | 'grid' | 'table';
    flow: 'root';
    contents: '';
    hidden: '';
    float: 'right' | 'left' | 'none';
    clear: 'right' | 'left' | 'both' | 'none';
    isolate: '';
    isolation: 'auto' | 'isolate' | GlobalValue;
    object: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down' | Join<'' | 'left' | 'right' | 'center', '' | 'bottom' | 'top' | 'center'> | FromTheme<'objectPosition'>;
    overflow: Join<'' | 'x' | 'y', 'auto' | 'hidden' | 'visible' | 'scroll'> | 'ellipsis' | 'clip';
    overscroll: Join<'' | 'x' | 'y', 'auto' | 'contain' | 'none'>;
    static: '';
    fixed: '';
    absolute: '';
    relative: '';
    sticky: '';
    inset: Negatable<Join<'' | 'x' | 'y', FromTheme<'inset'>>>;
    top: Negatable<FromTheme<'inset'>>;
    right: Negatable<FromTheme<'inset'>>;
    bottom: Negatable<FromTheme<'inset'>>;
    left: Negatable<FromTheme<'inset'>>;
    visible: '';
    invisible: '';
    z: Negatable<FromTheme<'zIndex'>>;
    flex: '' | 'nowrap' | Join<'row' | 'col' | 'wrap', '' | 'reverse'> | Join<'grow', '' | '0' | FromTheme<'flexGrow'> | Interpolate<'number'>> | Join<'shrink', '' | '0' | FromTheme<'flexShrink'> | Interpolate<'number'>> | FromTheme<'flex'>;
    order: FromTheme<'order'>;
    grid: '' | Join<'cols', 'none' | Range<1, 12> | Interpolate<'nonzero'> | FromTheme<'gridTemplateColumns'>> | Join<'rows', 'none' | Range<1, 6> | Interpolate<'nonzero'> | FromTheme<'gridTemplateRows'>> | Join<'flow', Join<'row' | 'col', '' | 'dense'> | 'dense'>;
    col: Join<'span', Range<1, 12> | Interpolate<'nonzero'>> | Join<'start', 'auto' | Range<1, 13> | Interpolate<'nonzero'> | FromTheme<'gridColumnStart'>> | Join<'end', 'auto' | Range<1, 13> | Interpolate<'nonzero'> | FromTheme<'gridColumnEnd'>> | FromTheme<'gridColumn'>;
    row: Join<'span', Range<1, 12> | Interpolate<'nonzero'>> | Join<'start', 'auto' | Range<1, 13> | Interpolate<'nonzero'> | FromTheme<'gridRowStart'>> | Join<'end', 'auto' | Range<1, 13> | Interpolate<'nonzero'> | FromTheme<'gridRowEnd'>> | FromTheme<'gridRow'>;
    auto: Join<'cols', 'auto' | FromTheme<'gridAutoColumns'>> | Join<'rows', 'auto' | FromTheme<'gridAutoRows'>>;
    gap: Join<'' | 'x' | 'y', FromTheme<'gap'>>;
    justify: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly' | Join<'items' | 'self', 'auto' | 'start' | 'end' | 'center' | 'stretch'>;
    content: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
    items: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
    self: 'auto' | 'start' | 'end' | 'center' | 'stretch';
    place: Join<'content', 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly' | 'stretch'> | Join<'items' | 'self', 'auto' | 'start' | 'end' | 'center' | 'stretch'>;
    p: FromTheme<'padding'>;
    py: FromTheme<'padding'>;
    px: FromTheme<'padding'>;
    pt: FromTheme<'padding'>;
    pr: FromTheme<'padding'>;
    pb: FromTheme<'padding'>;
    pl: FromTheme<'padding'>;
    m: Negatable<FromTheme<'margin'>>;
    my: Negatable<FromTheme<'margin'>>;
    mx: Negatable<FromTheme<'margin'>>;
    mt: Negatable<FromTheme<'margin'>>;
    mr: Negatable<FromTheme<'margin'>>;
    mb: Negatable<FromTheme<'margin'>>;
    ml: Negatable<FromTheme<'margin'>>;
    space: Negatable<Join<'x' | 'y', FromTheme<'space'>>> | Join<'x' | 'y', 'reverse'>;
    w: FromTheme<'width'>;
    min: Join<'w', FromTheme<'minWidth'>> | Join<'h', FromTheme<'minHeight'>>;
    max: Join<'w', FromTheme<'maxWidth'>> | Join<'h', FromTheme<'maxHeight'>>;
    h: FromTheme<'height'>;
    font: FromTheme<'fontFamily'> | FromTheme<'fontWeight'> | 'italic' | 'not-italic';
    text: FromTheme<'fontSize'> | 'left' | 'right' | 'center' | 'justify' | FromTheme<'textColor'> | Join<'opacity', FromTheme<'textOpacity'>> | 'underline' | 'no-underline' | 'line-through' | 'uppercase' | 'lowercase' | 'capitalize' | 'normal-case';
    antialiased: '';
    'subpixel-antialiased': '';
    italic: '';
    'not-italic': '';
    'normal-nums': '';
    ordinal: '';
    'slashed-zero': '';
    'lining-nums': '';
    'oldstyle-nums': '';
    'proportional-nums': '';
    'tabular-nums': '';
    'diagonal-fractions': '';
    'stacked-fractions': '';
    tracking: FromTheme<'letterSpacing'>;
    leading: FromTheme<'lineHeight'>;
    list: 'item' | 'inside' | 'outside' | 'none' | 'disc' | 'circle' | 'sqaure' | 'decimal' | 'decimal-leading-zero' | Join<'lower' | 'upper', 'roman' | 'greek' | 'alpha' | 'latin'> | FromTheme<'listStyleType'>;
    placeholder: FromTheme<'placeholderColor'> | Join<'opacity', FromTheme<'placeholderOpacity'>>;
    underline: '';
    'no-underline': '';
    'line-through': '';
    uppercase: '';
    lowercase: '';
    capitalize: '';
    'normal-case': '';
    truncate: '';
    align: 'baseline' | 'top' | 'middle' | 'bottom' | 'text-top' | 'text-bottom' | 'sub' | 'super';
    whitespace: 'normal' | 'nowrap' | 'pre' | 'pre-wrap' | 'pre-line' | 'break-spaces';
    break: 'normal' | 'words' | 'all';
    bg: 'fixed' | 'local' | 'scroll' | Join<'clip', 'border' | 'padding' | 'content' | 'text'> | FromTheme<'backgroundColor'> | Join<'opacity', FromTheme<'backgroundOpacity'>> | Join<'' | 'left' | 'right' | 'center', '' | 'bottom' | 'top' | 'center'> | FromTheme<'backgroundPosition'> | 'no-repeat' | Join<'repeat', '' | 'x' | 'y' | 'round' | 'space'> | Join<'gradient-to', Corners> | FromTheme<'backgroundImage'> | FromTheme<'backgroundSize'>;
    from: FromTheme<'gradientColorStops'>;
    via: FromTheme<'gradientColorStops'>;
    to: FromTheme<'gradientColorStops'>;
    rounded: Join<'' | Corners, FromTheme<'borderRadius'>>;
    border: Join<'' | Edges, FromTheme<'borderWidth'>> | FromTheme<'borderColor'> | Join<'opacity', FromTheme<'borderOpacity'>> | BorderStyle | 'collapse' | 'separate';
    divide: Join<'x' | 'y', 'reverse' | FromTheme<'divideWidth'>> | FromTheme<'divideColor'> | Join<'opacity', FromTheme<'divideOpacity'>> | BorderStyle;
    ring: 'inset' | FromTheme<'ringWidth'> | FromTheme<'ringColor'> | Join<'opacity', FromTheme<'ringOpacity'>> | Join<'offset', FromTheme<'ringOffsetWidth'> | FromTheme<'ringOffsetColor'>>;
    shadow: FromTheme<'boxShadow'>;
    opacity: FromTheme<'opacity'>;
    table: '' | 'caption' | 'cell' | 'column' | Join<'column' | 'footer' | 'header' | 'row', 'group'> | 'row' | 'auto' | 'fixed';
    transition: FromTheme<'transitionProperty'>;
    duration: FromTheme<'durations'>;
    ease: FromTheme<'transitionTimingFunction'>;
    delay: FromTheme<'transitionDelay'>;
    animate: FromTheme<'animation'>;
    transform: '' | 'gpu' | 'none';
    origin: 'center' | Join<'' | 'top' | 'bottom', '' | 'right' | 'left'>;
    rotate: Negatable<FromTheme<'rotate'>>;
    scale: Join<'' | 'x' | 'y', FromTheme<'scale'>>;
    skew: Negatable<Join<'' | 'x' | 'y', FromTheme<'skew'>>>;
    translate: Negatable<Join<'' | 'x' | 'y', FromTheme<'translate'>>>;
    appearance: 'none' | 'auto' | 'menulist-button' | 'textfield';
    cursor: FromTheme<'cursor'> | 'auto' | 'default' | 'pointer' | 'wait' | 'text' | 'move' | 'help' | 'not-allowed' | 'none' | 'context-menu' | 'progress' | 'cell' | 'crosshair' | 'vertical-text' | 'alias' | 'copy' | 'no-drop' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';
    outline: FromTheme<'outline'>;
    'pointer-events': 'auto' | 'none';
    resize: 'none' | 'x' | 'y' | '';
    select: 'none' | 'auto' | 'text' | 'contain' | 'all';
    fill: FromTheme<'fill'>;
    stroke: FromTheme<'stroke'> | FromTheme<'strokeWidth'>;
    'sr-only': '';
    'not-sr-only': '';
    filter: '' | 'none';
    blur: FromTheme<'blur'>;
    brightness: FromTheme<'brightness'>;
    contrast: FromTheme<'contrast'>;
    grayscale: FromTheme<'grayscale'>;
    'hue-rotate': Negatable<FromTheme<'hueRotate'>>;
    invert: FromTheme<'invert'>;
    saturate: FromTheme<'saturate'>;
    sepia: FromTheme<'sepia'>;
    'drop-shadow': FromTheme<'dropShadow'>;
    backdrop: Join<'filter', '' | 'none'> | Join<'blur', FromTheme<'backdropBlur'>> | Join<'brightness', FromTheme<'backdropBrightness'>> | Join<'contrast', FromTheme<'backdropContrast'>> | Join<'grayscale', FromTheme<'backdropGrayscale'>> | Join<'hue-rotate', Negatable<FromTheme<'backdropHueRotate'>>> | Join<'invert', FromTheme<'backdropInvert'>> | Join<'opacity', FromTheme<'backdropOpacity'>> | Join<'saturate', FromTheme<'backdropSaturate'>> | Join<'sepia', FromTheme<'backdropSepia'>>;
    'mix-blend': BlendMode;
    'bg-blend': BlendMode;
}
declare type ToString<T> = T extends string ? T : T extends number ? `${T}` : never;
declare type JoinFromObject<T, Separator extends string = '-'> = {
    [P in keyof T]: Join<ToString<P>, ToString<T[P]>, Separator>;
}[keyof T];
/** For adding additional variants */
interface Variants {
}
/** For adding additional plugins */
interface Plugins {
}
declare type CoreCompletionTokens = `${FromTheme<'screens'>}:` | `${'' | 'not-'}${SimplePseudoClasses}:` | `${Join<'group', '' | Interpolate<'string'>>}-${SimplePseudoClasses}:` | `${SimplePseudoElements}::` | `${CoreVariants}:` | JoinFromObject<CorePlugins>;
declare type UserCompletionTokens = {
    [K in keyof Variants]: `${ToString<K>}:`;
}[keyof Variants] | JoinFromObject<Plugins>;
declare type CompletionTokens = CoreCompletionTokens | UserCompletionTokens;

interface Apply {
    (strings: TemplateStringsArray, ...interpolations: Token[]): Directive<CSSRules>;
    (...tokens: Token[]): Directive<CSSRules>;
}
declare const apply: Apply;

declare const tw: TW;
declare const setup: (options?: Configuration | undefined) => void;

/**
 * Returns an optimized and cached function for use with `tw`.
 *
 * `tw` caches rules based on the function identity. This helper caches
 * the function based on the data.
 *
 * @param factory to use when the directive is invoked
 * @param data to use
 */
declare const directive: <Data, T>(factory: (data: Data, context: Context) => MaybeThunk<T>, data: Data) => Directive<T>;

declare const expandGroups: (classNames: string) => string;

declare const create: (config?: Configuration | undefined) => Instance;

declare const mode: (report: (message: string) => void) => Mode;
declare const warn: Mode;
declare const strict: Mode;
declare const silent: Mode;

declare const noprefix: Prefixer;
declare const autoprefix: Prefixer;

/**
 * Creates an sheet which inserts style rules through the CSS Object Model.
 */
declare const cssomSheet: ({ nonce, target, }?: SheetConfig<CSSStyleSheet>) => Sheet<CSSStyleSheet>;
/**
 * An sheet placeholder which performs no operations. Useful for avoiding errors in a non-browser environment.
 */
declare const voidSheet: () => Sheet<null>;

declare const theme: ThemeHelper;

declare const cyrb32: Hasher;

export { Apply, BlendMode, BorderStyle, CSSAtKeyframes, CSSAtMedia, CSSAtSupports, CSSCustomProperties, CSSProperties, CSSPseudos, CSSRuleValue, CSSRules, CSSRulesThunk, CSSSimplePseudos, CompletionTokens, Configuration, Context, CoreCompletionTokens, CorePlugins, CoreVariants, Corners, CounterStyle, DarkMode, Directive, DirectiveHandler, Edges, Empty, Falsy, FontFace, FromTheme, GlobalValue, Hasher, InlineDirective, Instance, Interpolate, InterpolateKind, Join, JoinFromObject, MaybeArray, MaybeObjInterpolationGeneric, MaybeThunk, MaybeTokenInterpolation, Mode, Negatable, NonEmptyString, Plugin, Plugins, Prefixer, Preflight, Range, ReportInfo, Rule, Sheet, SheetConfig, SheetInit, SheetInitCallback, SimplePseudoClasses, SimplePseudoElements, TW, TWCallable, Theme, ThemeColor, ThemeColorObject, ThemeConfiguration, ThemeContainer, ThemeFontSize, ThemeHelper, ThemeOutline, ThemeResolver, ThemeScreen, ThemeScreenValue, ThemeSection, ThemeSectionRecord, ThemeSectionResolver, ThemeSectionResolverContext, ThemeSectionType, ToString, Token, TokenGrouping, TypescriptCompat, Unwrap, UserCompletionTokens, Variants, apply, autoprefix, create, cssomSheet, directive, expandGroups, cyrb32 as hash, mode, noprefix, setup, silent, strict, theme, tw, voidSheet, warn };
//# sourceMappingURL=twind.d.ts.map