@lottiefiles/dotlottie-wc/dist/index-DzwdSRLm.d.ts

Web component wrapper around the dotlottie-web library

//#region ../../node_modules/.pnpm/@lit+reactive-element@2.1.0/node_modules/@lit/reactive-element/development/css-tag.d.ts
/**
 * A CSSResult or native CSSStyleSheet.
 *
 * In browsers that support constructible CSS style sheets, CSSStyleSheet
 * object can be used for styling along side CSSResult from the `css`
 * template tag.
 */
type CSSResultOrNative = CSSResult | CSSStyleSheet;
type CSSResultArray = Array<CSSResultOrNative | CSSResultArray>;
/**
 * A single CSSResult, CSSStyleSheet, or an array or nested arrays of those.
 */
type CSSResultGroup = CSSResultOrNative | CSSResultArray;
/**
 * A container for a string of CSS text, that may be used to create a CSSStyleSheet.
 *
 * CSSResult is the return value of `css`-tagged template literals and
 * `unsafeCSS()`. In order to ensure that CSSResults are only created via the
 * `css` tag and `unsafeCSS()`, CSSResult cannot be constructed directly.
 */
declare class CSSResult {
  ['_$cssResult$']: boolean;
  readonly cssText: string;
  private _styleSheet?;
  private _strings;
  private constructor();
  get styleSheet(): CSSStyleSheet | undefined;
  toString(): string;
}
//#endregion
//#region ../../node_modules/.pnpm/@lit+reactive-element@2.1.0/node_modules/@lit/reactive-element/development/reactive-controller.d.ts
/**
 * @license
 * Copyright 2021 Google LLC
 * SPDX-License-Identifier: BSD-3-Clause
 */
/**
 * An object that can host Reactive Controllers and call their lifecycle
 * callbacks.
 */
interface ReactiveControllerHost {
  /**
   * Adds a controller to the host, which sets up the controller's lifecycle
   * methods to be called with the host's lifecycle.
   */
  addController(controller: ReactiveController): void;
  /**
   * Removes a controller from the host.
   */
  removeController(controller: ReactiveController): void;
  /**
   * Requests a host update which is processed asynchronously. The update can
   * be waited on via the `updateComplete` property.
   */
  requestUpdate(): void;
  /**
   * Returns a Promise that resolves when the host has completed updating.
   * The Promise value is a boolean that is `true` if the element completed the
   * update without triggering another update. The Promise result is `false` if
   * a property was set inside `updated()`. If the Promise is rejected, an
   * exception was thrown during the update.
   *
   * @return A promise of a boolean that indicates if the update resolved
   *     without triggering another update.
   */
  readonly updateComplete: Promise<boolean>;
}
/**
 * A Reactive Controller is an object that enables sub-component code
 * organization and reuse by aggregating the state, behavior, and lifecycle
 * hooks related to a single feature.
 *
 * Controllers are added to a host component, or other object that implements
 * the `ReactiveControllerHost` interface, via the `addController()` method.
 * They can hook their host components's lifecycle by implementing one or more
 * of the lifecycle callbacks, or initiate an update of the host component by
 * calling `requestUpdate()` on the host.
 */
interface ReactiveController {
  /**
   * Called when the host is connected to the component tree. For custom
   * element hosts, this corresponds to the `connectedCallback()` lifecycle,
   * which is only called when the component is connected to the document.
   */
  hostConnected?(): void;
  /**
   * Called when the host is disconnected from the component tree. For custom
   * element hosts, this corresponds to the `disconnectedCallback()` lifecycle,
   * which is called the host or an ancestor component is disconnected from the
   * document.
   */
  hostDisconnected?(): void;
  /**
   * Called during the client-side host update, just before the host calls
   * its own update.
   *
   * Code in `update()` can depend on the DOM as it is not called in
   * server-side rendering.
   */
  hostUpdate?(): void;
  /**
   * Called after a host update, just before the host calls firstUpdated and
   * updated. It is not called in server-side rendering.
   *
   */
  hostUpdated?(): void;
}
//#endregion
//#region ../../node_modules/.pnpm/@lit+reactive-element@2.1.0/node_modules/@lit/reactive-element/development/reactive-element.d.ts
/**
 * Converts property values to and from attribute values.
 */
interface ComplexAttributeConverter<Type = unknown, TypeHint = unknown> {
  /**
   * Called to convert an attribute value to a property
   * value.
   */
  fromAttribute?(value: string | null, type?: TypeHint): Type;
  /**
   * Called to convert a property value to an attribute
   * value.
   *
   * It returns unknown instead of string, to be compatible with
   * https://github.com/WICG/trusted-types (and similar efforts).
   */
  toAttribute?(value: Type, type?: TypeHint): unknown;
}
type AttributeConverter<Type = unknown, TypeHint = unknown> = ComplexAttributeConverter<Type> | ((value: string | null, type?: TypeHint) => Type);
/**
 * Defines options for a property accessor.
 */
