@a11d/lit 0.0.6

package/README.md

@@ -0,0 +1 @@
+A thin wrapper around the Lit library.

package/dist/Component/Component.d.ts

@@ -0,0 +1,18 @@
+import { LitElement, PropertyValues } from 'lit';
+export declare const component: (tagName: string) => (classOrDescriptor: import("@lit/reactive-element/decorators/base").ClassDescriptor | {
+    prototype: HTMLElement;
+}) => any;
+export declare abstract class Component extends LitElement {
+    /** Invoked after first update i.e. render is completed */
+    protected initialized(): void;
+    /** Invoked every time the component is connected to the Document Object Model (DOM) */
+    protected connected(): void;
+    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
+    protected disconnected(): void;
+    /** @deprecated Use template getter instead */
+    protected render(): import("lit-html").TemplateResult<2 | 1>;
+    protected get template(): import("lit-html").TemplateResult<2 | 1>;
+    firstUpdated(props: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}

package/dist/Component/Component.js

@@ -0,0 +1,31 @@
+import { LitElement } from 'lit';
+import { customElement } from 'lit/decorators.js';
+import { nothing } from '.';
+export const component = customElement;
+export class Component extends LitElement {
+    /** Invoked after first update i.e. render is completed */
+    initialized() { }
+    /** Invoked every time the component is connected to the Document Object Model (DOM) */
+    connected() { }
+    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
+    disconnected() { }
+    /** @deprecated Use template getter instead */
+    render() {
+        return this.template;
+    }
+    get template() {
+        return nothing;
+    }
+    firstUpdated(props) {
+        super.firstUpdated(props);
+        this.initialized();
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.connected();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.disconnected();
+    }
+}

package/dist/Component/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nothing';
+export * from './Component';

package/dist/Component/index.js

@@ -0,0 +1,2 @@
+export * from './nothing';
+export * from './Component';

package/dist/Component/nothing.d.ts

@@ -0,0 +1,2 @@
+import { TemplateResult } from 'lit';
+export declare const nothing: TemplateResult<2 | 1>;

package/dist/Component/nothing.js

@@ -0,0 +1,2 @@
+import { nothing as litNothing } from 'lit';
+export const nothing = litNothing;

package/dist/Controller/Controller.d.ts

@@ -0,0 +1,9 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare abstract class Controller implements ReactiveController {
+    protected readonly host: ReactiveControllerHost;
+    constructor(host: ReactiveControllerHost);
+    hostConnected?(): void;
+    hostDisconnected?(): void;
+    hostUpdate?(): void;
+    hostUpdated?(): void;
+}

package/dist/Controller/Controller.js

@@ -0,0 +1,6 @@
+export class Controller {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+}

package/dist/Controller/index.d.ts

@@ -0,0 +1 @@
+export * from './Controller';

package/dist/Controller/index.js

@@ -0,0 +1 @@
+export * from './Controller';

package/dist/decorateLitElement.d.ts

@@ -0,0 +1,7 @@
+import { LitElement } from 'lit';
+export declare const decorateLitElement: <T>({ constructorPropertyName, prototype, initialValue, lifecycleHooks }: {
+    constructorPropertyName: string;
+    prototype: LitElement;
+    initialValue: T;
+    lifecycleHooks: Map<string, (this: LitElement, data: T, ...args: Array<any>) => any>;
+}) => T;

package/dist/decorateLitElement.js

@@ -0,0 +1,19 @@
+export const decorateLitElement = ({ constructorPropertyName, prototype, initialValue, lifecycleHooks }) => {
+    const p = prototype;
+    const constructor = prototype.constructor;
+    const existingValue = Object.getOwnPropertyDescriptor(constructor, constructorPropertyName)?.value;
+    if (existingValue) {
+        return existingValue;
+    }
+    const inheritedValue = constructor[constructorPropertyName];
+    const value = inheritedValue ? Object.assign(initialValue, inheritedValue) : initialValue;
+    Object.defineProperty(constructor, constructorPropertyName, { value });
+    for (const [lifecycleName, lifecycleFunction] of lifecycleHooks) {
+        const originalFunction = p[lifecycleName];
+        p[lifecycleName] = function (...args) {
+            originalFunction.call(this, ...args);
+            lifecycleFunction.call(this, value, ...args);
+        };
+    }
+    return value;
+};

package/dist/event/EventDispatcher.d.ts

@@ -0,0 +1,6 @@
+declare type EventHandler<T> = (data: T) => void;
+interface EventDispatcher<T = void> {
+    dispatch(value: T): void;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+}

package/dist/event/EventDispatcher.js

@@ -0,0 +1 @@
+"use strict";

package/dist/event/HTMLElementEventDispatcher.d.ts

@@ -0,0 +1,10 @@
+export declare class HTMLElementEventDispatcher<T = void> implements EventDispatcher<T> {
+    private readonly element;
+    private readonly type;
+    private readonly options?;
+    private readonly handlersMap;
+    constructor(element: HTMLElement, type: string, options?: EventInit | undefined);
+    dispatch(value: T): void;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+}

package/dist/event/HTMLElementEventDispatcher.js

@@ -0,0 +1,23 @@
+export class HTMLElementEventDispatcher {
+    constructor(element, type, options) {
+        this.element = element;
+        this.type = type;
+        this.options = options;
+        this.handlersMap = new Map();
+    }
+    dispatch(value) {
+        this.element.dispatchEvent(new CustomEvent(this.type, { detail: value, ...this.options }));
+    }
+    subscribe(handler) {
+        const nativeHandler = (event) => handler(event.detail);
+        this.element.addEventListener(this.type, nativeHandler);
+        this.handlersMap.set(handler, nativeHandler);
+    }
+    unsubscribe(handler) {
+        const nativeHandler = this.handlersMap.get(handler);
+        if (nativeHandler) {
+            this.element.removeEventListener(this.type, nativeHandler);
+        }
+        this.handlersMap.delete(handler);
+    }
+}

package/dist/event/PureEventDispatcher.d.ts

@@ -0,0 +1,6 @@
+export declare class PureEventDispatcher<T = void> implements EventDispatcher<T> {
+    private readonly handlers;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+    dispatch(data: T): void;
+}

package/dist/event/PureEventDispatcher.js

@@ -0,0 +1,16 @@
+export class PureEventDispatcher {
+    constructor() {
+        this.handlers = new Set();
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+    }
+    unsubscribe(handler) {
+        this.handlers.delete(handler);
+    }
+    dispatch(data) {
+        for (const handler of this.handlers) {
+            handler(data);
+        }
+    }
+}

package/dist/event/event.d.ts

@@ -0,0 +1 @@
+export declare function event(options?: EventInit): (prototype: unknown, propertyKey?: string) => void;

package/dist/event/event.js

@@ -0,0 +1,20 @@
+import { HTMLElementEventDispatcher } from './HTMLElementEventDispatcher';
+import { PureEventDispatcher } from './PureEventDispatcher';
+export function event(options) {
+    return (prototype, propertyKey) => {
+        if (propertyKey === undefined) {
+            return;
+        }
+        const eventFieldName = `$${propertyKey}Event$`;
+        Object.defineProperty(prototype, propertyKey, {
+            get() {
+                if (!this[eventFieldName]) {
+                    this[eventFieldName] = this instanceof HTMLElement
+                        ? new HTMLElementEventDispatcher(this, propertyKey, options)
+                        : new PureEventDispatcher();
+                }
+                return this[eventFieldName];
+            }
+        });
+    };
+}

package/dist/event/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PureEventDispatcher';
+export * from './HTMLElementEventDispatcher';
+export * from './event';

package/dist/event/index.js

@@ -0,0 +1,3 @@
+export * from './PureEventDispatcher';
+export * from './HTMLElementEventDispatcher';
+export * from './event';

package/dist/eventListener/eventListener.d.ts

@@ -0,0 +1,13 @@
+import { LitElement } from 'lit';
+declare type ShorthandEventListenerDecoratorOptions = [type: string, options?: EventListenerOptions | boolean];
+declare type FullEventListenerDecoratorOptions = [
+    {
+        type: string;
+        target?: EventTarget | ((this: any) => EventTarget);
+        options?: EventListenerOptions | boolean;
+    }
+];
+declare type EventListenerDecoratorOptions = ShorthandEventListenerDecoratorOptions | FullEventListenerDecoratorOptions;
+export declare const eventListener: (...eventListenerOptions: EventListenerDecoratorOptions) => (prototype: LitElement, propertyKey: string, descriptor?: PropertyDescriptor) => void;
+export declare const extractEventHandler: <TEvent extends Event = Event>(eventListener: EventListenerOrEventListenerObject) => (event: TEvent) => void;
+export {};

package/dist/eventListener/eventListener.js

@@ -0,0 +1,76 @@
+import { decorateLitElement } from '../decorateLitElement';
+function extractArguments(args) {
+    const short = ((args) => typeof args[0] === 'string')(args);
+    return {
+        type: short ? args[0] : args[0].type,
+        target: short ? undefined : args[0].target,
+        options: short ? args[1] : args[0].options,
+    };
+}
+function extractEventTarget(target) {
+    return typeof target === 'function' ? target.call(this) : target ?? this;
+}
+export const eventListener = (...eventListenerOptions) => {
+    return (prototype, propertyKey, descriptor) => {
+        decorateLitElement({
+            prototype,
+            constructorPropertyName: '$eventListeners$',
+            initialValue: new Map,
+            lifecycleHooks: new Map([
+                ['connectedCallback', function (eventListeners) {
+                        for (const [key, { type, target, options, descriptor, property }] of eventListeners) {
+                            if (this.constructor.name === extractConstructorNameFromUniquePropertyKey(key)) {
+                                defineBoundListener.call(this, property, descriptor);
+                                extractEventTarget.call(this, target)
+                                    ?.addEventListener(type, getBoundListener.call(this, property), options);
+                            }
+                        }
+                    }],
+                ['disconnectedCallback', function (eventListeners) {
+                        for (const { type, target, options, property } of eventListeners.values()) {
+                            extractEventTarget.call(this, target)
+                                ?.removeEventListener(type, getBoundListener.call(this, property), options);
+                        }
+                    }],
+            ])
+        }).set(getUniquePropertyKey(prototype.constructor, propertyKey), { descriptor, property: propertyKey, ...extractArguments(eventListenerOptions) });
+    };
+};
+const getUniquePropertyKey = (constructor, property) => `${constructor.name}.${property}`;
+const extractConstructorNameFromUniquePropertyKey = (uniquePropertyKey) => uniquePropertyKey.split('.')[0];
+function getBoundListener(propertyKey) {
+    return Object.getOwnPropertyDescriptor(this, getBoundMethodKey(propertyKey))?.value;
+}
+function defineBoundListener(propertyKey, descriptor) {
+    const unboundFunction = !descriptor
+        ? Object.getOwnPropertyDescriptor(this, propertyKey)?.value
+        : typeof descriptor.get === 'function'
+            ? descriptor.get
+            : descriptor.value;
+    if (isEventListenerOrEventListenerObject(unboundFunction) === false) {
+        throw new TypeError(`${getUniquePropertyKey(this.constructor, propertyKey)} is not a function`);
+    }
+    Object.defineProperty(this, getBoundMethodKey(propertyKey), {
+        // eslint-disable-next-line no-restricted-syntax
+        value: unboundFunction.bind(this),
+        configurable: true,
+        enumerable: false,
+        writable: false,
+    });
+}
+const getBoundMethodKey = (method) => `$BOUND_${method}$`;
+const isEventListenerOrEventListenerObject = (listener) => {
+    const isListener = typeof listener === 'function';
+    // @ts-expect-error 'in' operator seemingly does not narrow down the type
+    const isListenerObject = typeof listener === 'object' && listener !== null && 'handleEvent' in listener && typeof listener.handleEvent === 'function';
+    return isListener || isListenerObject;
+};
+export const extractEventHandler = (eventListener) => {
+    if ('_$committedValue' in eventListener) {
+        const eventPart = eventListener;
+        const handler = eventListener['_$committedValue'];
+        // eslint-disable-next-line no-restricted-syntax
+        return handler.bind(eventPart.element);
+    }
+    return typeof eventListener === 'function' ? eventListener : eventListener.handleEvent;
+};

package/dist/eventListener/index.d.ts

@@ -0,0 +1 @@
+export * from './eventListener';

package/dist/eventListener/index.js

@@ -0,0 +1 @@
+export * from './eventListener';

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export * from 'lit';
+export { InternalPropertyDeclaration, QueryAssignedElementsOptions, QueryAssignedNodesOptions, eventOptions, queryAssignedElements, queryAssignedNodes, queryAsync } from 'lit/decorators.js';
+export * from 'lit-html';
+export * from 'lit/directive.js';
+export * from 'lit/directives/repeat.js';
+export * from 'lit/directives/cache.js';
+export * from 'lit/directives/if-defined.js';
+export * from 'lit/directives/until.js';
+export * from 'lit/directives/live.js';
+export * from 'lit/directives/style-map.js';
+export * from 'lit/directives/class-map.js';
+export * from 'lit/directives/choose.js';
+export * from 'lit/directives/join.js';
+export * from 'lit/directives/async-append.js';
+export * from 'lit/directives/async-replace.js';
+export * from 'lit/directives/ref.js';
+export * from 'lit/directives/unsafe-html.js';
+export * from 'lit/directives/unsafe-svg.js';
+export * from 'lit/directives/when.js';
+export * from 'lit/directives/async-replace';
+export * from 'lit/directives/async-append';
+export * from 'lit/directives/template-content';
+import './types';
+export { Component, nothing } from './Component';
+export * from './Controller';
+export * from './query';
+export * from './updated';
+export * from './eventListener';
+export * from './event';

package/dist/index.js

@@ -0,0 +1,30 @@
+/* eslint-disable import/export */
+export * from 'lit';
+export { eventOptions, queryAssignedElements, queryAssignedNodes, queryAsync } from 'lit/decorators.js';
+export * from 'lit-html';
+export * from 'lit/directive.js';
+export * from 'lit/directives/repeat.js';
+export * from 'lit/directives/cache.js';
+export * from 'lit/directives/if-defined.js';
+export * from 'lit/directives/until.js';
+export * from 'lit/directives/live.js';
+export * from 'lit/directives/style-map.js';
+export * from 'lit/directives/class-map.js';
+export * from 'lit/directives/choose.js';
+export * from 'lit/directives/join.js';
+export * from 'lit/directives/async-append.js';
+export * from 'lit/directives/async-replace.js';
+export * from 'lit/directives/ref.js';
+export * from 'lit/directives/unsafe-html.js';
+export * from 'lit/directives/unsafe-svg.js';
+export * from 'lit/directives/when.js';
+export * from 'lit/directives/async-replace';
+export * from 'lit/directives/async-append';
+export * from 'lit/directives/template-content';
+import './types';
+export { Component, nothing } from './Component';
+export * from './Controller';
+export * from './query';
+export * from './updated';
+export * from './eventListener';
+export * from './event';

package/dist/packages/Component/Component.d.ts

@@ -0,0 +1,18 @@
+import { LitElement, PropertyValues } from 'lit';
+export declare const component: (tagName: string) => (classOrDescriptor: import("@lit/reactive-element/decorators/base").ClassDescriptor | {
+    prototype: HTMLElement;
+}) => any;
+export declare abstract class Component extends LitElement {
+    /** Invoked after first update i.e. render is completed */
+    protected initialized(): void;
+    /** Invoked every time the component is connected to the Document Object Model (DOM) */
+    protected connected(): void;
+    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
+    protected disconnected(): void;
+    /** @deprecated Use template getter instead */
+    protected render(): import("lit-html").TemplateResult<1 | 2>;
+    protected get template(): import("lit-html").TemplateResult<1 | 2>;
+    firstUpdated(props: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}

package/dist/packages/Component/Component.js

@@ -0,0 +1,31 @@
+import { LitElement } from 'lit';
+import { customElement } from 'lit/decorators.js';
+import { nothing } from '.';
+export const component = customElement;
+export class Component extends LitElement {
+    /** Invoked after first update i.e. render is completed */
+    initialized() { }
+    /** Invoked every time the component is connected to the Document Object Model (DOM) */
+    connected() { }
+    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
+    disconnected() { }
+    /** @deprecated Use template getter instead */
+    render() {
+        return this.template;
+    }
+    get template() {
+        return nothing;
+    }
+    firstUpdated(props) {
+        super.firstUpdated(props);
+        this.initialized();
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.connected();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.disconnected();
+    }
+}

package/dist/packages/Component/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nothing';
+export * from './Component';

package/dist/packages/Component/index.js

@@ -0,0 +1,2 @@
+export * from './nothing';
+export * from './Component';

package/dist/packages/Component/nothing.d.ts

@@ -0,0 +1,2 @@
+import { TemplateResult } from 'lit';
+export declare const nothing: TemplateResult<1 | 2>;

package/dist/packages/Component/nothing.js

@@ -0,0 +1,2 @@
+import { nothing as litNothing } from 'lit';
+export const nothing = litNothing;

package/dist/packages/Controller/Controller.d.ts

@@ -0,0 +1,9 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare abstract class Controller implements ReactiveController {
+    protected readonly host: ReactiveControllerHost;
+    constructor(host: ReactiveControllerHost);
+    hostConnected?(): void;
+    hostDisconnected?(): void;
+    hostUpdate?(): void;
+    hostUpdated?(): void;
+}

package/dist/packages/Controller/Controller.js

@@ -0,0 +1,6 @@
+export class Controller {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+}

package/dist/packages/Controller/index.d.ts

@@ -0,0 +1 @@
+export * from './Controller';

package/dist/packages/Controller/index.js

@@ -0,0 +1 @@
+export * from './Controller';

package/dist/packages/decorateLitElement.d.ts

@@ -0,0 +1,7 @@
+import { LitElement } from 'lit';
+export declare const decorateLitElement: <T>({ constructorPropertyName, prototype, initialValue, lifecycleHooks }: {
+    constructorPropertyName: string;
+    prototype: LitElement;
+    initialValue: T;
+    lifecycleHooks: Map<string, (this: LitElement, data: T, ...args: Array<any>) => any>;
+}) => T;

package/dist/packages/decorateLitElement.js

@@ -0,0 +1,19 @@
+export const decorateLitElement = ({ constructorPropertyName, prototype, initialValue, lifecycleHooks }) => {
+    const p = prototype;
+    const constructor = prototype.constructor;
+    const existingValue = Object.getOwnPropertyDescriptor(constructor, constructorPropertyName)?.value;
+    if (existingValue) {
+        return existingValue;
+    }
+    const inheritedValue = constructor[constructorPropertyName];
+    const value = inheritedValue ? Object.assign(initialValue, inheritedValue) : initialValue;
+    Object.defineProperty(constructor, constructorPropertyName, { value });
+    for (const [lifecycleName, lifecycleFunction] of lifecycleHooks) {
+        const originalFunction = p[lifecycleName];
+        p[lifecycleName] = function (...args) {
+            originalFunction.call(this, ...args);
+            lifecycleFunction.call(this, value, ...args);
+        };
+    }
+    return value;
+};

package/dist/packages/event/EventDispatcher.d.ts

@@ -0,0 +1,6 @@
+declare type EventHandler<T> = (data: T) => void;
+interface EventDispatcher<T = void> {
+    dispatch(value: T): void;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+}

package/dist/packages/event/EventDispatcher.js

@@ -0,0 +1 @@
+"use strict";

package/dist/packages/event/HTMLElementEventDispatcher.d.ts

@@ -0,0 +1,10 @@
+export declare class HTMLElementEventDispatcher<T = void> implements EventDispatcher<T> {
+    private readonly element;
+    private readonly type;
+    private readonly options?;
+    private readonly handlersMap;
+    constructor(element: HTMLElement, type: string, options?: EventInit | undefined);
+    dispatch(value: T): void;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+}

package/dist/packages/event/HTMLElementEventDispatcher.js

@@ -0,0 +1,23 @@
+export class HTMLElementEventDispatcher {
+    constructor(element, type, options) {
+        this.element = element;
+        this.type = type;
+        this.options = options;
+        this.handlersMap = new Map();
+    }
+    dispatch(value) {
+        this.element.dispatchEvent(new CustomEvent(this.type, { detail: value, ...this.options }));
+    }
+    subscribe(handler) {
+        const nativeHandler = (event) => handler(event.detail);
+        this.element.addEventListener(this.type, nativeHandler);
+        this.handlersMap.set(handler, nativeHandler);
+    }
+    unsubscribe(handler) {
+        const nativeHandler = this.handlersMap.get(handler);
+        if (nativeHandler) {
+            this.element.removeEventListener(this.type, nativeHandler);
+        }
+        this.handlersMap.delete(handler);
+    }
+}

package/dist/packages/event/PureEventDispatcher.d.ts

@@ -0,0 +1,6 @@
+export declare class PureEventDispatcher<T = void> implements EventDispatcher<T> {
+    private readonly handlers;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+    dispatch(data: T): void;
+}

package/dist/packages/event/PureEventDispatcher.js

@@ -0,0 +1,16 @@
+export class PureEventDispatcher {
+    constructor() {
+        this.handlers = new Set();
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+    }
+    unsubscribe(handler) {
+        this.handlers.delete(handler);
+    }
+    dispatch(data) {
+        for (const handler of this.handlers) {
+            handler(data);
+        }
+    }
+}

package/dist/packages/event/event.d.ts

@@ -0,0 +1 @@
+export declare function event(options?: EventInit): (prototype: unknown, propertyKey?: string) => void;

package/dist/packages/event/event.js

@@ -0,0 +1,20 @@
+import { HTMLElementEventDispatcher } from './HTMLElementEventDispatcher';
+import { PureEventDispatcher } from './PureEventDispatcher';
+export function event(options) {
+    return (prototype, propertyKey) => {
+        if (propertyKey === undefined) {
+            return;
+        }
+        const eventFieldName = `$${propertyKey}Event$`;
+        Object.defineProperty(prototype, propertyKey, {
+            get() {
+                if (!this[eventFieldName]) {
+                    this[eventFieldName] = this instanceof HTMLElement
+                        ? new HTMLElementEventDispatcher(this, propertyKey, options)
+                        : new PureEventDispatcher();
+                }
+                return this[eventFieldName];
+            }
+        });
+    };
+}

package/dist/packages/event/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PureEventDispatcher';
+export * from './HTMLElementEventDispatcher';
+export * from './event';

package/dist/packages/event/index.js

@@ -0,0 +1,3 @@
+export * from './PureEventDispatcher';
+export * from './HTMLElementEventDispatcher';
+export * from './event';

package/dist/packages/eventListener/eventListener.d.ts

@@ -0,0 +1,13 @@
+import { LitElement } from 'lit';
+declare type ShorthandEventListenerDecoratorOptions = [type: string, options?: EventListenerOptions | boolean];
+declare type FullEventListenerDecoratorOptions = [
+    {
+        type: string;
+        target?: EventTarget | ((this: any) => EventTarget);
+        options?: EventListenerOptions | boolean;
+    }
+];
+declare type EventListenerDecoratorOptions = ShorthandEventListenerDecoratorOptions | FullEventListenerDecoratorOptions;
+export declare const eventListener: (...eventListenerOptions: EventListenerDecoratorOptions) => (prototype: LitElement, propertyKey: string, descriptor?: PropertyDescriptor) => void;
+export declare const extractEventHandler: <TEvent extends Event = Event>(eventListener: EventListenerOrEventListenerObject) => (event: TEvent) => void;
+export {};