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

package/dist/puppeteerTesting/puppeteer/types.d.ts

@@ -1,149 +1,147 @@
-import { HTTPResponse, Page, WaitForOptions } from 'puppeteer';
-import { EventSpy } from './events.ts';
-import { E2EElement } from './element.ts';
+import type { HTTPResponse, Page, WaitForOptions } from "puppeteer";
+import type { EventSpy } from "./events.js";
+import type { E2EElement } from "./element.js";
+
 export interface PageDiagnostic {
-    type: "error" | "pageerror" | "requestfailed";
-    message?: string;
-    location?: string;
+  type: "error" | "pageerror" | "requestfailed";
+  message?: string;
+  location?: string;
 }
+
 /**
  * The E2EPage is a wrapper utility to Puppeteer in order to
  * to create easier to write and read end-to-end tests.
  */
 export interface E2EPage extends Page {
-    /**
-     * Sets a debugger;
-     */
-    debugger: () => Promise<void>;
-    /**
-     * Find an element that matches the selector, which is the same as
-     * `document.querySelector(selector)`. Use `>>>` within the
-     * selector to find an element within the host element's shadow root.
-     * For example, to select the first `div` inside of the component
-     * `my-cmp`, the call would be `page.find('my-cmp >>> div')`.
-     * Returns `null` if an element was not found.
-     */
-    find: (selector: FindSelector) => Promise<E2EElement>;
-    /**
-     * Find all elements that match the selector, which is the same as
-     * `document.querySelectorAll(selector)`. Use `>>>` within the
-     * selector to find elements within the host element's shadow root.
-     * For example, to select all of the `li` elements inside of the component
-     * `my-cmp`, the call would be `page.findAll('my-cmp >>> li')`.
-     * Returns an empty array if no elements were found.
-     */
-    findAll: (selector: string) => Promise<E2EElement[]>;
-    /**
-     * During an end-to-end test, a dev-server is started so `page.goto(url)` can be used
-     * on the app being tested. Urls are always relative since the dev server provides
-     * a localhost address. A shortcut to `page.goto(url)` is to set the `url` option
-     * when creating a new page, such as `const page = await newE2EPage({ url })`.
-     */
-    goTo: (url: string, options?: WaitForOptions) => Promise<HTTPResponse | null>;
-    /**
-     * Instead of testing a url directly, html content can be mocked using
-     * `page.setContent(html)`. A shortcut to `page.setContent(html)` is to set
-     * the `html` option when creating a new page, such as
-     * `const page = await newE2EPage({ html })`.
-     */
-    setContent: (html: string, options?: WaitForOptions) => Promise<void>;
-    /**
-     * Used to test if an event was, or was not dispatched. This method
-     * returns a promise, that resolves with an EventSpy. The EventSpy
-     * can be used along with `expect(spy).toHaveReceivedEvent()`,
-     * `expect(spy).toHaveReceivedEventTimes(x)` and
-     * `expect(spy).toHaveReceivedEventDetail({...})`.
-     */
-    spyOnEvent: <Detail = unknown>(eventName: string, selector?: "document" | "window") => Promise<EventSpy<Detail>>;
-    /**
-     * Puppeteer has asynchronous architecture. Since all calls are async, it's
-     * required that `await page.waitForChanges()` is called when changes are
-     * made to components.
-     * An error will be thrown if changes were made to a component but
-     * `waitForChanges()` was not called.
-     *
-     * @param delay - The number of milliseconds to wait after components
-     * finish updating. Default value is determined by the
-     * `puppeteerTesting.waitForChangesDelay` option passed to useLumina().
-     */
-    waitForChanges: (delay?: number) => Promise<void>;
-    /**
-     * Waits for the event to be received on `window`. The optional second argument
-     * allows the listener to be set to `document` if needed.
-     */
-    waitForEvent: <Detail = unknown>(eventName: string) => Promise<SerializedEvent<Detail>>;
-    getDiagnostics: () => PageDiagnostic[];
-    isClosed: () => boolean;
-    /**
-     * Causes your script to wait for the given number of milliseconds.
-     *
-     * @remarks
-     *
-     * It's generally recommended to not wait for a number of seconds, but instead
-     * use {@link Frame.waitForSelector}, {@link Frame.waitForXPath} or
-     * {@link Frame.waitForFunction} to wait for exactly the conditions you want.
-     *
-     * @example
-     *
-     * Wait for 1 second:
-     *
-     * ```ts
-     * await page.waitForTimeout(1000);
-     * ```
-     *
-     * @param milliseconds - the number of milliseconds to wait.
-     */
-    waitForTimeout: (milliseconds: number) => Promise<void>;
-    /** @private */
-    _e2eElements: E2EElement[];
-    /** @private */
-    _e2eEvents: Map<number, WaitForEvent>;
-    /** @private */
-    _e2eEventIds: number;
-    /** @private */
-    _originalClose: Page["close"];
-    /** @private */
-    _isWaitingForAllReady: boolean;
-    /** @private */
-    _unhandledError: unknown;
+  /** Sets a debugger; */
+  debugger(): Promise<void>;
+  /**
+   * Find an element that matches the selector, which is the same as
+   * `document.querySelector(selector)`. Use `>>>` within the
+   * selector to find an element within the host element's shadow root.
+   * For example, to select the first `div` inside of the component
+   * `my-cmp`, the call would be `page.find('my-cmp >>> div')`.
+   * Returns `null` if an element was not found.
+   *
+   * @param selector
+   */
+  find(selector: FindSelector): Promise<E2EElement>;
+  /**
+   * Find all elements that match the selector, which is the same as
+   * `document.querySelectorAll(selector)`. Use `>>>` within the
+   * selector to find elements within the host element's shadow root.
+   * For example, to select all of the `li` elements inside of the component
+   * `my-cmp`, the call would be `page.findAll('my-cmp >>> li')`.
+   * Returns an empty array if no elements were found.
+   *
+   * @param selector
+   */
+  findAll(selector: string): Promise<E2EElement[]>;
+  /**
+   * During an end-to-end test, a dev-server is started so `page.goto(url)` can be used
+   * on the app being tested. Urls are always relative since the dev server provides
+   * a localhost address. A shortcut to `page.goto(url)` is to set the `url` option
+   * when creating a new page, such as `const page = await newE2EPage({ url })`.
+   *
+   * @param url
+   * @param options
+   */
+  goTo(url: string, options?: WaitForOptions): Promise<HTTPResponse | null>;
+  /**
+   * Instead of testing a url directly, html content can be mocked using
+   * `page.setContent(html)`. A shortcut to `page.setContent(html)` is to set
+   * the `html` option when creating a new page, such as
+   * `const page = await newE2EPage({ html })`.
+   *
+   * @param html
+   * @param options
+   */
+  setContent(html: string, options?: WaitForOptions): Promise<void>;
+  /**
+   * Used to test if an event was, or was not dispatched. This method
+   * returns a promise, that resolves with an EventSpy. The EventSpy
+   * can be used along with `expect(spy).toHaveReceivedEvent()`,
+   * `expect(spy).toHaveReceivedEventTimes(x)` and
+   * `expect(spy).toHaveReceivedEventDetail({...})`.
+   *
+   * @param eventName
+   * @param selector
+   */
+  spyOnEvent<Detail = unknown>(eventName: string, selector?: "document" | "window"): Promise<EventSpy<Detail>>;
+  /**
+   * Puppeteer has asynchronous architecture. Since all calls are async, it's
+   * required that `await page.waitForChanges()` is called when changes are
+   * made to components.
+   * An error will be thrown if changes were made to a component but
+   * `waitForChanges()` was not called.
+   *
+   * @param delay - The number of milliseconds to wait after components
+   * finish updating. Default value is determined by the
+   * `puppeteerTesting.waitForChangesDelay` option passed to useLumina().
+   */
+  waitForChanges(delay?: number): Promise<void>;
+  /**
+   * Waits for the event to be received on `window`. The optional second argument
+   * allows the listener to be set to `document` if needed.
+   *
+   * @param eventName
+   */
+  waitForEvent<Detail = unknown>(eventName: string): Promise<SerializedEvent<Detail>>;
+  getDiagnostics(): PageDiagnostic[];
+  isClosed(): boolean;
+  /**
+   * Causes your script to wait for the given number of milliseconds.
+   *
+   * It's generally recommended to not wait for a number of seconds, but instead
+   * use Frame.waitForSelector, Frame.waitForXPath or
+   * Frame.waitForFunction to wait for exactly the conditions you want.
+   *
+   * @param milliseconds - the number of milliseconds to wait.
+   * @example
+   * Wait for 1 second:
+   *
+   * ```ts
+   * await page.waitForTimeout(1000);
+   * ```
+   */
+  waitForTimeout(milliseconds: number): Promise<void>;
 }
