import { CSSResultGroup } from 'lit';
import { LitElement } from 'lit';
import { PropertyDeclaration } from 'lit';
import { PropertyValues } from 'lit';
import { ReactiveElement } from 'lit';

declare type AlphaLowercase = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';

declare type ApplyMixins<TBase extends Class<unknown>, TMixins extends readonly unknown[]> = TMixins extends readonly [] ? TBase : TMixins extends readonly [infer First, ...infer Rest] ? First extends (base: Class<unknown> & typeof LitElement) => Class<infer R> ? TBase & ApplyMixins<Class<R>, Rest> : never : TBase;

declare type ChangedPropertiesConsumer<DefinedComponents extends ReactiveElement> = (changedProperties: PropertyValues<DefinedComponents>) => void;

declare type ChangedPropertiesPredicate<DefinedComponents extends ReactiveElement> = (changedProperties: PropertyValues<DefinedComponents>) => boolean;

declare type Class<T = {}> = new (...args: any[]) => T;

export declare type DefinedComponent = ReturnType<typeof defineElement>;

export declare type DefinedComponentInstance = InstanceType<DefinedComponent>;

export declare function defineElement(name: ValidCustomElementName, render: () => unknown, opts?: FunctionComponentOptions): typeof LitElement;

export declare function defineElement<Name extends ValidCustomElementName, UseShadowRoot extends boolean, Properties extends Record<string, DefinePropertyDeclaration>, Styles extends UseShadowRoot extends true | undefined ? CSSResultGroup | undefined : undefined, Parent extends typeof LitElement, Instance extends InstanceType<Parent> & UnwrapProps<Properties>, Render extends (this: Instance) => unknown, Setup extends (this: Instance, comp?: Instance) => void | Render>(options: {
    name?: ValidatedCustomElementName<Name>;
    parent?: Parent;
    styles?: Styles;
    props?: Properties;
    register?: boolean;
    shadowRoot?: UseShadowRoot;
    setup?: Setup;
    render?: Render;
}): typeof LitElement;

declare const defineElementWithOptions: <Name extends ValidCustomElementName, UseShadowRoot extends boolean, Properties extends Record<string, DefinePropertyDeclaration>, Styles extends UseShadowRoot extends true | undefined ? CSSResultGroup : never, Parent extends typeof LitElement, Instance extends InstanceType<Parent> & UnwrapProps<Properties>, Render extends (this: Instance) => unknown, Setup extends (this: Instance, comp?: Instance) => void | Render>(options: {
    name?: ValidatedCustomElementName<Name>;
    parent?: Parent;
    styles?: Styles;
    props?: Properties;
    register?: boolean;
    shadowRoot?: UseShadowRoot;
    setup?: Setup;
    render?: Render;
}, decorator: LitElementDecorator) => typeof LitElement;

declare interface DefinePropertyDeclaration<Type = unknown, TypeHint = unknown> extends PropertyDeclaration<Type, TypeHint> {
    readonly type?: TypeHint;
    readonly default?: TypeHint | (() => TypeHint);
}

declare type FirstCharacter = AlphaLowercase;

declare type ForbiddenCustomElementNames = 'annotation-xml' | 'color-profile' | 'font-face' | 'font-face-src' | 'font-face-uri' | 'font-face-format' | 'font-face-name' | 'missing-glyph';

declare type FunctionComponentOptions = {
    [K in keyof Parameters<typeof defineElementWithOptions>[0]]: Parameters<typeof defineElementWithOptions>[0][K];
} & {
    styles: any;
};

/**
 * Get the current instance of a LitElement.
 * There is only one thread of execution, so there is only one current instance at a time.
 */
export declare const getCurrentInstance: <T extends LitElement>() => T;

declare type IllegalCharacter = '<' | '>' | '/' | '\r' | '\t' | '\n' | '\f' | '\0' | '\u0020';

declare type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? unknown : null : [T] extends [{
    type: null | true;
}] ? unknown : [T] extends [DefinePropertyDeclaration<unknown, ObjectConstructor>] ? Record<string, unknown> : [T] extends [DefinePropertyDeclaration<unknown, BooleanConstructor>] ? boolean : [T] extends [DefinePropertyDeclaration<unknown, DateConstructor>] ? Date : [T] extends [DefinePropertyDeclaration<unknown, (infer U)[]>] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [DefinePropertyDeclaration<unknown, infer V>] ? V extends StringConstructor ? string : V extends NumberConstructor ? number : V extends BooleanConstructor ? boolean : V extends DateConstructor ? Date : V extends PropType<infer P> ? P : V : T;

declare type LitElementDecorator = (t: typeof LitElement) => typeof t;

export declare type Mixin<Type, BaseClass extends typeof LitElement & Class<Type> = typeof LitElement & Class<Type>, Result extends BaseClass = BaseClass> = (base: BaseClass) => Result;

export declare const mixin: <TBase extends Class<unknown>, TMixins extends readonly Mixin<unknown>[]>(base: TBase, ...mixins: TMixins) => ApplyMixins<TBase, TMixins>;

export declare const onConnected: <Type extends LitElement>(cb: SomeFunction) => number;

export declare const onDisconnected: <Type extends LitElement>(cb: SomeFunction) => number;

export declare const onFirstUpdated: <Type extends LitElement>(cb: ChangedPropertiesConsumer<Type>) => number;

export declare const onPerformUpdate: <Type extends LitElement>(cb: SomeFunction) => number;

export declare const onShouldUpdate: <Type extends LitElement>(cb: ChangedPropertiesPredicate<Type>) => number;

export declare const onUpdate: <Type extends LitElement>(cb: ChangedPropertiesConsumer<Type>) => number;

export declare const onUpdated: <Type extends LitElement>(cb: ChangedPropertiesConsumer<Type>) => number;

export declare const onWillUpdate: <Type extends LitElement>(cb: ChangedPropertiesConsumer<Type>) => number;

export declare type PropType<T> = TypeConstructor<T> | (TypeConstructor<T> | null)[];

declare type SomeFunction = (...args: unknown[]) => unknown;

declare type TypeConstructor<T = unknown> = (new (...args: unknown[]) => T & {}) | (() => T) | TypeMethod<T>;

declare type TypeMethod<T, Ctor = unknown> = [T] extends [((...args: unknown[]) => unknown) | undefined] ? {
    new (): Ctor;
    (): T;
    readonly prototype: Ctor;
} : never;

declare type UnwrapProps<Props extends Record<string, DefinePropertyDeclaration>> = {
    [K in keyof Props]: InferPropType<Props[K]>;
};

declare type ValidatedCustomElementName<Name extends ValidCustomElementName> = Name extends ForbiddenCustomElementNames ? never : Name extends `${string}${IllegalCharacter}${string}` ? never : Name;

/**
 * A very basic validator for custom element names.
 */
export declare type ValidCustomElementName = `${Lowercase<`${FirstCharacter}${string}-${string}`>}`;

export { }