import * as s from 'superstruct';
export declare const strokeStyleValues: readonly ["solid", "dashed", "dotted", "double", "groove", "ridge", "outset", "inset"];
/**
 * Don't use this one, use this instead:
 * @see {@link TokenDefinitionSingular}
 */
type TokenDefinitionSingularRaw = {
    type: 'string';
    value: string;
} | {
    type: 'number';
    value: number;
} | {
    type: 'boolean';
    value: boolean;
} | {
    type: 'color';
    value: string;
} | {
    type: 'strokeStyle';
    value: (typeof strokeStyleValues)[number];
} | {
    type: 'dimension';
    value: `${number}${'px' | 'rem' | 'em' | '%'}`;
} | {
    type: 'duration';
    value: `${number}ms`;
} | {
    type: 'fontWeight';
    value: string | number;
} | {
    type: 'cubicBezier';
    value: [number, number, number, number];
};
/**
 * Definitions for both singular (non-composite) tokens.
 * Use first generic param to get just that type.
 * @example
 * ```ts
 * type TokenDefinitionDimension = TokenDefinitionSingular<'dimension'>
 * ```
 */
export type TokenDefinitionSingular<TheTokenType extends TokenDefinitionSingularRaw['type'] = TokenDefinitionSingularRaw['type']> = Extract<TokenDefinitionSingularRaw, {
    type: TheTokenType;
}>;
/**
 * Don't use this one, use this instead:
 * @see {@link TokenDefinitionComposite}
 */
type TokenDefinitionCompositeRaw = {
    type: 'border';
    value: {
        color: {
            type: 'color';
        };
        style: {
            type: 'strokeStyle';
        };
        width: {
            type: 'dimension';
        };
    };
} | {
    type: 'shadow';
    value: {
        color: {
            type: 'color';
        };
        offsetX: {
            type: 'dimension';
        };
        offsetY: {
            type: 'dimension';
        };
        spread: {
            type: 'dimension';
        };
        blur: {
            type: 'dimension';
        };
        inset: {
            type: 'boolean';
        };
    };
} | {
    type: 'transition';
    value: {
        duration: {
            type: 'duration';
        };
        delay: {
            type: 'duration';
        };
        timingFunction: {
            type: 'cubicBezier';
        };
    };
};
/**
 * Definitions for composite tokens.
 * Use first generic param to get just that type.
 * @example
 * ```ts
 * type TokenDefinitionShadow = TokenDefinitionComposite<'shadow'>
 * ```
 */
export type TokenDefinitionComposite<TheTokenType extends TokenDefinitionCompositeRaw['type'] = TokenDefinitionCompositeRaw['type']> = Extract<TokenDefinitionCompositeRaw, {
    type: TheTokenType;
}>;
/**
 * Definitions for both singular and composite tokens.
 * Use first generic param to get just that type.
 * @example
 * ```ts
 * type TokenDefinitionDimension = TokenDefinition<'dimension'>
 * ```
 */
export type TokenDefinition<TheTokenType extends TokenDefinitionComposite['type'] | TokenDefinitionSingular['type'] = TokenDefinitionComposite['type'] | TokenDefinitionSingular['type']> = Extract<TokenDefinitionComposite | TokenDefinitionSingular, {
    type: TheTokenType;
}>;
export type TokenReference = `{${string}}`;
/** ensures there is no `{}` */
export type NotTokenReference<T> = T extends TokenReference ? never : T;
export declare function isTokenReference(val: unknown): val is TokenReference;
export declare function hasTokenReferences(val: unknown): boolean;
export declare function isNotTokenReference<T>(value: T): value is NotTokenReference<T>;
export declare const TokenReferenceStruct: s.Struct<`{${string}}`, null>;
export type TokenType = TokenDefinition['type'];
export type TokenTypeComposite = TokenDefinitionComposite['type'];
export type TokenTypeSingular = TokenDefinitionSingular['type'];
export type TokenValueSingular = TokenDefinitionSingular['value'];
export declare const tokenTypeComposites: ("border" | "shadow" | "transition")[];
export declare const tokenTypeSingulars: ("string" | "number" | "boolean" | "color" | "strokeStyle" | "dimension" | "duration" | "fontWeight" | "cubicBezier")[];
/**
 * @deprecated You probably want `isTokenDataComposite`
 * @see {isTokenDataComposite}
 */
export declare function isTokenTypeComposite(type: TokenType): type is TokenTypeComposite;
export declare function isTokenTypeSingular(type: TokenType): type is TokenTypeSingular;
export {};
//# sourceMappingURL=token-definitions.d.ts.map