declare class TrustedHTML { private constructor(); // To prevent instantiting with 'new'. private brand: true; // To prevent structural typing. } /** * @license * Copyright 2017 Google LLC * SPDX-License-Identifier: BSD-3-Clause */ /** * A function which can sanitize values that will be written to a specific kind * of DOM sink. * * See SanitizerFactory. * * @param value The value to sanitize. Will be the actual value passed into * the lit-html template literal, so this could be of any type. * @return The value to write to the DOM. Usually the same as the input value, * unless sanitization is needed. */ type ValueSanitizer = (value: unknown) => unknown; /** TemplateResult types */ declare const HTML_RESULT = 1; declare const SVG_RESULT = 2; declare const MATHML_RESULT = 3; type ResultType = typeof HTML_RESULT | typeof SVG_RESULT | typeof MATHML_RESULT; declare const ATTRIBUTE_PART = 1; declare const CHILD_PART = 2; declare const PROPERTY_PART = 3; declare const BOOLEAN_ATTRIBUTE_PART = 4; declare const EVENT_PART = 5; declare const ELEMENT_PART = 6; declare const COMMENT_PART = 7; /** * The return type of the template tag functions, {@linkcode html} and * {@linkcode svg} when it hasn't been compiled by @lit-labs/compiler. * * A `TemplateResult` object holds all the information about a template * expression required to render it: the template strings, expression values, * and type of template (html or svg). * * `TemplateResult` objects do not create any DOM on their own. To create or * update DOM you need to render the `TemplateResult`. See * [Rendering](https://lit.dev/docs/components/rendering) for more information. * */ type UncompiledTemplateResult = { ['_$litType$']: T; strings: TemplateStringsArray; values: unknown[]; }; /** * Object specifying options for controlling lit-html rendering. Note that * while `render` may be called multiple times on the same `container` (and * `renderBefore` reference node) to efficiently update the rendered content, * only the options passed in during the first render are respected during * the lifetime of renders to that unique `container` + `renderBefore` * combination. */ interface RenderOptions { /** * An object to use as the `this` value for event listeners. It's often * useful to set this to the host component rendering a template. */ host?: object; /** * A DOM node before which to render content in the container. */ renderBefore?: ChildNode | null; /** * Node used for cloning the template (`importNode` will be called on this * node). This controls the `ownerDocument` of the rendered DOM, along with * any inherited context. Defaults to the global `document`. */ creationScope?: { importNode(node: Node, deep?: boolean): Node; }; /** * The initial connected state for the top-level part being rendered. If no * `isConnected` option is set, `AsyncDirective`s will be connected by * default. Set to `false` if the initial render occurs in a disconnected tree * and `AsyncDirective`s should see `isConnected === false` for their initial * render. The `part.setConnected()` method must be used subsequent to initial * render to change the connected state of the part. */ isConnected?: boolean; } interface DirectiveParent { _$parent?: DirectiveParent; _$isConnected: boolean; __directive?: Directive; __directives?: Array; } declare class Template { parts: Array; constructor({ strings, ['_$litType$']: type }: UncompiledTemplateResult, options?: RenderOptions); /** @nocollapse */ static createElement(html: TrustedHTML, _options?: RenderOptions): HTMLTemplateElement; } interface Disconnectable { _$parent?: Disconnectable; _$disconnectableChildren?: Set; _$isConnected: boolean; } /** * An updateable instance of a Template. Holds references to the Parts used to * update the template instance. */ declare class TemplateInstance implements Disconnectable { _$template: Template; _$parts: Array; constructor(template: Template, parent: ChildPart); get parentNode(): Node; get _$isConnected(): boolean; _clone(options: RenderOptions | undefined): Node; _update(values: Array): void; } type AttributeTemplatePart = { readonly type: typeof ATTRIBUTE_PART; readonly index: number; readonly name: string; readonly ctor: typeof AttributePart; readonly strings: ReadonlyArray; }; type ChildTemplatePart = { readonly type: typeof CHILD_PART; readonly index: number; }; type ElementTemplatePart = { readonly type: typeof ELEMENT_PART; readonly index: number; }; type CommentTemplatePart = { readonly type: typeof COMMENT_PART; readonly index: number; }; /** * A TemplatePart represents a dynamic part in a template, before the template * is instantiated. When a template is instantiated Parts are created from * TemplateParts. */ type TemplatePart = ChildTemplatePart | AttributeTemplatePart | ElementTemplatePart | CommentTemplatePart; type Part = ChildPart | AttributePart | PropertyPart | BooleanAttributePart | ElementPart | EventPart; declare class ChildPart implements Disconnectable { readonly type = 2; readonly options: RenderOptions | undefined; _$committedValue: unknown; private _textSanitizer; get _$isConnected(): boolean; constructor(startNode: ChildNode, endNode: ChildNode | null, parent: TemplateInstance | ChildPart | undefined, options: RenderOptions | undefined); /** * The parent node into which the part renders its content. * * A ChildPart's content consists of a range of adjacent child nodes of * `.parentNode`, possibly bordered by 'marker nodes' (`.startNode` and * `.endNode`). * * - If both `.startNode` and `.endNode` are non-null, then the part's content * consists of all siblings between `.startNode` and `.endNode`, exclusively. * * - If `.startNode` is non-null but `.endNode` is null, then the part's * content consists of all siblings following `.startNode`, up to and * including the last child of `.parentNode`. If `.endNode` is non-null, then * `.startNode` will always be non-null. * * - If both `.endNode` and `.startNode` are null, then the part's content * consists of all child nodes of `.parentNode`. */ get parentNode(): Node; /** * The part's leading marker node, if any. See `.parentNode` for more * information. */ get startNode(): Node | null; /** * The part's trailing marker node, if any. See `.parentNode` for more * information. */ get endNode(): Node | null; _$setValue(value: unknown, directiveParent?: DirectiveParent): void; private _insert; private _commitNode; private _commitText; private _commitTemplateResult; private _commitIterable; } declare class AttributePart implements Disconnectable { readonly type: typeof ATTRIBUTE_PART | typeof PROPERTY_PART | typeof BOOLEAN_ATTRIBUTE_PART | typeof EVENT_PART; readonly element: HTMLElement; readonly name: string; readonly options: RenderOptions | undefined; /** * If this attribute part represents an interpolation, this contains the * static strings of the interpolation. For single-value, complete bindings, * this is undefined. */ readonly strings?: ReadonlyArray; protected _sanitizer: ValueSanitizer | undefined; get tagName(): string; get _$isConnected(): boolean; constructor(element: HTMLElement, name: string, strings: ReadonlyArray, parent: Disconnectable, options: RenderOptions | undefined); } declare class PropertyPart extends AttributePart { readonly type = 3; } declare class BooleanAttributePart extends AttributePart { readonly type = 4; } declare class EventPart extends AttributePart { readonly type = 5; constructor(element: HTMLElement, name: string, strings: ReadonlyArray, parent: Disconnectable, options: RenderOptions | undefined); handleEvent(event: Event): void; } declare class ElementPart implements Disconnectable { element: Element; readonly type = 6; _$committedValue: undefined; options: RenderOptions | undefined; constructor(element: Element, parent: Disconnectable, options: RenderOptions | undefined); get _$isConnected(): boolean; _$setValue(value: unknown): void; } /** * @license * Copyright 2017 Google LLC * SPDX-License-Identifier: BSD-3-Clause */ interface DirectiveClass { new (part: PartInfo): Directive; } /** * This utility type extracts the signature of a directive class's render() * method so we can use it for the type of the generated directive function. */ type DirectiveParameters = Parameters; /** * A generated directive function doesn't evaluate the directive, but just * returns a DirectiveResult object that captures the arguments. */ interface DirectiveResult { } declare const PartType: { readonly ATTRIBUTE: 1; readonly CHILD: 2; readonly PROPERTY: 3; readonly BOOLEAN_ATTRIBUTE: 4; readonly EVENT: 5; readonly ELEMENT: 6; }; type PartType = (typeof PartType)[keyof typeof PartType]; interface ChildPartInfo { readonly type: typeof PartType.CHILD; } interface AttributePartInfo { readonly type: typeof PartType.ATTRIBUTE | typeof PartType.PROPERTY | typeof PartType.BOOLEAN_ATTRIBUTE | typeof PartType.EVENT; readonly strings?: ReadonlyArray; readonly name: string; readonly tagName: string; } interface ElementPartInfo { readonly type: typeof PartType.ELEMENT; } /** * Information about the part a directive is bound to. * * This is useful for checking that a directive is attached to a valid part, * such as with directive that can only be used on attribute bindings. */ type PartInfo = ChildPartInfo | AttributePartInfo | ElementPartInfo; /** * Creates a user-facing directive function from a Directive class. This * function has the same parameters as the directive's render() method. */ declare const directive: (c: C) => (...values: DirectiveParameters>) => DirectiveResult; /** * Base class for creating custom directives. Users should extend this class, * implement `render` and/or `update`, and then pass their subclass to * `directive`. */ declare abstract class Directive implements Disconnectable { constructor(_partInfo: PartInfo); get _$isConnected(): boolean; abstract render(...props: Array): unknown; update(_part: Part, props: Array): unknown; } export { AttributePart, type AttributePartInfo, BooleanAttributePart, ChildPart, type ChildPartInfo, Directive, type DirectiveClass, type DirectiveParameters, type DirectiveResult, ElementPart, type ElementPartInfo, EventPart, type Part, type PartInfo, PartType, PropertyPart, directive };