@arcgis/lumina 5.2.0-next.2 → 5.2.0-next.21

package/dist/LitElement.d.ts

@@ -1,17 +1,9 @@
-import { CSSResultGroup, CSSResultOrNative, PropertyValues, ReactiveController, LitElement as OriginalLitElement } from 'lit';
-import { Runtime } from './makeRuntime.ts';
-import { ProxyComponent } from './lazyLoad.ts';
-import { ToElement } from './jsx/types.ts';
-import { BaseController, LuminaPropertyDeclaration } from './controllers/types.ts';
-import { ControllerManager } from './controllers/ControllerManager.ts';
-import { Controller } from './controllers/Controller.ts';
-import { FormAssociatedEvents } from './formAssociatedUtils.ts';
-type ComponentLifecycle = {
-    connectedCallback?: () => void;
-    disconnectedCallback?: () => void;
-    load?: () => Promise<void> | void;
-    loaded?: () => void;
-};
+import type { ReactiveController, LitElement as OriginalLitElement } from "lit";
+import type { ToElement } from "./jsx/types.js";
+import type { BaseController } from "./controllers/types.js";
+import type { ControllerManager } from "./controllers/ControllerManager.js";
+import type { FormAssociatedEvents } from "./formAssociatedUtils.js";
+
 /**
  * Base Lit class that should be used by all components instead of the original
  * Lit element.
@@ -23,9 +15,8 @@ type ComponentLifecycle = {
  *   (like componentWillLoad and componentDidLoad in Stencil)
  * - Provides a .listen() method like Stencil's \@Listen decorator
  *
- * @remarks
  * Even though all components will extend this class, it is not exposed in the
- * public typings as we do not want to expose internal methods like
+ * public types as we do not want to expose internal methods like
  * addController() and connectedCallback() to the public typings.
  *
  * Instead, `@arcgis/lumina-compiler` will make it appear that your component
@@ -34,239 +25,177 @@ type ComponentLifecycle = {
  * `PublicLitElement` will never be called at runtime - it exists for typings
  * only.
  */