+
 export interface SerializedEvent<Detail = unknown> {
-    bubbles: boolean;
-    cancelable: boolean;
-    composed: boolean;
-    currentTarget: SerializedElement;
-    defaultPrevented: boolean;
-    detail: Detail;
-    eventPhase: number;
-    isTrusted: boolean;
-    target: SerializedElement;
-    timeStamp: number;
-    type: string;
-    isSerializedEvent: boolean;
+  bubbles: boolean;
+  cancelable: boolean;
+  composed: boolean;
+  currentTarget: SerializedElement;
+  defaultPrevented: boolean;
+  detail: Detail;
+  eventPhase: number;
+  isTrusted: boolean;
+  target: SerializedElement;
+  timeStamp: number;
+  type: string;
+  isSerializedEvent: boolean;
 }
+
 export type SerializedElement = Record<string, unknown> | null;
+
 export type FindSelector = FindSelectorOptions | string;
+
 export interface FindSelectorOptions {
-    /**
-     * Finds an element with text content matching this
-     * exact value after the whitespace has been trimmed.
-     */
-    text?: string;
-    /**
-     * Finds an element with text content containing this value.
-     */
-    contains?: string;
+  /**
+   * Finds an element with text content matching this
+   * exact value after the whitespace has been trimmed.
+   */
+  text?: string;
+  /** Finds an element with text content containing this value. */
+  contains?: string;
 }
