import Stylis from '@emotion/stylis'
import type {Plugable} from '@emotion/stylis'
export declare type Falsy = false | 0 | null | undefined
export declare const hash: (string: string) => string
export declare const createDash: <
  Vars extends DefaultVars = DefaultVars,
  ThemeNames extends string = never
>(
  options?: DashOptions<Vars, ThemeNames>
) => DashCache<Vars, ThemeNames>
export interface DashOptions<
  Vars extends DefaultVars = DefaultVars,
  ThemeNames extends string = Extract<keyof DefaultThemes, string>
> {
  readonly key?: string
  readonly nonce?: string
  readonly hash?: typeof hash
  readonly stylisPlugins?: Plugable[]
  readonly prefix?:
    | boolean
    | ((key: string, value: any, context: any) => boolean)
  readonly container?: HTMLElement
  readonly speedy?: boolean
  readonly variables?: Vars
  readonly themes?: Themes<Vars, ThemeNames>
}
export declare type InsertCache = {
  [name: string]: number
}
export declare type VariableDefs =
  | {
      [name: string]: VariableDefs | string | number
    }
  | {
      [name: number]: VariableDefs | string | number
    }
export interface Variables {
  [name: string]: VariableDefs | string | number
}
export declare type GlobalCache = {
  [name: string]: {
    count: number
    sheet: DashStyleSheet
  }
}
export declare type StylisCache = {
  [name: string]: string
}
export declare type Themes<
  Vars extends DefaultVars = DefaultVars,
  ThemeNames extends string = Extract<keyof DefaultThemes, string>
> = {
  [Name in ThemeNames]: Vars
}
export declare type DashCache<
  Vars extends DefaultVars = DefaultVars,
  ThemeNames extends string = Extract<keyof DefaultThemes, string>
> = {
  readonly key: string
  readonly sheet: DashStyleSheet
  readonly hash: (string: string) => string
  readonly stylis: typeof Stylis
  readonly stylisCache: StylisCache
  readonly insert: (
    selector: string,
    name: string,
    styles: string,
    sheet: DashStyleSheet
  ) => void
  readonly insertCache: InsertCache
  variables: Vars
  readonly variablesCache: GlobalCache
  themes: Themes<Vars, ThemeNames>
  readonly globalCache: GlobalCache
  readonly clear: () => void
}
export interface DashStyleSheet {
  readonly key: string
  readonly nonce?: string
  readonly container?: HTMLElement
  readonly speedy: boolean
  readonly insert: (rule: string) => void
  readonly flush: () => void
}
export interface DashStyleSheetOptions {
  readonly key: string
  readonly container?: HTMLElement
  readonly nonce?: string
  readonly speedy: boolean
}
export declare const styleSheet: (
  options: DashStyleSheetOptions
) => DashStyleSheet
export declare type StyleObject = {
  [property: string]: StyleObject | string | number
}
export declare type SerializedVariables<
  Vars extends DefaultVars = DefaultVars
> = {
  readonly variables: Vars
  readonly styles: string
}
export declare type StyleGetter<Vars extends DefaultVars = DefaultVars> = (
  variables: Vars
) => StyleObject | string
export declare const normalizeStyles: <Vars extends DefaultVars = DefaultVars>(
  styles: string | StyleObject | StyleGetter<Vars>,
  variables: any
) => string
export interface CSSFunction<Names extends string> {
  (...names: (Names | StyleObjectArgument<Names> | Falsy)[]): string
}
export interface EjectGlobal {
  (): void
}
export declare type StyleDefs<
  Names extends string,
  Vars extends DefaultVars = DefaultVars
> = {
  [Name in Names | 'default']?: string | StyleGetter<Vars> | StyleObject
}
export interface DefaultVars {}
export interface DefaultThemes {}
export interface Styles<
  Vars extends DefaultVars = DefaultVars,
  ThemeNames extends string = Extract<keyof DefaultThemes, string>
> {
  <Names extends string>(defs: StyleDefs<Names, Vars>): Style<Names, Vars>
  create: <
    T extends DefaultVars = Vars,
    U extends string = Extract<keyof DefaultThemes, string>
  >(
    options?: DashOptions<T, U>
  ) => Styles<T, U>
  one: (
    literals: TemplateStringsArray | string | StyleObject | StyleGetter<Vars>,
    ...placeholders: string[]
  ) => OneCallback
  variables: (vars: Vars, selector?: string) => EjectGlobal
  themes: (themes: Themes<Vars, ThemeNames>) => EjectGlobal
  theme: (name: ThemeNames) => string
  global: (
    literals: TemplateStringsArray | string | StyleGetter<Vars> | StyleObject,
    ...placeholders: string[]
  ) => EjectGlobal
  dash: DashCache<Vars, ThemeNames>
}
export declare type StyleObjectArgument<Names extends string> = {
  [Name in Names]?: boolean | null | undefined | string | number
}
export interface Style<
  Names extends string = string,
  Vars extends DefaultVars = DefaultVars
> {
  (...args: (Names | StyleObjectArgument<Names> | Falsy)[]): string
  css: CSSFunction<Names>
  styles: StyleDefs<Names, Vars>
}
export interface OneCallbackCss {
  (): string
  toString: () => string
}
export declare type OneCallback = {
  (createClassName?: boolean | number | string | null): string
  toString: () => string
  css: OneCallbackCss
}
export declare const styles: Styles<
  DefaultVars,
  Extract<keyof DefaultThemes, string>
>
export default styles