import type * as CSS from 'csstype';
export type CSSValue = string | number;
export type CustomValue = string | number | boolean;
export type Value = CustomValue | readonly CustomValue[];
export type PropertyValueDefinition<T> = T | {
    [condition: string]: PropertyValueDefinition<T>;
};
export type PropertyValueMap<T extends CSSValue = CSSValue> = {
    [name in T]: PropertyValueDefinition<string>;
};
export type CustomProperty = `--${string}`;
export type CSSProperties = CSS.Properties & {
    [k: CustomProperty]: CSSValue;
};
export type PropertyFunction<T extends Value> = (value: T, property: string) => PropertyValueDefinition<[CSSProperties, string]>;
export interface Theme {
    properties: {
        [name: string]: PropertyValueMap | PropertyFunction<any> | string[];
    };
    conditions: {
        [name: string]: string;
    };
    shorthands: {
        [name: string]: string[];
    };
}
type PropertyValue<T> = T extends PropertyFunction<infer P> ? P : T extends PropertyValueMap<infer P> ? P : T extends string[] ? T[number] : never;
type PropertyValue2<T> = PropertyValue<T> | CustomProperty | `[${string}]`;
type Merge<T> = T extends any ? T : never;
export type ThemeProperties<T extends Theme> = Merge<{
    [K in keyof T['properties'] | keyof T['shorthands']]: K extends keyof T['properties'] ? Merge<PropertyValue2<T['properties'][K]>> : Merge<PropertyValue2<T['properties'][T['shorthands'][K][0]]>>;
}>;
type Style<T extends ThemeProperties<Theme>, C extends string, R extends RenderProps<string>> = StaticProperties<T, C, R> & CustomProperties<T, C, R>;
type StaticProperties<T extends ThemeProperties<Theme>, C extends string, R extends RenderProps<string>> = {
    [Name in keyof T]?: StyleValue<T[Name], C, R>;
};
type CustomProperties<T extends ThemeProperties<Theme>, C extends string, R extends RenderProps<string>> = {
    [key: CustomProperty]: CustomPropertyValue<T, keyof T, C, R>;
};
type CustomPropertyValue<T extends ThemeProperties<Theme>, P extends keyof T, C extends string, R extends RenderProps<string>> = P extends any ? {
    type: P;
    value: StyleValue<T[P], C, R>;
} : never;
export type RenderProps<K extends string> = {
    [key in K]: any;
};
export type StyleValue<V extends Value, C extends string, R extends RenderProps<string>> = V | Conditional<V, C, R>;
export type Condition<T extends Theme> = 'default' | Extract<keyof T['conditions'], string>;
type Conditional<V extends Value, C extends string, R extends RenderProps<string>> = CSSConditions<V, C, R> & RuntimeConditions<V, C, R>;
type ArbitraryCondition = `:${string}` | `@${string}`;
type CSSConditions<V extends Value, C extends string, R extends RenderProps<string>> = {
    [name in C]?: StyleValue<V, C, R>;
};
type RuntimeConditions<V extends Value, C extends string, R extends RenderProps<string>> = [
    R
] extends [never] ? UnknownConditions<V, C> : RenderPropConditions<V, C, R>;
type UnknownConditions<V extends Value, C extends string> = {
    [name: string]: StyleValue<V, C, never> | VariantMap<string, V, C, never>;
};
type BooleanConditionName = `is${Capitalize<string>}` | `allows${Capitalize<string>}`;
type RenderPropConditions<V extends Value, C extends string, R extends RenderProps<string>> = {
    [K in keyof R]?: K extends BooleanConditionName ? StyleValue<V, C, R> : VariantMap<R[K], V, C, R>;
};
type Values<T, K extends keyof T = keyof T> = {
    [k in K]: T[k];
}[K];
export type VariantMap<K extends CSSValue, V extends Value, C extends string, R extends RenderProps<string>> = {
    [k in K]?: StyleValue<V, C, R>;
};
type ExtractConditionalValue<C extends keyof any, V> = V extends Value ? never : RuntimeConditionObject<Extract<keyof V, BooleanConditionName>, boolean> | Variants<V, Exclude<keyof V, C | BooleanConditionName>> | ExtractConditionalValue<C, Values<V, Extract<keyof V, C | BooleanConditionName>> | Values<Values<V, Exclude<keyof V, C | BooleanConditionName>>>>;
type RuntimeConditionObject<K, V> = K extends keyof any ? {
    [P in K]?: V;
} : never;
type Variants<T, K extends keyof T> = K extends any ? {
    [k in K]?: keyof T[k];
} : never;
type InferCustomPropertyValue<T> = T extends {
    value: infer V;
} ? V : never;
type KeysOfUnion<T> = T extends T ? keyof T : never;
type KeyValue<T, K extends KeysOfUnion<T>> = T extends {
    [k in K]?: any;
} ? T[K] : never;
type MergeUnion<T> = {
    [K in KeysOfUnion<T>]: KeyValue<T, K>;
};
type RuntimeConditionsObject<C extends keyof any, S extends Style<any, any, any>> = MergeUnion<ExtractConditionalValue<C, Values<S, Exclude<keyof S, CustomProperty>> | InferCustomPropertyValue<Values<S, Extract<keyof S, CustomProperty>>>>>;
type IncludedProperties<S> = Merge<{
    [K in keyof S]: unknown;
}>;
type Keys<R> = [R] extends [never] ? never : keyof R;
export type RuntimeStyleFunction<S, R> = Keys<R> extends never ? () => string & S : (props: R) => string & S;
type InferProps<R, C extends keyof any, S extends Style<any, any, any>> = [R] extends [never] ? AllowOthers<RuntimeConditionsObject<C, S>> : R;
type AllowOthers<R> = Keys<R> extends never ? never : R | {
    [x: string]: any;
};
export type StyleFunction<T extends ThemeProperties<Theme>, C extends string> = <R extends RenderProps<string> = never, S extends Style<T, C, R> = Style<T, C | ArbitraryCondition, R>>(style: S) => RuntimeStyleFunction<IncludedProperties<S>, InferProps<R, C | ArbitraryCondition, S>>;
type LimitTheme<T, P> = Merge<{
    [K in keyof T]?: K extends P ? unknown : never;
}>;
export type CSSProp<S, P extends string | number> = S extends StyleFunction<infer T, any> ? string & LimitTheme<T, P> : never;
export {};