+
 export interface WaitForEventOptions {
-    timeout?: number;
+  timeout?: number;
 }
+
 export interface WaitForEvent {
-    eventName: string;
-    callback: (event: SerializedEvent) => void;
-}
-export interface BrowserWindow extends Window {
-    puppeteerAwaitAllReady: () => Promise<void>;
-    puppeteerOnEvent: (id: number, event: SerializedEvent) => void;
-    puppeteerSerializeEvent: <Detail = unknown>(event: CustomEvent | Event) => SerializedEvent<Detail>;
-    puppeteerSerializeEventTarget: (target: Element | EventTarget | null) => SerializedElement;
-}
+  eventName: string;
+  /** @param event */
+  callback(event: SerializedEvent): void;
+}

package/dist/puppeteerTesting/vitest/matchers/index.d.ts

@@ -1,31 +1,34 @@
-export declare const expectExtend: {
-    toEqualAttribute: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toEqualAttributes: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toEqualText: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveAttribute: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveClass: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveClasses: (element: unknown, expectClassNames: string[]) => import('@vitest/expect').SyncExpectationResult;
-    toMatchClasses: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveReceivedEvent: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveReceivedEventTimes: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveReceivedEventDetail: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveFirstReceivedEventDetail: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveLastReceivedEventDetail: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-    toHaveNthReceivedEventDetail: import('vitest').Matcher<import('vitest').MatcherState, any[]>;
-};
+/**
+ * @internal
+ * @knipIgnore Used in ../../index.ts inside a namespace
+ */
 export interface PuppeteerMatchers<R = unknown> {
-    toEqualAttribute: (expectedAttribute: string, expectedValue: unknown) => R;
-    toEqualAttributes: (expectedAttributes: Record<string, unknown>) => R;
-    toEqualHtml: (expectedHtml: string) => R;
-    toEqualLightHtml: (expectedHtml: string) => R;
-    toEqualText: (expectedTextContent: string) => R;
-    toHaveAttribute: (expectedAttributeName: string) => R;
-    toHaveClass: (classNames: string) => R;
-    toHaveClasses: (classNames: string[]) => R;
-    toHaveReceivedEvent: () => R;
-    toHaveReceivedEventTimes: (count: number) => R;
-    toHaveReceivedEventDetail: (eventDetail: unknown) => R;
-    toHaveFirstReceivedEventDetail: (eventDetail: unknown) => R;
-    toHaveLastReceivedEventDetail: (eventDetail: unknown) => R;
-    toHaveNthReceivedEventDetail: (index: number, eventDetail: unknown) => R;
-}
+  /** @internal */
+  toEqualAttribute: (expectedAttribute: string, expectedValue: unknown) => R;
+  /** @internal */
+  toEqualAttributes: (expectedAttributes: Record<string, unknown>) => R;
+  /** @internal */
+  toEqualHtml: (expectedHtml: string) => R;
+  /** @internal */
+  toEqualLightHtml: (expectedHtml: string) => R;
+  /** @internal */
+  toEqualText: (expectedTextContent: string) => R;
+  /** @internal */
+  toHaveAttribute: (expectedAttributeName: string) => R;
+  /** @internal */
+  toHaveClass: (classNames: string) => R;
+  /** @internal */
+  toHaveClasses: (classNames: string[]) => R;
+  /** @internal */
+  toHaveReceivedEvent: () => R;
+  /** @internal */
+  toHaveReceivedEventTimes: (count: number) => R;
+  /** @internal */
+  toHaveReceivedEventDetail: (eventDetail: unknown) => R;
+  /** @internal */
+  toHaveFirstReceivedEventDetail: (eventDetail: unknown) => R;
+  /** @internal */
+  toHaveLastReceivedEventDetail: (eventDetail: unknown) => R;
+  /** @internal */
+  toHaveNthReceivedEventDetail: (index: number, eventDetail: unknown) => R;
+}