interface PropertyDeclaration<Type = unknown, TypeHint = unknown> {
  /**
   * When set to `true`, indicates the property is internal private state. The
   * property should not be set by users. When using TypeScript, this property
   * should be marked as `private` or `protected`, and it is also a common
   * practice to use a leading `_` in the name. The property is not added to
   * `observedAttributes`.
   */
  readonly state?: boolean;
  /**
   * Indicates how and whether the property becomes an observed attribute.
   * If the value is `false`, the property is not added to `observedAttributes`.
   * If true or absent, the lowercased property name is observed (e.g. `fooBar`
   * becomes `foobar`). If a string, the string value is observed (e.g
   * `attribute: 'foo-bar'`).
   */
  readonly attribute?: boolean | string;
  /**
   * Indicates the type of the property. This is used only as a hint for the
   * `converter` to determine how to convert the attribute
   * to/from a property.
   */
  readonly type?: TypeHint;
  /**
   * Indicates how to convert the attribute to/from a property. If this value
   * is a function, it is used to convert the attribute value a the property
   * value. If it's an object, it can have keys for `fromAttribute` and
   * `toAttribute`. If no `toAttribute` function is provided and
   * `reflect` is set to `true`, the property value is set directly to the
   * attribute. A default `converter` is used if none is provided; it supports
   * `Boolean`, `String`, `Number`, `Object`, and `Array`. Note,
   * when a property changes and the converter is used to update the attribute,
   * the property is never updated again as a result of the attribute changing,
   * and vice versa.
   */
  readonly converter?: AttributeConverter<Type, TypeHint>;
  /**
   * Indicates if the property should reflect to an attribute.
   * If `true`, when the property is set, the attribute is set using the
   * attribute name determined according to the rules for the `attribute`
   * property option and the value of the property converted using the rules
   * from the `converter` property option.
   */
  readonly reflect?: boolean;
  /**
   * A function that indicates if a property should be considered changed when
   * it is set. The function should take the `newValue` and `oldValue` and
   * return `true` if an update should be requested.
   */
  hasChanged?(value: Type, oldValue: Type): boolean;
  /**
   * Indicates whether an accessor will be created for this property. By
   * default, an accessor will be generated for this property that requests an
   * update when set. If this flag is `true`, no accessor will be created, and
   * it will be the user's responsibility to call
   * `this.requestUpdate(propertyName, oldValue)` to request an update when
   * the property changes.
   */
  readonly noAccessor?: boolean;
  /**
   * When `true`, uses the initial value of the property as the default value,
   * which changes how attributes are handled:
   *  - The initial value does *not* reflect, even if the `reflect` option is `true`.
   *    Subsequent changes to the property will reflect, even if they are equal to the
   *     default value.
   *  - When the attribute is removed, the property is set to the default value
   *  - The initial value will not trigger an old value in the `changedProperties` map
   *    argument to update lifecycle methods.
   *
   * When set, properties must be initialized, either with a field initializer, or an
   * assignment in the constructor. Not initializing the property may lead to
   * improper handling of subsequent property assignments.
   *
   * While this behavior is opt-in, most properties that reflect to attributes should
   * use `useDefault: true` so that their initial values do not reflect.
   */
  useDefault?: boolean;
}
/**
 * Map of properties to PropertyDeclaration options. For each property an
 * accessor is made, and the property is processed according to the
 * PropertyDeclaration options.
 */
interface PropertyDeclarations {
  readonly [key: string]: PropertyDeclaration;
}
type PropertyDeclarationMap = Map<PropertyKey, PropertyDeclaration>;
/**
 * A Map of property keys to values.
 *
 * Takes an optional type parameter T, which when specified as a non-any,
 * non-unknown type, will make the Map more strongly-typed, associating the map
 * keys with their corresponding value type on T.
 *
 * Use `PropertyValues<this>` when overriding ReactiveElement.update() and
 * other lifecycle methods in order to get stronger type-checking on keys
 * and values.
 */
type PropertyValues<T = any> = T extends object ? PropertyValueMap<T> : Map<PropertyKey, unknown>;
/**
 * Do not use, instead prefer {@linkcode PropertyValues}.
 */
interface PropertyValueMap<T> extends Map<PropertyKey, unknown> {
  get<K extends keyof T>(k: K): T[K] | undefined;
  set<K extends keyof T>(key: K, value: T[K]): this;
  has<K extends keyof T>(k: K): boolean;
  delete<K extends keyof T>(k: K): boolean;
}
/**
 * A string representing one of the supported dev mode warning categories.
 */
type WarningKind = 'change-in-update' | 'migration' | 'async-perform-update';
type Initializer = (element: ReactiveElement) => void;
declare global {
  interface SymbolConstructor {
    readonly metadata: unique symbol;
  }
}
declare global {
  var litPropertyMetadata: WeakMap<object, Map<PropertyKey, PropertyDeclaration>>;
}
/**
 * Base element class which manages element properties and attributes. When
 * properties change, the `update` method is asynchronously called. This method
 * should be supplied by subclasses to render updates as desired.
 * @noInheritDoc
 */
