import { CSSResultGroup } from 'lit';
import { LitElement } from 'lit';
import { PropertyDeclaration } from 'lit';
import { PropertyValues } from 'lit';
import { ReactiveElement } from 'lit';
import { Signal } from '@lit-labs/signals';

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 ChangedPropertiesConsumer<DefinedComponents extends ReactiveElement> = (changedProperties: PropertyValues<DefinedComponents>) => void;

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

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 FnSubscriber<T extends (...args: any[]) => unknown> = ReturnType<typeof fnSubscriber<T>>;

declare const fnSubscriber: <FN extends (...args: any[]) => unknown>() => {
    add: (fn: FN) => number;
    run: (t: unknown, ...args: Parameters<FN>) => unknown[];
};

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;
};

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;

/* Excluded from this release type: InternalOptions */

/**
 * Check if a value is a reactive proxy created by reactive().
 *
 * @typeParam T - The target object type.
 * @param target - The value to test.
 * @returns True if the value is a reactive object produced by reactive().
 */
export declare const isReactive: <T extends {}>(target: T) => target is Reactive<never>;

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

declare type LitRender = LitElement['render'];

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;

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

declare type Reactive<T> = T extends object ? {
    [K in keyof T]: T[K] extends Signal.State<infer V> ? V : T[K] extends (...args: any[]) => unknown ? T[K] : T[K] extends object ? Reactive<T[K]> : T[K];
} : T;

/**
 * Turn an object containing Effects into a reactive object.
 * @param target
 * @param deep - if true, recursively make all properties reactive
 */
export declare const reactive: <T extends {}>(target: T, deep?: boolean) => Reactive<T>;

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.
 */
declare type ValidCustomElementName = `${Lowercase<`${FirstCharacter}${string}-${string}`>}`;

export declare const withHooks: <Base extends abstract new (...args: any[]) => LitElement, Result = abstract new () => LitElement & InstanceType<Base> & {
    __opts: InternalOptions<InstanceType<Base>>;
}>(Base: Base) => Result;

export { }