package/dist/testing/index.d.ts

@@ -1,11 +1,4 @@
-/**
- * Unlike most of lumina-compiler code, this entrypoint may be executed in the
- * browser (or in node.js), depending on where the tests are running.
- *
- * Thus, make sure to not import anything from the rest of the lumina-compiler
- * in this bundle.
- */
-export type { RenderOptions, RenderResult } from './mount.ts';
-export { mount, findFirstComponent } from './mount.ts';
-export { setupLuminaTest } from './setupFile.ts';
-export { wrapController } from './wrapController.ts';
+export { type RenderOptions, type RenderResult } from "./mount.js";
+export { mount, findFirstComponent } from "./mount.js";
+export { wrapController } from "./wrapController.js";
+

package/dist/testing/mount.d.ts

@@ -1,89 +1,90 @@
-import { TemplateResult } from 'lit';
-import { JsxNode, LitElement, ToElement } from '@arcgis/lumina';
-export type RenderResult<Component extends HTMLElement> = {
-    /**
-     * The custom element proxy that is attached to the DOM.
-     *
-     * This element will contain all the public properties and public methods of
-     * your custom element, but it will not contain any internal members.
-     */
-    readonly el: ToElement<Component> & {
-        shadowRoot: ShadowRoot;
-    };
-    /**
-     * This is the actual LitElement that you authored in the code.
-     *
-     * It is not directly connected to the DOM (instead, a proxy element is used
-     * to facilitate lazy-loading).
-     *
-     * All public and private members of your custom element are available here.
-     */
-    readonly component: Component;
-    /**
-     * The container element that was used to render the component.
-     *
-     * This element is useful to inspect for functional components and components
-     * that do not use shadow DOM.
-     */
-    readonly container: HTMLElement;
-    /**
-     * A callback for triggering component re-render. Optionally, if the first
-     * argument to `mount()` was a function, that function will be called
-     * again to get a new template.
-     *
-     * @example
-     * ```tsx
-     * let someValue = 1;
-     * const { el, component, reRender } = await mount<ArcgisCounter>(
-     *   ()=><arcgis-counter someProp={someValue} />
-     * );
-     *
-     * someValue = 2;
-     * await reRender();
-     * ```
-     *
-     * The above is roughly equivalent to manually setting `el.someProp = 2`.
-     */
-    readonly reRender: () => Promise<boolean>;
-};
-export type RenderOptions<Component extends HTMLElement = HTMLElement> = {
-    /**
-     * The parent to attach this component to.
-     *
-     * @default document.body
-     */
-    readonly parent?: DocumentFragment | HTMLElement;
-    /**
-     * `mount()` will return a promise that resolves after the element
-     * is connected to the DOM, fully loaded and rendered.
-     *
-     * This callback is for executing code right after the element is connected to
-     * the DOM, but before it is fully loaded and rendered.
-     */
-    readonly afterConnect?: (el: ToElement<Component> & {
-        shadowRoot: ShadowRoot;
-    }) => Promise<void> | void;
-    /**
-     * This option only needs to be used if you created the custom element
-     * dynamically (inside the test file), rather than in a separate .tsx file.
-     * Also, if you already passed the dynamic custom element class as the first
-     * argument to `mount()`, you don't need to provide it again here.
-     */
-    readonly dynamicComponents?: (typeof LitElement)[];
-    /**
-     * Whether to cleanup the document body after the test. Set this to false if
-     * you wish to reuse the same component between different test() blocks.
-     *
-     * @default true
-     */
-    readonly cleanupAfterTest?: boolean;
-};
+import type { DeclareElements, JsxNode, LitElement, ToElement } from "@arcgis/lumina";
+import type { TemplateResult } from "lit";
+
+export interface RenderResult<Component extends HTMLElement> {
+  /**
+   * The custom element proxy that is attached to the DOM.
+   *
+   * This element will contain all the public properties and public methods of
+   * your custom element, but it will not contain any internal members.
+   */
+  readonly el: ToElement<Component> & { shadowRoot: ShadowRoot; };
+  /**
+   * This is the actual LitElement that you authored in the code.
+   *
+   * It is not directly connected to the DOM (instead, a proxy element is used
+   * to facilitate lazy-loading).
+   *
+   * All public and private members of your custom element are available here.
+   */
+  readonly component: Component;
+  /**
+   * The container element that was used to render the component.
+   *
+   * This element is useful to inspect for functional components and components
+   * that do not use shadow DOM.
+   */
+  readonly container: HTMLElement;
+  /**
+   * A callback for triggering component re-render. Optionally, if the first
+   * argument to `mount()` was a function, that function will be called
+   * again to get a new template.
+   *
+   * @example
+   * ```tsx
+   * let someValue = 1;
+   * const { el, component, reRender } = await mount<ArcgisCounter>(
+   *   ()=><arcgis-counter someProp={someValue} />
+   * );
+   *
+   * someValue = 2;
+   * await reRender();
+   * ```
+   *
+   * The above is roughly equivalent to manually setting `el.someProp = 2`.
+   */
+  reRender(): Promise<boolean>;
+}
+
+export interface RenderOptions<Component extends HTMLElement = HTMLElement> {
+  /**
+   * The parent to attach this component to.
+   *
+   * @default document.body
+   */
+  readonly parent?: DocumentFragment | HTMLElement;
+  /**
+   * `mount()` will return a promise that resolves after the element
+   * is connected to the DOM, fully loaded and rendered.
+   *
+   * This callback is for executing code right after the element is connected to
+   * the DOM, but before it is fully loaded and rendered.
+   *
+   * @param el
+   */
+  afterConnect?(el: ToElement<Component> & { shadowRoot: ShadowRoot; }): Promise<void> | void;
+  /**
+   * This option only needs to be used if you created the custom element
+   * dynamically (inside the test file), rather than in a separate .tsx file.
+   * Also, if you already passed the dynamic custom element class as the first
+   * argument to `mount()`, you don't need to provide it again here.
+   */
+  readonly dynamicComponents?: (typeof LitElement)[];
+  /**
+   * Whether to cleanup the document body after the test. Set this to false if
+   * you wish to reuse the same component between different test() blocks.
+   *
+   * @default true
+   */
+  readonly cleanupAfterTest?: boolean;
+}
+
 /**
  * Render Lit Element in a test environment.
  *
- * See documentation:
- * https://webgis.esri.com/references/lumina/testing
- *
+ * @param tagName
+ * @param options
+ * @see https://webgis.esri.com/references/lumina/testing
  * @example
  * ```tsx
  * // Create component based on a tag name
@@ -93,8 +94,7 @@ export type RenderOptions<Component extends HTMLElement = HTMLElement> = {
  * // You can also use the component class as the explicit type annotation:
  * const { el, component } = await mount<ArcgisCounter>(<arcgis-counter />);
  * ```
- *
- * @remarks
+ * @example
  * In it's simplest form, what this function is doing is the following:
  *
  * ```tsx
@@ -104,17 +104,37 @@ export type RenderOptions<Component extends HTMLElement = HTMLElement> = {
  * await el.componentOnReady();
  * ```
  */