declare abstract class ReactiveElement extends HTMLElement implements ReactiveControllerHost {
  /**
   * Read or set all the enabled warning categories for this class.
   *
   * This property is only used in development builds.
   *
   * @nocollapse
   * @category dev-mode
   */
  static enabledWarnings?: WarningKind[];
  /**
   * Enable the given warning category for this class.
   *
   * This method only exists in development builds, so it should be accessed
   * with a guard like:
   *
   * ```ts
   * // Enable for all ReactiveElement subclasses
   * ReactiveElement.enableWarning?.('migration');
   *
   * // Enable for only MyElement and subclasses
   * MyElement.enableWarning?.('migration');
   * ```
   *
   * @nocollapse
   * @category dev-mode
   */
  static enableWarning?: (warningKind: WarningKind) => void;
  /**
   * Disable the given warning category for this class.
   *
   * This method only exists in development builds, so it should be accessed
   * with a guard like:
   *
   * ```ts
   * // Disable for all ReactiveElement subclasses
   * ReactiveElement.disableWarning?.('migration');
   *
   * // Disable for only MyElement and subclasses
   * MyElement.disableWarning?.('migration');
   * ```
   *
   * @nocollapse
   * @category dev-mode
   */
  static disableWarning?: (warningKind: WarningKind) => void;
  /**
   * Adds an initializer function to the class that is called during instance
   * construction.
   *
   * This is useful for code that runs against a `ReactiveElement`
   * subclass, such as a decorator, that needs to do work for each
   * instance, such as setting up a `ReactiveController`.
   *
   * ```ts
   * const myDecorator = (target: typeof ReactiveElement, key: string) => {
   *   target.addInitializer((instance: ReactiveElement) => {
   *     // This is run during construction of the element
   *     new MyController(instance);
   *   });
   * }
   * ```
   *
   * Decorating a field will then cause each instance to run an initializer
   * that adds a controller:
   *
   * ```ts
   * class MyElement extends LitElement {
   *   @myDecorator foo;
   * }
   * ```
   *
   * Initializers are stored per-constructor. Adding an initializer to a
   * subclass does not add it to a superclass. Since initializers are run in
   * constructors, initializers will run in order of the class hierarchy,
   * starting with superclasses and progressing to the instance's class.
   *
   * @nocollapse
   */
  static addInitializer(initializer: Initializer): void;
  static _initializers?: Initializer[];
  /**
   * Maps attribute names to properties; for example `foobar` attribute to
   * `fooBar` property. Created lazily on user subclasses when finalizing the
   * class.
   * @nocollapse
   */
  private static __attributeToPropertyMap;
  /**
   * Marks class as having been finalized, which includes creating properties
   * from `static properties`, but does *not* include all properties created
   * from decorators.
   * @nocollapse
   */
  protected static finalized: true | undefined;
  /**
   * Memoized list of all element properties, including any superclass
   * properties. Created lazily on user subclasses when finalizing the class.
   *
   * @nocollapse
   * @category properties
   */
  static elementProperties: PropertyDeclarationMap;
  /**
   * User-supplied object that maps property names to `PropertyDeclaration`
   * objects containing options for configuring reactive properties. When
   * a reactive property is set the element will update and render.
   *
   * By default properties are public fields, and as such, they should be
   * considered as primarily settable by element users, either via attribute or
   * the property itself.
   *
   * Generally, properties that are changed by the element should be private or
   * protected fields and should use the `state: true` option. Properties
   * marked as `state` do not reflect from the corresponding attribute
   *
   * However, sometimes element code does need to set a public property. This
   * should typically only be done in response to user interaction, and an event
   * should be fired informing the user; for example, a checkbox sets its
   * `checked` property when clicked and fires a `changed` event. Mutating
   * public properties should typically not be done for non-primitive (object or
   * array) properties. In other cases when an element needs to manage state, a
   * private property set with the `state: true` option should be used. When
   * needed, state properties can be initialized via public properties to
   * facilitate complex interactions.
   * @nocollapse
   * @category properties
   */
  static properties: PropertyDeclarations;
  /**
   * Memoized list of all element styles.
   * Created lazily on user subclasses when finalizing the class.
   * @nocollapse
   * @category styles
   */
  static elementStyles: Array<CSSResultOrNative>;
  /**
   * Array of styles to apply to the element. The styles should be defined
   * using the {@linkcode css} tag function, via constructible stylesheets, or
   * imported from native CSS module scripts.
   *
   * Note on Content Security Policy:
   *
   * Element styles are implemented with `<style>` tags when the browser doesn't
   * support adopted StyleSheets. To use such `<style>` tags with the style-src
   * CSP directive, the style-src value must either include 'unsafe-inline' or
   * `nonce-<base64-value>` with `<base64-value>` replaced be a server-generated
   * nonce.
   *
   * To provide a nonce to use on generated `<style>` elements, set
   * `window.litNonce` to a server-generated nonce in your page's HTML, before
   * loading application code:
   *
   * ```html
   * <script>
   *   // Generated and unique per request:
   *   window.litNonce = 'a1b2c3d4';
   * </script>
   * ```
   * @nocollapse
   * @category styles
   */
  static styles?: CSSResultGroup;
  /**
   * Returns a list of attributes corresponding to the registered properties.
   * @nocollapse
   * @category attributes
   */
  static get observedAttributes(): string[];
  private __instanceProperties?;
  /**
   * Creates a property accessor on the element prototype if one does not exist
   * and stores a {@linkcode PropertyDeclaration} for the property with the
   * given options. The property setter calls the property's `hasChanged`
   * property option or uses a strict identity check to determine whether or not
   * to request an update.
   *
   * This method may be overridden to customize properties; however,
   * when doing so, it's important to call `super.createProperty` to ensure
   * the property is setup correctly. This method calls
   * `getPropertyDescriptor` internally to get a descriptor to install.
   * To customize what properties do when they are get or set, override
   * `getPropertyDescriptor`. To customize the options for a property,
   * implement `createProperty` like this:
   *
   * ```ts
   * static createProperty(name, options) {
   *   options = Object.assign(options, {myOption: true});
   *   super.createProperty(name, options);
   * }
   * ```
   *
   * @nocollapse
   * @category properties
   */
  static createProperty(name: PropertyKey, options?: PropertyDeclaration): void;
  /**
   * Returns a property descriptor to be defined on the given named property.
   * If no descriptor is returned, the property will not become an accessor.
   * For example,
   *
   * ```ts
   * class MyElement extends LitElement {
   *   static getPropertyDescriptor(name, key, options) {
   *     const defaultDescriptor =
   *         super.getPropertyDescriptor(name, key, options);
   *     const setter = defaultDescriptor.set;
   *     return {
   *       get: defaultDescriptor.get,
   *       set(value) {
   *         setter.call(this, value);
   *         // custom action.
   *       },
   *       configurable: true,
   *       enumerable: true
   *     }
   *   }
   * }
   * ```
   *
   * @nocollapse
   * @category properties
   */
  protected static getPropertyDescriptor(name: PropertyKey, key: string | symbol, options: PropertyDeclaration): PropertyDescriptor | undefined;
  /**
   * Returns the property options associated with the given property.
   * These options are defined with a `PropertyDeclaration` via the `properties`
   * object or the `@property` decorator and are registered in
   * `createProperty(...)`.
   *
   * Note, this method should be considered "final" and not overridden. To
   * customize the options for a given property, override
   * {@linkcode createProperty}.
   *
   * @nocollapse
   * @final
   * @category properties
   */
  static getPropertyOptions(name: PropertyKey): PropertyDeclaration<unknown, unknown>;
  static [Symbol.metadata]: object & Record<PropertyKey, unknown>;
  /**
   * Initializes static own properties of the class used in bookkeeping
   * for element properties, initializers, etc.
   *
   * Can be called multiple times by code that needs to ensure these
   * properties exist before using them.
   *
   * This method ensures the superclass is finalized so that inherited
   * property metadata can be copied down.
   * @nocollapse
   */
  private static __prepare;
  /**
   * Finishes setting up the class so that it's ready to be registered
   * as a custom element and instantiated.
   *
   * This method is called by the ReactiveElement.observedAttributes getter.
   * If you override the observedAttributes getter, you must either call
   * super.observedAttributes to trigger finalization, or call finalize()
   * yourself.
   *
   * @nocollapse
   */
  protected static finalize(): void;
  /**
   * Options used when calling `attachShadow`. Set this property to customize
   * the options for the shadowRoot; for example, to create a closed
   * shadowRoot: `{mode: 'closed'}`.
   *
   * Note, these options are used in `createRenderRoot`. If this method
   * is customized, options should be respected if possible.
   * @nocollapse
   * @category rendering
   */
  static shadowRootOptions: ShadowRootInit;
  /**
   * Takes the styles the user supplied via the `static styles` property and
   * returns the array of styles to apply to the element.
   * Override this method to integrate into a style management system.
   *
   * Styles are deduplicated preserving the _last_ instance in the list. This
   * is a performance optimization to avoid duplicated styles that can occur
   * especially when composing via subclassing. The last item is kept to try
   * to preserve the cascade order with the assumption that it's most important
   * that last added styles override previous styles.
   *
   * @nocollapse
   * @category styles
   */
  protected static finalizeStyles(styles?: CSSResultGroup): Array<CSSResultOrNative>;
  /**
   * Node or ShadowRoot into which element DOM should be rendered. Defaults
   * to an open shadowRoot.
   * @category rendering
   */
  readonly renderRoot: HTMLElement | DocumentFragment;
  /**
   * Returns the property name for the given attribute `name`.
   * @nocollapse
   */
  private static __attributeNameForProperty;
  private __updatePromise;
  /**
   * True if there is a pending update as a result of calling `requestUpdate()`.
   * Should only be read.
   * @category updates
   */
  isUpdatePending: boolean;
  /**
   * Is set to `true` after the first update. The element code cannot assume
   * that `renderRoot` exists before the element `hasUpdated`.
   * @category updates
   */
  hasUpdated: boolean;
  /**
   * Records property default values when the
   * `useDefault` option is used.
   */
  private __defaultValues?;
  /**
   * Properties that should be reflected when updated.
   */
  private __reflectingProperties?;
  /**
   * Name of currently reflecting property
   */
  private __reflectingProperty;
  /**
   * Set of controllers.
   */
  private __controllers?;
  constructor();
  /**
   * Internal only override point for customizing work done when elements
   * are constructed.
   */
  private __initialize;
  /**
   * Registers a `ReactiveController` to participate in the element's reactive
   * update cycle. The element automatically calls into any registered
   * controllers during its lifecycle callbacks.
   *
   * If the element is connected when `addController()` is called, the
   * controller's `hostConnected()` callback will be immediately called.
   * @category controllers
   */
  addController(controller: ReactiveController): void;
  /**
   * Removes a `ReactiveController` from the element.
   * @category controllers
   */
  removeController(controller: ReactiveController): void;
  /**
   * Fixes any properties set on the instance before upgrade time.
   * Otherwise these would shadow the accessor and break these properties.
   * The properties are stored in a Map which is played back after the
   * constructor runs.
   */
  private __saveInstanceProperties;
  /**
   * Returns the node into which the element should render and by default
   * creates and returns an open shadowRoot. Implement to customize where the
   * element's DOM is rendered. For example, to render into the element's
   * childNodes, return `this`.
   *
   * @return Returns a node into which to render.
   * @category rendering
   */
  protected createRenderRoot(): HTMLElement | DocumentFragment;
  /**
   * On first connection, creates the element's renderRoot, sets up
   * element styling, and enables updating.
   * @category lifecycle
   */
  connectedCallback(): void;
  /**
   * Note, this method should be considered final and not overridden. It is
   * overridden on the element instance with a function that triggers the first
   * update.
   * @category updates
   */
  protected enableUpdating(_requestedUpdate: boolean): void;
  /**
   * Allows for `super.disconnectedCallback()` in extensions while
   * reserving the possibility of making non-breaking feature additions
   * when disconnecting at some point in the future.
   * @category lifecycle
   */
  disconnectedCallback(): void;
  /**
   * Synchronizes property values when attributes change.
   *
   * Specifically, when an attribute is set, the corresponding property is set.
   * You should rarely need to implement this callback. If this method is
   * overridden, `super.attributeChangedCallback(name, _old, value)` must be
   * called.
   *
   * See [responding to attribute changes](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#responding_to_attribute_changes)
   * on MDN for more information about the `attributeChangedCallback`.
   * @category attributes
   */
  attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
  private __propertyToAttribute;
  /**
   * Requests an update which is processed asynchronously. This should be called
   * when an element should update based on some state not triggered by setting
   * a reactive property. In this case, pass no arguments. It should also be
   * called when manually implementing a property setter. In this case, pass the
   * property `name` and `oldValue` to ensure that any configured property
   * options are honored.
   *
   * @param name name of requesting property
   * @param oldValue old value of requesting property
   * @param options property options to use instead of the previously
   *     configured options
   * @category updates
   */
  requestUpdate(name?: PropertyKey, oldValue?: unknown, options?: PropertyDeclaration): void;
  /**
   * Sets up the element to asynchronously update.
   */
  private __enqueueUpdate;
  /**
   * Schedules an element update. You can override this method to change the
   * timing of updates by returning a Promise. The update will await the
   * returned Promise, and you should resolve the Promise to allow the update
   * to proceed. If this method is overridden, `super.scheduleUpdate()`
   * must be called.
   *
   * For instance, to schedule updates to occur just before the next frame:
   *
   * ```ts
   * override protected async scheduleUpdate(): Promise<unknown> {
   *   await new Promise((resolve) => requestAnimationFrame(() => resolve()));
   *   super.scheduleUpdate();
   * }
   * ```
   * @category updates
   */
  protected scheduleUpdate(): void | Promise<unknown>;
  /**
   * Performs an element update. Note, if an exception is thrown during the
   * update, `firstUpdated` and `updated` will not be called.
   *
   * Call `performUpdate()` to immediately process a pending update. This should
   * generally not be needed, but it can be done in rare cases when you need to
   * update synchronously.
   *
   * @category updates
   */
  protected performUpdate(): void;
  /**
   * Invoked before `update()` to compute values needed during the update.
   *
   * Implement `willUpdate` to compute property values that depend on other
   * properties and are used in the rest of the update process.
   *
   * ```ts
   * willUpdate(changedProperties) {
   *   // only need to check changed properties for an expensive computation.
   *   if (changedProperties.has('firstName') || changedProperties.has('lastName')) {
   *     this.sha = computeSHA(`${this.firstName} ${this.lastName}`);
   *   }
   * }
   *
   * render() {
   *   return html`SHA: ${this.sha}`;
   * }
   * ```
   *
   * @category updates
   */
  protected willUpdate(_changedProperties: PropertyValues): void;
  private __markUpdated;
  /**
   * Returns a Promise that resolves when the element has completed updating.
   * The Promise value is a boolean that is `true` if the element completed the
   * update without triggering another update. The Promise result is `false` if
   * a property was set inside `updated()`. If the Promise is rejected, an
   * exception was thrown during the update.
   *
   * To await additional asynchronous work, override the `getUpdateComplete`
   * method. For example, it is sometimes useful to await a rendered element
   * before fulfilling this Promise. To do this, first await
   * `super.getUpdateComplete()`, then any subsequent state.
   *
   * @return A promise of a boolean that resolves to true if the update completed
   *     without triggering another update.
   * @category updates
   */
  get updateComplete(): Promise<boolean>;
  /**
   * Override point for the `updateComplete` promise.
   *
   * It is not safe to override the `updateComplete` getter directly due to a
   * limitation in TypeScript which means it is not possible to call a
   * superclass getter (e.g. `super.updateComplete.then(...)`) when the target
   * language is ES5 (https://github.com/microsoft/TypeScript/issues/338).
   * This method should be overridden instead. For example:
   *
   * ```ts
   * class MyElement extends LitElement {
   *   override async getUpdateComplete() {
   *     const result = await super.getUpdateComplete();
   *     await this._myChild.updateComplete;
   *     return result;
   *   }
   * }
   * ```
   *
   * @return A promise of a boolean that resolves to true if the update completed
   *     without triggering another update.
   * @category updates
   */
  protected getUpdateComplete(): Promise<boolean>;
  /**
   * Controls whether or not `update()` should be called when the element requests
   * an update. By default, this method always returns `true`, but this can be
   * customized to control when to update.
   *
   * @param _changedProperties Map of changed properties with old values
   * @category updates
   */
  protected shouldUpdate(_changedProperties: PropertyValues): boolean;
  /**
   * Updates the element. This method reflects property values to attributes.
   * It can be overridden to render and keep updated element DOM.
   * Setting properties inside this method will *not* trigger
   * another update.
   *
   * @param _changedProperties Map of changed properties with old values
   * @category updates
   */
  protected update(_changedProperties: PropertyValues): void;
  /**
   * Invoked whenever the element is updated. Implement to perform
   * post-updating tasks via DOM APIs, for example, focusing an element.
   *
   * Setting properties inside this method will trigger the element to update
   * again after this update cycle completes.
   *
   * @param _changedProperties Map of changed properties with old values
   * @category updates
   */
  protected updated(_changedProperties: PropertyValues): void;
  /**
   * Invoked when the element is first updated. Implement to perform one time
   * work on the element after update.
   *
   * ```ts
   * firstUpdated() {
   *   this.renderRoot.getElementById('my-text-area').focus();
   * }
   * ```
   *
   * Setting properties inside this method will trigger the element to update
   * again after this update cycle completes.
   *
   * @param _changedProperties Map of changed properties with old values
   * @category updates
   */
  protected firstUpdated(_changedProperties: PropertyValues): void;
}
//#endregion
//#region ../../node_modules/.pnpm/lit-html@3.3.0/node_modules/lit-html/development/lit-html.d.ts
/** 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;
/**
 * 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<T extends ResultType = ResultType> = {
  ['_$litType$']: T;
  strings: TemplateStringsArray;
  values: unknown[];
};
/**
 * The return type of the template tag functions, {@linkcode html} and
 * {@linkcode svg}.
 *
 * 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.
 *
 * In Lit 4, this type will be an alias of
 * MaybeCompiledTemplateResult, so that code will get type errors if it assumes
 * that Lit templates are not compiled. When deliberately working with only
 * one, use either {@linkcode CompiledTemplateResult} or
 * {@linkcode UncompiledTemplateResult} explicitly.
 */
