@types/styled-components

const css: ThemedCssFunction<DefaultTheme>;

const styled: StyledInterface;

const ThemeConsumer: React.Context<any>;

const ThemeContext: React.Context<any>;

const ThemeProvider: React.ComponentClass<ThemeProviderProps<T, U>>;

const withTheme: WithThemeFnInterface<DefaultTheme>;

createGlobalStyle: <P extends object = {}>(
    first:
        | TemplateStringsArray
        | CSSObject
        | InterpolationFunction<ThemedStyledProps<P, DefaultTheme>>,
    ...interpolations: Array<Interpolation<ThemedStyledProps<P, DefaultTheme>>>
) => GlobalStyleComponent<P, DefaultTheme>;

isStyledComponent: (target: any) => target is any;

keyframes: (
    strings: TemplateStringsArray | CSSKeyframes,
    ...interpolations: SimpleInterpolation[]
) => Keyframes;

useTheme: () => DefaultTheme;

type AnyStyledComponent =
    | StyledComponent<any, any, any, any>
    | StyledComponent<any, any, any>;

type BaseThemeProviderComponent<
    T extends object,
    U extends object = T
> = React.ComponentClass<ThemeProviderProps<T, U>>;

type BaseWithThemeFnInterface<T extends object> = <
    C extends React.ComponentType<any>
>(
    // this check is roundabout because the extends clause above would
    // not allow any component that accepts _more_ than theme as a prop
    component: React.ComponentProps<C> extends { theme?: T | undefined } ? C : never
) => React.ForwardRefExoticComponent<
    WithOptionalTheme<
        React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>,
        T
    >
>;

type CSSKeyframes = object & { [key: string]: CSSObject };

type CSSProp<T = AnyIfEmpty<DefaultTheme>> =
    | string
    | CSSObject
    | FlattenInterpolation<ThemeProps<T>>;

type CSSProperties = CSS.Properties<string | number>;

type CSSPseudos = { [K in CSS.Pseudos]?: CSSObject };

type FalseyValue = undefined | null | false;

type FlattenInterpolation<P> = ReadonlyArray<Interpolation<P>>;

type FlattenSimpleInterpolation = readonly SimpleInterpolation[];

type Interpolation<P> =
    | InterpolationValue
    | InterpolationFunction<P>
    | FlattenInterpolation<P>;

type InterpolationFunction<P> = (props: P) => Interpolation<P>;

type InterpolationValue =
    | string
    | number
    | FalseyValue
    | Keyframes
    | StyledComponentInterpolation
    | CSSObject;

type IntrinsicElementsKeys = keyof React.JSX.IntrinsicElements;

type OmitU<T, K extends keyof T> = T extends any
    ? PickU<T, Exclude<keyof T, K>>
    : never;

type PickU<T, K extends keyof T> = T extends any ? { [P in K]: T[P] } : never;

type SimpleInterpolation = InterpolationValue | FlattenSimpleInterpolation;

type StyledComponent<
    C extends keyof React.JSX.IntrinsicElements | React.ComponentType<any>,
    T extends object,
    O extends object = {},
    A extends keyof any = never
> = // the "string" allows this to be used as an object key
    // I really want to avoid this if possible but it's the only way to use nesting with object styles...
    string &
        StyledComponentBase<C, T, O, A> &
        hoistNonReactStatics.NonReactStatics<
            C extends React.ComponentType<any> ? C : never
        >;

type StyledComponentInnerAttrs<C extends AnyStyledComponent> =
    C extends StyledComponent<any, any, any, infer A> ? A : never;

type StyledComponentInnerComponent<C extends React.ComponentType<any>> =
    C extends StyledComponent<infer I, any, any, any>
        ? I
        : C extends StyledComponent<infer I, any, any>
        ? I
        : C;

type StyledComponentInnerOtherProps<C extends AnyStyledComponent> =
    C extends StyledComponent<any, any, infer O, any>
        ? O
        : C extends StyledComponent<any, any, infer O>
        ? O
        : never;

type StyledComponentProps<
    // The Component from whose props are derived
    C extends string | React.ComponentType<any>,
    // The Theme from the current context
    T extends object,
    // The other props added by the template
    O extends object,
    // The props that are made optional by .attrs
    A extends keyof any,
    // The Component passed with "forwardedAs" prop
    FAsC extends string | React.ComponentType<any> = C
> =
    // Distribute O if O is a union type
    O extends object
        ? WithOptionalTheme<
              MakeAttrsOptional<C, O, A> & MakeAttrsOptional<FAsC, O, A>,
              T
          >
        : never;

type StyledComponentPropsWithRef<
    C extends keyof React.JSX.IntrinsicElements | React.ComponentType<any>
> = C extends AnyStyledComponent
    ? React.ComponentPropsWithRef<StyledComponentInnerComponent<C>>
    : React.ComponentPropsWithRef<C>;

type StyledFunction<
    C extends keyof React.JSX.IntrinsicElements | React.ComponentType<any>
> = ThemedStyledFunction<C, any>;

type StyledInterface = ThemedStyledInterface<DefaultTheme>;

type StyledProps<P> = ThemedStyledProps<P, AnyIfEmpty<DefaultTheme>>;

type StylisPlugin = (
    context: number,
    selector: string[],
    parent: string[],
    content: string,
    line: number,
    column: number,
    length: number
    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
) => string | void;

type ThemedCssFunction<T extends object> = BaseThemedCssFunction<AnyIfEmpty<T>>;

type ThemedGlobalStyledClassProps<
    P extends { theme?: T | undefined },
    T
> = WithOptionalTheme<P, T> & {
    suppressMultiMountWarning?: boolean | undefined;
};

type ThemedStyledInterface<T extends object> = ThemedBaseStyledInterface<
    AnyIfEmpty<T>
>;

type ThemedStyledProps<P, T> = P & ThemeProps<T>;

type ThemeProviderComponent<
    T extends object,
    U extends object = T
> = BaseThemeProviderComponent<AnyIfEmpty<T>, AnyIfEmpty<U>>;

type WithThemeFnInterface<T extends object> = BaseWithThemeFnInterface<
    AnyIfEmpty<T>
>;