-export declare function mount<const TagName extends keyof DeclareElements>(tagName: TagName, options?: RenderOptions<DeclareElements[TagName]>): Promise<RenderResult<DeclareElements[TagName]>>;
-export declare function mount<Class extends typeof LitElement>(template: TemplateResult | (() => JsxNode), options?: RenderOptions<InstanceType<Class>> & {
-    dynamicComponents: [Class];
-}): Promise<RenderResult<InstanceType<Class>>>;
-export declare function mount<TagName extends keyof DeclareElements = never>(jsx: TemplateResult | (() => JsxNode), options?: RenderOptions<[TagName] extends [never] ? LitElement : DeclareElements[TagName]>): Promise<RenderResult<[TagName] extends [never] ? LitElement : DeclareElements[TagName]>>;
-export declare function mount<Class extends typeof LitElement>(template: Class | TemplateResult | (() => JsxNode), options?: RenderOptions<InstanceType<Class>>): Promise<RenderResult<InstanceType<Class>>>;
-export declare function mount<Component extends LitElement>(template: TemplateResult | (() => JsxNode) | (new () => Component), options?: RenderOptions<Component>): Promise<RenderResult<Component>>;
+export function mount<const TagName extends keyof DeclareElements>(tagName: TagName, options?: RenderOptions<DeclareElements[TagName]>): Promise<RenderResult<DeclareElements[TagName]>>;
+
+/**
+ * @param template
+ * @param options
+ */
+export function mount<Class extends typeof LitElement>(template: TemplateResult | (() => JsxNode), options?: RenderOptions<InstanceType<Class>> & { dynamicComponents: [Class]; }): Promise<RenderResult<InstanceType<Class>>>;
+
+/**
+ * @param jsx
+ * @param options
+ */
+export function mount<TagName extends keyof DeclareElements = never>(jsx: TemplateResult | (() => JsxNode), options?: RenderOptions<[TagName] extends [never] ? LitElement : DeclareElements[TagName]>): Promise<RenderResult<[TagName] extends [never] ? LitElement : DeclareElements[TagName]>>;
+
+/**
+ * @param template
+ * @param options
+ */
+export function mount<Class extends typeof LitElement>(template: Class | TemplateResult | (() => JsxNode), options?: RenderOptions<InstanceType<Class>>): Promise<RenderResult<InstanceType<Class>>>;
+
+/**
+ * @param template
+ * @param options
+ */
+export function mount<Component extends LitElement>(template: TemplateResult | (() => JsxNode) | (new () => Component), options?: RenderOptions<Component>): Promise<RenderResult<Component>>;
+
 /**
  * Find the first direct child Lumina component element. If failed to find a
  * direct child, do a priority-first search in the children of the children.
  *
+ * @param container
  * @experimental
  */