type TemplateResult<T extends ResultType = ResultType> = UncompiledTemplateResult<T>;
/**
 * 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;
}
//#endregion
//#region ../../node_modules/.pnpm/lit-element@4.2.0/node_modules/lit-element/development/lit-element.d.ts
/**
 * Base element class that manages element properties and attributes, and
 * renders a lit-html template.
 *
 * To define a component, subclass `LitElement` and implement a
 * `render` method to provide the component's template. Define properties
 * using the {@linkcode LitElement.properties properties} property or the
 * {@linkcode property} decorator.
 */
declare class LitElement extends ReactiveElement {
  static ['_$litElement$']: boolean;
  /**
   * @category rendering
   */
  readonly renderOptions: RenderOptions;
  private __childPart;
  /**
   * @category rendering
   */
  protected createRenderRoot(): HTMLElement | DocumentFragment;
  /**
   * Updates the element. This method reflects property values to attributes
   * and calls `render` to render DOM via lit-html. Setting properties inside
   * this method will *not* trigger another update.
   * @param changedProperties Map of changed properties with old values
   * @category updates
   */
  protected update(changedProperties: PropertyValues): void;
  /**
   * Invoked when the component is added to the document's DOM.
   *
   * In `connectedCallback()` you should setup tasks that should only occur when
   * the element is connected to the document. The most common of these is
   * adding event listeners to nodes external to the element, like a keydown
   * event handler added to the window.
   *
   * ```ts
   * connectedCallback() {
   *   super.connectedCallback();
   *   addEventListener('keydown', this._handleKeydown);
   * }
   * ```
   *
   * Typically, anything done in `connectedCallback()` should be undone when the
   * element is disconnected, in `disconnectedCallback()`.
   *
   * @category lifecycle
   */
  connectedCallback(): void;
  /**
   * Invoked when the component is removed from the document's DOM.
   *
   * This callback is the main signal to the element that it may no longer be
   * used. `disconnectedCallback()` should ensure that nothing is holding a
   * reference to the element (such as event listeners added to nodes external
   * to the element), so that it is free to be garbage collected.
   *
   * ```ts
   * disconnectedCallback() {
   *   super.disconnectedCallback();
   *   window.removeEventListener('keydown', this._handleKeydown);
   * }
   * ```
   *
   * An element may be re-connected after being disconnected.
   *
   * @category lifecycle
   */
  disconnectedCallback(): void;
  /**
   * Invoked on each update to perform rendering tasks. This method may return
   * any value renderable by lit-html's `ChildPart` - typically a
   * `TemplateResult`. Setting properties inside this method will *not* trigger
   * the element to update.
   * @category rendering
   */
  protected render(): unknown;
}
//#endregion
//#region ../web/dist/index.d.ts
declare var ae: {
  new (e: any): {
    _canvas: any;
    _eventManager: {
      addEventListener(e: any, t: any): void;
      removeEventListener(e: any, t: any): void;
      dispatch(e: any): void;
      removeAllEventListeners(): void;
    };
    _frameManager: {
      _strategy: {
        requestAnimationFrame(e: any): number;
        cancelAnimationFrame(e: any): void;
      } | {
        requestAnimationFrame(e: any): number | undefined;
        _lastHandleId: number | undefined;
        _lastImmediate: any;
        cancelAnimationFrame(e: any): void;
      };
      requestAnimationFrame(e: any): number | undefined;
      cancelAnimationFrame(e: any): void;
    };
    _boundAnimationLoop: (e: any) => void;
    _renderConfig: any;
    _dotLottieCore: {
      __destroy_into_raw(): number;
      __wbg_ptr: number;
      free(): void;
      clear_slot(e: any): boolean;
      is_playing(): boolean;
      is_stopped(): boolean;
      layout_fit(): string;
      loop_count(): number;
      poll_event(): any;
      reset_slot(e: any): boolean;
      set_layout(e: any, t: any, n: any): boolean;
      set_marker(e: any): void;
      clear_slots(): boolean;
      is_complete(): boolean;
      is_tweening(): boolean;
      reset_slots(): boolean;
      reset_theme(): boolean;
      segment_end(): any;
      set_quality(e: any): boolean;
      set_segment(e: any, t: any): boolean;
      animation_id(): string | undefined;
      audio_volume(): any;
      background_a(): any;
      background_b(): any;
      background_g(): any;
      background_r(): any;
      clear_marker(): void;
      emit_on_loop(): void;
      get_slot_ids(): any;
      get_slot_str(e: any): string | undefined;
      marker_names(): any;
      set_autoplay(e: any): void;
      set_slot_str(e: any, t: any): boolean;
      set_viewport(e: any, t: any, n: any, r: any): boolean;
      total_frames(): any;
      clear_segment(): boolean;
      current_frame(): any;
      get_slot_type(e: any): string | undefined;
      get_slots_str(): string;
      get_transform(): any;
      segment_start(): any;
      set_slots_str(e: any): boolean;
      set_text_slot(e: any, t: any): boolean;
      set_transform(e: any): boolean;
      sm_get_inputs(): any;
      sm_poll_event(): any;
      sm_post_click(e: any, t: any): void;
      animation_size(): any;
      current_marker(): string | undefined;
      layout_align_x(): any;
      layout_align_y(): any;
      load_animation(e: any): boolean;
      loop_animation(): boolean;
      set_background(e: any, t: any, n: any, r: any): boolean;
      set_color_slot(e: any, t: any, n: any, r: any): boolean;
      set_loop_count(e: any): void;
      set_theme_data(e: any): boolean;
      sm_reset_input(e: any): void;
      manifest_string(): string;
      set_scalar_slot(e: any, t: any): boolean;
      set_vector_slot(e: any, t: any, n: any): boolean;
      setup_sw_target(e: any, t: any): boolean;
      get_pixel_buffer(): any;
      set_audio_volume(e: any): void;
      sm_current_state(): string;
      state_machine_id(): string | undefined;
      get_state_machine(e: any): string | undefined;
      set_position_slot(e: any, t: any, n: any): boolean;
      current_loop_count(): number;
      sm_framework_setup(): any;
      sm_post_pointer_up(e: any, t: any): void;
      state_machine_load(e: any): boolean;
      load_dotlottie_data(e: any): boolean;
      sm_get_string_input(e: any): string | undefined;
      sm_set_string_input(e: any, t: any): boolean;
      sm_get_boolean_input(e: any): boolean | undefined;
      sm_get_numeric_input(e: any): any;
      sm_post_pointer_down(e: any, t: any): void;
      sm_post_pointer_exit(e: any, t: any): void;
      sm_post_pointer_move(e: any, t: any): void;
      sm_set_boolean_input(e: any, t: any): boolean;
      sm_set_numeric_input(e: any, t: any): boolean;
      state_machine_unload(): void;
      sm_post_pointer_enter(e: any, t: any): void;
      load_animation_from_id(e: any): boolean;
      sm_poll_internal_event(): any;
      use_frame_interpolation(): boolean;
      reset_current_loop_count(): void;
      sm_override_current_state(e: any, t: any): boolean;
      state_machine_load_from_id(e: any): boolean;
      set_use_frame_interpolation(e: any): void;
      mode(): any;
      play(): boolean;
      stop(): boolean;
      tick(e: any): boolean;
      pause(): boolean;
      speed(): any;
      width(): number;
      height(): number;
      render(): boolean;
      markers(): any;
      sm_fire(e: any): boolean;
      sm_stop(): boolean;
      sm_tick(e: any): boolean;
      autoplay(): boolean;
      duration(): any;
      set_loop(e: any): void;
      set_mode(e: any): void;
      sm_start(e: any, t: any): boolean;
      theme_id(): string | undefined;
      is_loaded(): boolean;
      is_paused(): boolean;
      load_font(e: any, t: any): boolean;
      set_frame(e: any): boolean;
      set_speed(e: any): void;
      set_theme(e: any): boolean;
      sm_status(): string;
    };
    _segment: any[];
    _marker: any;
    _stateMachineId: any;
    _stateMachineConfig: any;
    _pendingLoad: {
      data: any;
      src?: undefined;
    } | {
      src: any;
      data?: undefined;
    };
    _initWasm(): Promise<any>;
    _createCore(): {
      __destroy_into_raw(): number;
      __wbg_ptr: number;
      free(): void;
      clear_slot(e: any): boolean;
      is_playing(): boolean;
      is_stopped(): boolean;
      layout_fit(): string;
      loop_count(): number;
      poll_event(): any;
      reset_slot(e: any): boolean;
      set_layout(e: any, t: any, n: any): boolean;
      set_marker(e: any): void;
      clear_slots(): boolean;
      is_complete(): boolean;
      is_tweening(): boolean;
      reset_slots(): boolean;
      reset_theme(): boolean;
      segment_end(): any;
      set_quality(e: any): boolean;
      set_segment(e: any, t: any): boolean;
      animation_id(): string | undefined;
      audio_volume(): any;
      background_a(): any;
      background_b(): any;
      background_g(): any;
      background_r(): any;
      clear_marker(): void;
      emit_on_loop(): void;
      get_slot_ids(): any;
      get_slot_str(e: any): string | undefined;
      marker_names(): any;
      set_autoplay(e: any): void;
      set_slot_str(e: any, t: any): boolean;
      set_viewport(e: any, t: any, n: any, r: any): boolean;
      total_frames(): any;
      clear_segment(): boolean;
      current_frame(): any;
      get_slot_type(e: any): string | undefined;
      get_slots_str(): string;
      get_transform(): any;
      segment_start(): any;
      set_slots_str(e: any): boolean;
      set_text_slot(e: any, t: any): boolean;
      set_transform(e: any): boolean;
      sm_get_inputs(): any;
      sm_poll_event(): any;
      sm_post_click(e: any, t: any): void;
      animation_size(): any;
      current_marker(): string | undefined;
      layout_align_x(): any;
      layout_align_y(): any;
      load_animation(e: any): boolean;
      loop_animation(): boolean;
      set_background(e: any, t: any, n: any, r: any): boolean;
      set_color_slot(e: any, t: any, n: any, r: any): boolean;
      set_loop_count(e: any): void;
      set_theme_data(e: any): boolean;
      sm_reset_input(e: any): void;
      manifest_string(): string;
      set_scalar_slot(e: any, t: any): boolean;
      set_vector_slot(e: any, t: any, n: any): boolean;
      setup_sw_target(e: any, t: any): boolean;
      get_pixel_buffer(): any;
      set_audio_volume(e: any): void;
      sm_current_state(): string;
      state_machine_id(): string | undefined;
      get_state_machine(e: any): string | undefined;
      set_position_slot(e: any, t: any, n: any): boolean;
      current_loop_count(): number;
      sm_framework_setup(): any;
      sm_post_pointer_up(e: any, t: any): void;
      state_machine_load(e: any): boolean;
      load_dotlottie_data(e: any): boolean;
      sm_get_string_input(e: any): string | undefined;
      sm_set_string_input(e: any, t: any): boolean;
      sm_get_boolean_input(e: any): boolean | undefined;
      sm_get_numeric_input(e: any): any;
      sm_post_pointer_down(e: any, t: any): void;
      sm_post_pointer_exit(e: any, t: any): void;
      sm_post_pointer_move(e: any, t: any): void;
      sm_set_boolean_input(e: any, t: any): boolean;
      sm_set_numeric_input(e: any, t: any): boolean;
      state_machine_unload(): void;
      sm_post_pointer_enter(e: any, t: any): void;
      load_animation_from_id(e: any): boolean;
      sm_poll_internal_event(): any;
      use_frame_interpolation(): boolean;
      reset_current_loop_count(): void;
      sm_override_current_state(e: any, t: any): boolean;
      state_machine_load_from_id(e: any): boolean;
      set_use_frame_interpolation(e: any): void;
      mode(): any;
      play(): boolean;
      stop(): boolean;
      tick(e: any): boolean;
      pause(): boolean;
      speed(): any;
      width(): number;
      height(): number;
      render(): boolean;
      markers(): any;
      sm_fire(e: any): boolean;
      sm_stop(): boolean;
      sm_tick(e: any): boolean;
      autoplay(): boolean;
      duration(): any;
      set_loop(e: any): void;
      set_mode(e: any): void;
      sm_start(e: any, t: any): boolean;
      theme_id(): string | undefined;
      is_loaded(): boolean;
      is_paused(): boolean;
      load_font(e: any, t: any): boolean;
      set_frame(e: any): boolean;
      set_speed(e: any): void;
      set_theme(e: any): boolean;
      sm_status(): string;
    };
    _onCoreCreated(): void;
    _setupTarget(e: any, t: any): boolean;
    _drainPlayerEvents({
      skipFrame: e
    }?: {
      skipFrame?: boolean | undefined;
    }): void;
    _drainSmEvents(): void;
    _isStateMachineRunning: boolean | undefined;
    _dispatchError(e: any): void;
    _fetchData(e: any): Promise<string | ArrayBuffer>;
    _loadFromData(e: any): void;
    _loadFromSrc(e: any): void;
    get buffer(): any;
    get activeAnimationId(): string | undefined;
    get activeThemeId(): string | undefined;
    get layout(): {
      align: any[];
      fit: string;
    } | undefined;
    get marker(): string;
    get manifest(): any;
    get renderConfig(): any;
    get segment(): any[] | undefined;
    get loop(): boolean;
    get mode(): "reverse" | "bounce" | "reverse-bounce" | "forward";
    get isFrozen(): boolean | undefined;
    get isStateMachineRunning(): boolean | undefined;
    get backgroundColor(): any;
    get autoplay(): boolean;
    get useFrameInterpolation(): boolean;
    get speed(): any;
    get isReady(): boolean;
    get isLoaded(): boolean;
    get isPlaying(): boolean;
    get isPaused(): boolean;
    get isStopped(): boolean;
    get currentFrame(): number;
    get loopCount(): number;
    get totalFrames(): any;
    get duration(): number;
    get canvas(): any;
    load(e: any): void;
    _isFrozen: boolean | undefined;
    _draw(): void;
    _context: OffscreenCanvasRenderingContext2D | RenderingContext | null | undefined;
    _bufferMismatchCount: number | undefined;
    _lastExpectedBufferSize: any;
    _cachedImageData: any;
    _cachedImageDataBuffer: any;
    _cachedImageDataByteOffset: any;
    _cleanupCanvas(): void;
    _initializeCanvas(): void;
    _setupRendererOnCanvas(): void;
    _stopAnimationLoop(): void;
    _animationFrameId: number | null | undefined;
    _lastFrameTime: any;
    _startAnimationLoop(): void;
    _animationLoop(e: any): void;
    play(): void;
    pause(): void;
    stop(): void;
    setFrame(e: any): void;
    setSpeed(e: any): void;
    setBackgroundColor(e: any): void;
    _backgroundColor: any;
    setLoop(e: any): void;
    setLoopCount(e: any): void;
    setUseFrameInterpolation(e: any): void;
    addEventListener(e: any, t: any): void;
    removeEventListener(e: any, t: any): void;
    destroy(): void;
    freeze(): void;
    unfreeze(): void;
    resize(): void;
    setCanvas(e: any): void;
    setTransform(e: any): boolean;
    getTransform(): any[] | undefined;
    setSegment(e: any, t: any): void;
    resetSegment(): void;
    setMode(e: any): void;
    setRenderConfig(e: