declare const isString: (v: any) => v is string;
declare const isBoolean: (v: any) => v is boolean;
type AnyFunction = (...args: any[]) => any;
declare const isFunction: (v: any) => v is AnyFunction;
declare function isObject(value: any): value is Record<string, any>;
declare const isSymbol: (v: any) => v is symbol;
declare const isObjectOrArray: (obj: unknown) => obj is object;

interface CreateCssContext {
    hash?: boolean;
    /**
     * Partial properties from the Utility class
     */
    utility: {
        prefix: string;
        hasShorthand: boolean;
        resolveShorthand: (prop: string) => string;
        transform: (prop: string, value: any) => {
            className: string;
        };
        toHash: (path: string[], toHash: (str: string) => string) => string;
    };
    /**
     * Partial properties from the Condition class
     */
    conditions?: {
        breakpoints: {
            keys: string[];
        };
        shift: (paths: string[]) => string[];
        finalize: (paths: string[]) => string[];
    };
}
declare function createCss(context: CreateCssContext): ({ base, ...styles }?: Record<string, any>) => string;
interface StyleObject {
    [key: string]: any;
}
declare function createMergeCss(context: CreateCssContext): {
    mergeCss: (...styles: StyleObject[]) => StyleObject;
    assignCss: (...styles: StyleObject[]) => any;
};

declare function compact<T extends Record<string, any>>(value: T): T;

declare const isBaseCondition: (v: string) => v is "base";
declare function filterBaseConditions(c: string[]): string[];

type Predicate<R = any> = (value: any, path: string[]) => R;
type MappedObject<T, K> = {
    [Prop in keyof T]: T[Prop] extends Array<any> ? MappedObject<T[Prop][number], K>[] : T[Prop] extends Record<string, unknown> ? MappedObject<T[Prop], K> : K;
};
type WalkObjectStopFn = (value: any, path: string[]) => boolean;
interface WalkObjectOptions {
    stop?: WalkObjectStopFn;
    getKey?(prop: string, value: any): string;
}
declare function walkObject<T, K>(target: T, predicate: Predicate<K>, options?: WalkObjectOptions): MappedObject<T, ReturnType<Predicate<K>>>;
declare function mapObject(obj: any, fn: (value: any) => any): any;

declare function toHash(value: string): string;

declare const hypenateProperty: (property: string) => string;

declare function isImportant<T extends string | number | boolean>(value: T): boolean;
declare function withoutImportant<T extends string | number | boolean>(value: T): string | T;
declare function withoutSpace<T extends string | number | boolean>(str: T): string | T;
type Dict$1 = Record<string, unknown>;
declare function markImportant(obj: Dict$1): {};

declare const memo: <T extends (...args: any[]) => any>(fn: T) => T;

declare function mergeProps<T extends Record<string, unknown>>(...sources: T[]): T;

declare const patternFns: {
    map: typeof mapObject;
    isCssFunction: (v: unknown) => boolean;
    isCssVar: (v: unknown) => boolean;
    isCssUnit: (v: unknown) => boolean;
};
declare const getPatternStyles: (pattern: any, styles: Record<string, any>) => any;

declare const getSlotRecipes: (recipe?: Record<string, any>) => Record<string, any>;
declare const getSlotCompoundVariant: <T extends {
    css: any;
}>(compoundVariants: T[], slotName: string) => (T & {
    css: any;
})[];

type Dict = Record<string, unknown>;
type PredicateFn = (key: string) => boolean;
type Key = PredicateFn | string[];
declare function splitProps(props: Dict, ...keys: Key[]): Dict[];

declare const uniq: <T>(...items: T[][]) => T[];

export { walkObject as A, mapObject as B, type CreateCssContext as C, type MappedObject as M, type WalkObjectStopFn as W, isBoolean as a, isFunction as b, isObject as c, isSymbol as d, isObjectOrArray as e, createCss as f, createMergeCss as g, compact as h, isString as i, isBaseCondition as j, filterBaseConditions as k, hypenateProperty as l, isImportant as m, withoutSpace as n, markImportant as o, memo as p, mergeProps as q, patternFns as r, getPatternStyles as s, toHash as t, getSlotRecipes as u, getSlotCompoundVariant as v, withoutImportant as w, splitProps as x, uniq as y, type WalkObjectOptions as z };