-export declare function findFirstComponent(container: ParentNode): Element | undefined;
+export function findFirstComponent(container: ParentNode): Element | undefined;

package/dist/testing/wrapController.d.ts

@@ -1,15 +1,17 @@
-import { LitElement } from '@arcgis/lumina';
+import type { LitElement } from "@arcgis/lumina";
+
 /**
  * Wrap a controller in a small component - useful when you are interested in
  * only testing the controller behavior.
  *
+ * @param controller
+ * @param afterConstruct
  * @example
  * ```ts
  * const testController = (): string => makeController(()=>'a');
  * const { component } = await mount(wrapController(testController));
  * expect(component.controller).toEqual("a");
  * ```
- *
  * @example
  * ```ts
  * class TestController extends Controller {
@@ -21,12 +23,4 @@ import { LitElement } from '@arcgis/lumina';
  * expect(controller.a).toEqual("a");
  * ```
  */
-export declare function wrapController<T>(controller: ((component: LitElement) => T) | (new (component: LitElement) => T), 
-/**
- * An optional callback to call right after controller constructor
- */
-afterConstruct?: (component: LitElement & {
-    controller: T;
-}) => Promise<void> | void): typeof LitElement & (new () => LitElement & {
-    controller: T;
-});
+export function wrapController<T>(controller: ((component: LitElement) => T) | (new (component: LitElement) => T), afterConstruct?: (component: LitElement & { controller: T; }) => Promise<void> | void): typeof LitElement & (new () => LitElement & { controller: T; });