-export declare class LitElement extends OriginalLitElement implements ComponentLifecycle {
-    #private;
-    /**
-     * @private
-     * @remarks
-     * We prefix private variables with double underscore to avoid collisions with
-     * subclasses. All runtime properties that start with underscore are mangled
-     * in production build, so collision avoidance is mainly important to avoid
-     * triggering TypeScript errors.
-     */
-    static __runtime: Runtime;
-    /** @private */
-    static __tagName: string;
-    static elementProperties: Map<PropertyKey, LuminaPropertyDeclaration>;
-    /**
-     * Customize Lit's default style handling to support non-shadow-root styles
-     */
-    static finalizeStyles(styles?: CSSResultGroup): CSSResultOrNative[];
-    static createProperty(name: PropertyKey, 
-    /**
-     * While in vanilla Lit this type is always LuminaPropertyDeclaration,
-     * in Lumina it is always number or
-     * [number,LuminaPropertyDeclaration], so we don't even check for the
-     * LuminaPropertyDeclaration case. LuminaPropertyDeclaration is here
-     * only to satisfy the type checker.
-     */
-    options?: LuminaPropertyDeclaration | number | [number, LuminaPropertyDeclaration]): void;
-    protected static getPropertyDescriptor(name: PropertyKey, key: string | symbol, options: LuminaPropertyDeclaration): PropertyDescriptor | undefined;
-    /**
-     * Since we can't pass arguments to web component constructor, before lazy
-     * loading logic calls document.createElement(), it temporary sets this static
-     * property.
-     *
-     * @private
-     * */
-    static __lazy: ProxyComponent | undefined;
-    static readonly lumina = true;
-    /**
-     * In lazy build, the actual DOM element differs from the class instance:
-     * - "this.el" is a proxy custom element - it's physically present in the DOM
-     *   even before the Lit component is loaded.
-     * - "this" is the actual Lit component - in case of Lazy builds, it's
-     *   never directly attached to the DOM. Instead, all interactions with the
-     *   proxy are forwarded to the actual Lit component. And, when Lit wants to
-     *   render, it renders into the shadow root of the proxy.
-     *
-     * "this.el" should be used instead of "this" for all things involving the
-     * DOM (addEventListener, querySelector, children, setAttribute,
-     * MutationObserver, etc...)
-     *
-     * @example
-     * ```ts
-     * // Generally, you shouldn't have to write logic specific to lazy or non-lazy
-     * // build, but if you have to, you can detect if you are in a lazy build like so:
-     * const isLazy = this.el !== this;
-     * ```
-     */
-    readonly el: ToElement<this>;
-    /**
-     * Controller does not need to be an instance of the Controller class. Any
-     * Lit's Reactive controller will work as well. See examples:
-     * https://lit.dev/docs/composition/controllers/
-     *
-     * @private
-     * @privateRemarks
-     * For most private names I tried to prefix with __ to not conflict with
-     * private names on subclasses. However, Lit already has __controllers private.
-     */
-    readonly _controllers: (BaseController | Controller<unknown>)[];
-    /**
-     * Controller Manager orchestrates all controllers used by this component,
-     * connecting their lifecycle hooks and providing context information.
-     */
-    readonly manager: ControllerManager;
-    /** @private */
-    __postLoadDeferred: ProxyComponent["__postLoadDeferred"];
-    /**
-     * Direct offspring that should be awaited before loaded() is emitted.
-     *
-     * `attachToAncestor()` will add elements to this array
-     *
-     * @private
-     */
-    __offspringComponents: ProxyComponent["__offspringComponents"];
-    /**
-     * For HMR, if the .elementInternals was created, preserve that element
-     * internals instance across hot reloads. This method lets HMR get a reference
-     * to element internals in a side-effect free way and without adding production
-     * bytes.
-     *
-     * @private
-     */
-    devOnly$PureGetElementInternals?: () => ElementInternals | undefined;
-    /**
-     * @see [MDN ElementInternals](https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals)
-     */
-    get elementInternals(): ElementInternals;
-    constructor();
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    /**
-     * Overwrite Lit's default behavior of attaching shadow root to the lit
-     * element, and instead use this.el to support lazy builds.
-     *
-     * Also, support the case when component asked to not use shadow root
-     */
-    protected createRenderRoot(): DocumentFragment | HTMLElement;
-    /**
-     * Overwriting default shouldUpdate simply to get access to
-     * "changedProperties" so that we can later provide it to ControllerManager
-     */
-    protected shouldUpdate(_changedProperties: PropertyValues): boolean;
-    protected update(changedProperties: PropertyValues): void;
-    /**
-     * A helper for setting event listener on the current component.
-     *
-     * The event listener will be removed automatically when component
-     * disconnects, and added back if component re-comments, thus you don't have
-     * to clean it up manually.
-     *
-     * @remarks
-     * This listens for any event on the component or one of it's children.
-     * If you only want to listen for events originating from the component itself
-     * use `const isSelf = event.target === this.el;` to check.
-     *
-     * @example
-     * ```tsx
-     * constructor() {
-     *   // Handle click will only be called while component is connected
-     *   this.listen('click', this.handleClick);
-     * }
-     * handleClick(event: MouseEvent):void {
-     *   console.log('clicked');
-     * }
-     * ```
-     */
-    listen<K extends keyof HTMLElementEventMap>(name: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
-    listen<K extends keyof FormAssociatedEvents>(name: K, listener: (this: this, event: FormAssociatedEvents[K]) => unknown, options?: Omit<AddEventListenerOptions, "capture" | "passive"> | boolean): void;
-    listen(name: string, listener: (this: this, event: Event) => unknown, options?: AddEventListenerOptions | boolean): void;
-    listen<EventType extends Event = CustomEvent<"Provide type like this.listenOn<ToEvents<ArcgisCounter>['arcgisClick']>() to get type-checked payload type">>(name: string, 
-    /**
-     * The "NoInfer" here forces type argument to be specified explicitly.
-     * Without it, the following would be allowed:
-     * ```tsx
-     * this.listen("focus",(event:NotFocusEvent)=>{....})
-     * ```
-     */
-    listener: (this: this, event: NoInfer<EventType>) => unknown, options?: AddEventListenerOptions | boolean): void;
-    /**
-     * A helper for setting even listener on any element (or window / document).
-     *
-     * The event listener will be removed automatically when component
-     * disconnects, and added back if component re-comments, thus you don't have
-     * to clean it up manually.
-     *
-     * Use cases:
-     * - Listening for pointer events on the top-most element
-     * - Listening to events that are emitted exclusively on document/window/body
-     * - Imperatively listening for events on children components
-     * - Listening for events on non-Element objects (like Worker, WebSocket, etc)
-     * - Your component could emit a custom event, and then listen for that event
-     *   on the window. This lets consumer of the component handle the event and
-     *   stop propagation - and if they didn't and event reached the window, your
-     *   component can handle the event itself using the default behavior.
-     *
-     * @example
-     * ```tsx
-     * constructor() {
-     *   // Handle click will only be called while component is connected
-     *   this.listenOn(window, 'click', this.handleWindowClick);
-     * }
-     * handleWindowClick(event: MouseEvent):void {
-     *   console.log('clicked');
-     * }
-     * ```
-     */
-    listenOn<Name extends keyof WindowEventMap>(target: Window, name: Name, listener: Listener<this, WindowEventMap[Name] & {
-        currentTarget: Window;
-    }>, options?: AddEventListenerOptions | boolean): void;
-    listenOn<Name extends keyof DocumentEventMap>(target: Document, name: Name, listener: Listener<this, DocumentEventMap[Name] & {
-        currentTarget: Document;
-    }>, options?: AddEventListenerOptions | boolean): void;
-    listenOn<Name extends keyof HTMLElementEventMap>(target: HTMLElement, name: Name, listener: Listener<this, HTMLElementEventMap[Name] & {
-        currentTarget: HTMLElement;
-    }>, options?: AddEventListenerOptions | boolean): void;
-    listenOn<EventType extends Event = CustomEvent<"Provide type like this.listenOn<ToEvents<ArcgisCounter>['arcgisClick']>() to get type-checked payload type">, Target = EventTarget>(target: Target, name: string, 
-    /**
-     * The "NoInfer" here forces type argument to be specified explicitly.
-     * Without it, the following would be allowed:
-     * ```tsx
-     * this.listen("focus",(event:NotFocusEvent)=>{....})
-     * ```
-     */
-    listener: Listener<this, NoInfer<EventType> & {
-        currentTarget: Target;
-    }>, options?: AddEventListenerOptions | boolean): void;
-    /**
-     * Creates a promise that resolves once the component is fully loaded.
-     *
-     * @example
-     * const map = document.createElement('arcgis-map');
-     * document.body.append(map);
-     * map.componentOnReady().then(() => {
-     *   console.log('Map is ready to go!');
-     * });
-     */
-    componentOnReady(): Promise<this>;
-    /**
-     * Adds a controller to the host, which connects the controller's lifecycle
-     * methods to the host's lifecycle.
-     *
-     * @remarks
-     * Even though Lit's LitElement already has addController,
-     * we overwrite it with a compatible version to have more control over
-     * timing, and to add support for load/loaded lifecycle hooks.
-     */
-    addController(controller: BaseController | ReactiveController): void;
-    /**
-     * Removes a controller from the host.
-     */
-    removeController(controller: BaseController | ReactiveController): void;
+export class LitElement extends OriginalLitElement {
+  static readonly lumina: true;
+  /** @internal */
+  constructor();
+  /**
+   * In lazy build, the actual DOM element differs from the class instance:
+   * - "this.el" is a proxy custom element - it's physically present in the DOM
+   *   even before the Lit component is loaded.
+   * - "this" is the actual Lit component - in case of Lazy builds, it's
+   *   never directly attached to the DOM. Instead, all interactions with the
+   *   proxy are forwarded to the actual Lit component. And, when Lit wants to
+   *   render, it renders into the shadow root of the proxy.
+   *
+   * "this.el" should be used instead of "this" for all things involving the
+   * DOM (addEventListener, querySelector, children, setAttribute,
+   * MutationObserver, etc...)
+   *
+   * @example
+   * ```ts
+   * // Generally, you shouldn't have to write logic specific to lazy or non-lazy
+   * // build, but if you have to, you can detect if you are in a lazy build like so:
+   * const isLazy = this.el !== this;
+   * ```
+   */
+  readonly el: ToElement<this>;
+  /** @see [MDN ElementInternals](https://developer.mozilla.org/docs/Web/API/ElementInternals) */
+  get elementInternals(): ElementInternals;
+  /**
+   * Controller Manager orchestrates all controllers used by this component,
+   * connecting their lifecycle hooks and providing context information.
+   */
+  readonly manager: ControllerManager;
+  /**
+   * Adds a controller to the host, which connects the controller's lifecycle
+   * methods to the host's lifecycle.
+   *
+   * Even though Lit's LitElement already has addController,
+   * we overwrite it with a compatible version to have more control over
+   * timing, and to add support for load/loaded lifecycle hooks.
+   *
+   * @param controller
+   */
+  addController(controller: BaseController | ReactiveController): void;
+  /**
+   * Creates a promise that resolves once the component is fully loaded.
+   *
+   * @example
+   * ```js
+   * const map = document.createElement('arcgis-map');
+   * document.body.append(map);
+   * map.componentOnReady().then(() => {
+   *   console.log('Map is ready to go!');
+   * });
+   * ```
+   */
+  componentOnReady(): Promise<this>;
+  /**
+   * A helper for setting event listener on the current component.
+   *
+   * The event listener will be removed automatically when component
+   * disconnects, and added back if component re-comments, thus you don't have
+   * to clean it up manually.
+   *
+   * This listens for any event on the component or one of it's children.
+   * If you only want to listen for events originating from the component itself
+   * use `const isSelf = event.target === this.el;` to check.
+   *
+   * @param name
+   * @param listener
+   * @param options
+   * @example
+   * ```tsx
+   * constructor() {
+   *   // Handle click will only be called while component is connected
+   *   this.listen('click', this.handleClick);
+   * }
+   * handleClick(event: MouseEvent):void {
+   *   console.log('clicked');
+   * }
+   * ```
+   */
+  listen<K extends keyof HTMLElementEventMap>(name: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listen<K extends keyof FormAssociatedEvents>(name: K, listener: (this: this, event: FormAssociatedEvents[K]) => unknown, options?: Omit<AddEventListenerOptions, "capture" | "passive"> | boolean): void;
+  /**
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listen(name: string, listener: (this: this, event: Event) => unknown, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listen<EventType extends Event = CustomEvent<"Provide type like this.listenOn<ToEvents<ArcgisCounter>['arcgisClick']>() to get type-checked payload type">>(name: string, listener: (this: this, event: NoInfer<EventType>) => unknown, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * A helper for setting even listener on any element (or window / document).
+   *
+   * The event listener will be removed automatically when component
+   * disconnects, and added back if component re-comments, thus you don't have
+   * to clean it up manually.
+   *
+   * Use cases:
+   * - Listening for pointer events on the top-most element
+   * - Listening to events that are emitted exclusively on document/window/body
+   * - Imperatively listening for events on children components
+   * - Listening for events on non-Element objects (like Worker, WebSocket, etc)
+   * - Your component could emit a custom event, and then listen for that event
+   *   on the window. This lets consumer of the component handle the event and
+   *   stop propagation - and if they didn't and event reached the window, your
+   *   component can handle the event itself using the default behavior.
+   *
+   * @param target
+   * @param name
+   * @param listener
+   * @param options
+   * @example
+   * ```tsx
+   * constructor() {
+   *   // Handle click will only be called while component is connected
+   *   this.listenOn(window, 'click', this.handleWindowClick);
+   * }
+   * handleWindowClick(event: MouseEvent):void {
+   *   console.log('clicked');
+   * }
+   * ```
+   */
+  listenOn<Name extends keyof WindowEventMap>(target: Window, name: Name, listener: Listener<this, WindowEventMap[Name] & { currentTarget: Window; }>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param target
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listenOn<Name extends keyof DocumentEventMap>(target: Document, name: Name, listener: Listener<this, DocumentEventMap[Name] & { currentTarget: Document; }>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param target
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listenOn<Name extends keyof HTMLElementEventMap>(target: HTMLElement, name: Name, listener: Listener<this, HTMLElementEventMap[Name] & { currentTarget: HTMLElement; }>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param target
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listenOn<EventType extends Event = CustomEvent<"Provide type like this.listenOn<ToEvents<ArcgisCounter>['arcgisClick']>() to get type-checked payload type">, Target = EventTarget>(target: Target, name: string, listener: Listener<this, NoInfer<EventType> & { currentTarget: Target; }>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param target
+   * @param name
+   * @param listener
+   * @param options
+   */
+  listenOn(target: EventTarget, name: string, listener: Listener<this, Event>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * Removes a controller from the host.
+   *
+   * @param controller
+   */
+  removeController(controller: BaseController | ReactiveController): void;
 }
-type Listener<ThisType, EventType> = ((this: ThisType, event: EventType) => unknown) | {
-    handleEvent(event: EventType): unknown;
-};
-/**
- * List of tag names defined by this library.
- *
- * @private
- */
-export type GlobalThisWithOwnTagNames = typeof globalThis & {
-    devOnly$ownTagNames?: Set<string>;
-};
+
+export type Listener<ThisType, EventType> = ((this: ThisType, event: EventType) => unknown) | { handleEvent(event: EventType): unknown; };
+
 /**
  * Lumina tracks accesses to JSAPI Accessor properties during render() and
  * automatically re-renders the component when any tracked property changes.
@@ -276,6 +205,7 @@ export type GlobalThisWithOwnTagNames = typeof globalThis & {
  * give you time to complete the migration and refactor the code.
  *
  * @deprecated Use this as a **temporary** workaround only.
+ * @param componentClass
  * @example
  * ```ts
  * import { disableReactiveUtilsIntegration } from "@arcgis/lumina";
@@ -285,5 +215,4 @@ export type GlobalThisWithOwnTagNames = typeof globalThis & {
  * disableReactiveUtilsIntegration(MyComponent);
  * ```
  */
-export declare function disableReactiveUtilsIntegration(componentClass: typeof LitElement): void;
-export {};
+export function disableReactiveUtilsIntegration(componentClass: typeof LitElement): void;

package/dist/PublicLitElement.d.ts

@@ -1,30 +1,64 @@
-import { TargetedEvent } from './jsx/types.ts';
-/**
- * The base public interface for all `@arcgis/lumina` components
- */
-export declare class PublicLitElement extends HTMLElement {
-    private el;
-    ["@eventTypes"]: Record<never, never>;
-    /**
-     * Web components are not constructable via the `new` operator.
-     * Instead use `document.createElement("some-tag-name")`.
-     */
-    protected constructor();
-    /**
-     * Creates a promise that resolves once the component is fully loaded.
-     *
-     * @example
-     * const map = document.createElement("arcgis-map");
-     * document.body.append(map);
-     * map.componentOnReady().then(() => {
-     *   console.log("Map is ready to go!");
-     * });
-     */
-    componentOnReady(): Promise<this>;
-    addEventListener<K extends keyof this["@eventTypes"]>(type: K, listener: (this: this, event: TargetedEvent<this, this["@eventTypes"][K]>) => unknown, options?: AddEventListenerOptions | boolean): void;
-    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener<K extends keyof this["@eventTypes"]>(type: K, listener: (this: this, event: TargetedEvent<this, this["@eventTypes"][K]>) => unknown, options?: EventListenerOptions | boolean): void;
-    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: EventListenerOptions | boolean): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
-}
+import type { TargetedEvent } from "./jsx/types.js";
+
+/** The base public interface for all `@arcgis/lumina` components */
+export class PublicLitElement extends HTMLElement {
+  /**
+   * @deprecated
+   * Do not directly reference this property.
+   * Use EventNames and EventTypes helpers from \@arcgis/core/Evented
+   */
+  "@eventTypes": unknown;
+  /**
+   * Web components are not constructable via the `new` operator.
+   * Instead use `document.createElement("some-tag-name")`.
+   */
+  protected constructor();
+  el: this;
+  /**
+   * @param type
+   * @param listener
+   * @param options
+   */
+  addEventListener<K extends keyof this["@eventTypes"]>(type: K, listener: (this: this, event: TargetedEvent<this, this["@eventTypes"][K]>) => unknown, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param type
+   * @param listener
+   * @param options
+   */
+  addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * @param type
+   * @param listener
+   * @param options
+   */
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * Creates a promise that resolves once the component is fully loaded.
+   *
+   * @example
+   * const map = document.createElement("arcgis-map");
+   * document.body.append(map);
+   * map.componentOnReady().then(() => {
+   *   console.log("Map is ready to go!");
+   * });
+   */
+  componentOnReady(): Promise<this>;
+  /**
+   * @param type
+   * @param listener
+   * @param options
+   */
+  removeEventListener<K extends keyof this["@eventTypes"]>(type: K, listener: (this: this, event: TargetedEvent<this, this["@eventTypes"][K]>) => unknown, options?: EventListenerOptions | boolean): void;
+  /**
+   * @param type
+   * @param listener
+   * @param options
+   */
+  removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: EventListenerOptions | boolean): void;
+  /**
+   * @param type
+   * @param listener
+   * @param options
+   */
+  removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
+}

package/dist/config.d.ts

@@ -1,22 +1,28 @@
-/**
- * Configuration options that are shared between `@arcgis/lumina` and
- * `@arcgis/lumina-compiler`. To avoid the need of loading DOM modules in Node.js,
- * this file is extracted into a separate entrypoint.
- */
-export declare const lazyMetaGroupJoiner = ";";
-export declare const lazyMetaItemJoiner = ",";
-export declare const lazyMetaSubItemJoiner = ":";
+export const lazyMetaGroupJoiner: ";";
+
+export const lazyMetaItemJoiner: ",";
+
+export const lazyMetaSubItemJoiner: ":";
+
 /**
  * By default in Lit, the `@property()` decorator accepts an object. However, to
  * keep the bundle size smaller, in production builds, instead of passing it an
  * object, we pass it a compact number, that gets converted back to an object
  * in createProperty() at runtime.
  */
-export declare const propertyFlagAttribute: number;
-export declare const propertyFlagReflect: number;
-export declare const propertyFlagBoolean: number;
-export declare const propertyFlagNumber: number;
-export declare const propertyFlagState: number;
-export declare const propertyFlagReadOnly: number;
-export declare const propertyFlagNoAccessor: number;
-export declare const propertyFlagUseDefault: number;
+export const propertyFlagAttribute: number;
+
+export const propertyFlagReflect: number;
+
+export const propertyFlagBoolean: number;
+
+export const propertyFlagNumber: number;
+
+export const propertyFlagState: number;
+
+export const propertyFlagReadOnly: number;
+
+/** The name is inverted so that the more common case is "false" */
+export const propertyFlagNoAccessor: number;
+
+export const propertyFlagUseDefault: number;