ember-source 4.10.0-beta.2 → 4.11.0-alpha.2

package/types/stable/@ember/-internals/glimmer/lib/helpers/readonly.d.ts

@@ -0,0 +1,119 @@
+declare module '@ember/-internals/glimmer/lib/helpers/readonly.d.ts' {
+  /**
+    The `readonly` helper let's you specify that a binding is one-way only,
+    instead of two-way.
+    When you pass a `readonly` binding from an outer context (e.g. parent component),
+    to to an inner context (e.g. child component), you are saying that changing that
+    property in the inner context does not change the value in the outer context.
+
+    To specify that a binding is read-only, when invoking the child `Component`:
+
+    ```app/components/my-parent.js
+    export default Component.extend({
+      totalClicks: 3
+    });
+    ```
+
+    ```app/templates/components/my-parent.hbs
+    {{log totalClicks}} // -> 3
+    <MyChild @childClickCount={{readonly totalClicks}} />
+    ```
+    ```
+    {{my-child childClickCount=(readonly totalClicks)}}
+    ```
+
+    Now, when you update `childClickCount`:
+
+    ```app/components/my-child.js
+    export default Component.extend({
+      click() {
+        this.incrementProperty('childClickCount');
+      }
+    });
+    ```
+
+    The value updates in the child component, but not the parent component:
+
+    ```app/templates/components/my-child.hbs
+    {{log childClickCount}} //-> 4
+    ```
+
+    ```app/templates/components/my-parent.hbs
+    {{log totalClicks}} //-> 3
+    <MyChild @childClickCount={{readonly totalClicks}} />
+    ```
+    or
+    ```app/templates/components/my-parent.hbs
+    {{log totalClicks}} //-> 3
+    {{my-child childClickCount=(readonly totalClicks)}}
+    ```
+
+    ### Objects and Arrays
+
+    When passing a property that is a complex object (e.g. object, array) instead of a primitive object (e.g. number, string),
+    only the reference to the object is protected using the readonly helper.
+    This means that you can change properties of the object both on the parent component, as well as the child component.
+    The `readonly` binding behaves similar to the `const` keyword in JavaScript.
+
+    Let's look at an example:
+
+    First let's set up the parent component:
+
+    ```app/components/my-parent.js
+    import Component from '@ember/component';
+
+    export default Component.extend({
+      clicks: null,
+
+      init() {
+        this._super(...arguments);
+        this.set('clicks', { total: 3 });
+      }
+    });
+    ```
+
+    ```app/templates/components/my-parent.hbs
+    {{log clicks.total}} //-> 3
+    <MyChild @childClicks={{readonly clicks}} />
+    ```
+    ```app/templates/components/my-parent.hbs
+    {{log clicks.total}} //-> 3
+    {{my-child childClicks=(readonly clicks)}}
+    ```
+
+    Now, if you update the `total` property of `childClicks`:
+
+    ```app/components/my-child.js
+    import Component from '@ember/component';
+
+    export default Component.extend({
+      click() {
+        this.get('clicks').incrementProperty('total');
+      }
+    });
+    ```
+
+    You will see the following happen:
+
+    ```app/templates/components/my-parent.hbs
+    {{log clicks.total}} //-> 4
+    <MyChild @childClicks={{readonly clicks}} />
+    ```
+    or
+    ```app/templates/components/my-parent.hbs
+    {{log clicks.total}} //-> 4
+    {{my-child childClicks=(readonly clicks)}}
+    ```
+
+    ```app/templates/components/my-child.hbs
+    {{log childClicks.total}} //-> 4
+    ```
+
+    @method readonly
+    @param {Object} [attr] the read-only attribute.
+    @for Ember.Templates.helpers
+    @private
+  */
+  const _default: object;
+  export default _default;
+}

package/types/stable/@ember/-internals/glimmer/lib/helpers/unbound.d.ts

@@ -0,0 +1,34 @@
+declare module '@ember/-internals/glimmer/lib/helpers/unbound.d.ts' {
+  /**
+  @module ember
+  */
+  /**
+    The `{{unbound}}` helper disconnects the one-way binding of a property,
+    essentially freezing its value at the moment of rendering. For example,
+    in this example the display of the variable `name` will not change even
+    if it is set with a new value:
+
+    ```handlebars
+    {{unbound this.name}}
+    ```
+
+    Like any helper, the `unbound` helper can accept a nested helper expression.
+    This allows for custom helpers to be rendered unbound:
+
+    ```handlebars
+    {{unbound (some-custom-helper)}}
+    {{unbound (capitalize this.name)}}
+    {{! You can use any helper, including unbound, in a nested expression }}
+    {{capitalize (unbound this.name)}}
+    ```
+
+    The `unbound` helper only accepts a single argument, and it return an
+    unbound value.
+
+    @method unbound
+    @for Ember.Templates.helpers
+    @public
+  */
+  const _default: object;
+  export default _default;
+}

package/types/stable/@ember/-internals/glimmer/lib/helpers/unique-id.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember/-internals/glimmer/lib/helpers/unique-id.d.ts' {
+  /**
+  @module ember
+  */
+  const _default: object;
+  export default _default;
+}

package/types/stable/@ember/-internals/glimmer/lib/modifiers/action.d.ts

@@ -0,0 +1,30 @@
+declare module '@ember/-internals/glimmer/lib/modifiers/action.d.ts' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type { CapturedNamedArguments, CapturedPositionalArguments } from '@glimmer/interfaces';
+  import type { UpdatableTag } from '@glimmer/validator';
+  import type { SimpleElement } from '@simple-dom/interface';
+  export let ActionHelper: {
+      registeredActions: Record<string, ActionState>;
+      registerAction(actionState: ActionState): number;
+      unregisterAction(actionState: ActionState): void;
+  };
+  export class ActionState {
+      element: SimpleElement;
+      owner: InternalOwner;
+      actionId: number;
+      actionName: any;
+      actionArgs: any;
+      namedArgs: CapturedNamedArguments;
+      positional: CapturedPositionalArguments;
+      implicitTarget: any;
+      eventName: any;
+      tag: UpdatableTag;
+      constructor(element: SimpleElement, owner: InternalOwner, actionId: number, actionArgs: any[], namedArgs: CapturedNamedArguments, positionalArgs: CapturedPositionalArguments);
+      getEventName(): unknown;
+      getActionArgs(): any[];
+      getTarget(): any;
+      handler(event: Event): boolean;
+  }
+  const _default: {};
+  export default _default;
+}

package/types/stable/@ember/-internals/glimmer/lib/modifiers/internal.d.ts

@@ -0,0 +1,33 @@
+declare module '@ember/-internals/glimmer/lib/modifiers/internal.d.ts' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type { CapturedArguments, Destroyable, InternalModifierManager as ModifierManager } from '@glimmer/interfaces';
+  import type { SimpleElement } from '@simple-dom/interface';
+  export default class InternalModifier {
+      protected owner: InternalOwner;
+      protected readonly element: Element;
+      protected readonly args: CapturedArguments;
+      static toString(): string;
+      constructor(owner: InternalOwner, element: Element, args: CapturedArguments);
+      install(): void;
+      remove(): void;
+      protected positional(index: number): unknown;
+      protected named(key: string): unknown;
+      toString(): string;
+  }
+  class InternalModifierState implements Destroyable {
+      readonly instance: InternalModifier;
+      constructor(instance: InternalModifier);
+  }
+  export class InternalModifierManager implements ModifierManager<InternalModifierState, typeof InternalModifier> {
+      private ModifierClass;
+      private name;
+      constructor(ModifierClass: typeof InternalModifier, name: string);
+      create(owner: InternalOwner, element: SimpleElement, _definition: unknown, args: CapturedArguments): InternalModifierState;
+      getTag(): null;
+      getDebugName(): string;
+      install({ instance }: InternalModifierState): void;
+      update(): void;
+      getDestroyable({ instance }: InternalModifierState): Destroyable;
+  }
+  export {};
+}

package/types/stable/@ember/-internals/glimmer/lib/modifiers/on.d.ts

@@ -0,0 +1,94 @@
+declare module '@ember/-internals/glimmer/lib/modifiers/on.d.ts' {
+  /**
+  @module ember
+  */
+  /**
+    The `{{on}}` modifier lets you easily add event listeners (it uses
+    [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+    internally).
+
+    For example, if you'd like to run a function on your component when a `<button>`
+    in the components template is clicked you might do something like:
+
+    ```app/components/like-post.hbs
+    <button {{on 'click' this.saveLike}}>Like this post!</button>
+    ```
+
+    ```app/components/like-post.js
+    import Component from '@glimmer/component';
+    import { action } from '@ember/object';
+
+    export default class LikePostComponent extends Component {
+      @action
+      saveLike() {
+        // someone likes your post!
+        // better send a request off to your server...
+      }
+    }
+    ```
+
+    ### Arguments
+
+    `{{on}}` accepts two positional arguments, and a few named arguments.
+
+    The positional arguments are:
+
+    - `event` -- the name to use when calling `addEventListener`
+    - `callback` -- the function to be passed to `addEventListener`
+
+    The named arguments are:
+
+    - capture -- a `true` value indicates that events of this type will be dispatched
+      to the registered listener before being dispatched to any EventTarget beneath it
+      in the DOM tree.
+    - once -- indicates that the listener should be invoked at most once after being
+      added. If true, the listener would be automatically removed when invoked.
+    - passive -- if `true`, indicates that the function specified by listener will never
+      call preventDefault(). If a passive listener does call preventDefault(), the user
+      agent will do nothing other than generate a console warning. See
+      [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
+      to learn more.
+
+    The callback function passed to `{{on}}` will receive any arguments that are passed
+    to the event handler. Most commonly this would be the `event` itself.
+
+    If you would like to pass additional arguments to the function you should use
+    the `{{fn}}` helper.
+
+    For example, in our example case above if you'd like to pass in the post that
+    was being liked when the button is clicked you could do something like:
+
+    ```app/components/like-post.hbs
+    <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
+    ```
+
+    In this case, the `saveLike` function will receive two arguments: the click event
+    and the value of `@post`.
+
+    ### Function Context
+
+    In the example above, we used `@action` to ensure that `likePost` is
+    properly bound to the `items-list`, but let's explore what happens if we
+    left out `@action`:
+
+    ```app/components/like-post.js
+    import Component from '@glimmer/component';
+
+    export default class LikePostComponent extends Component {
+      saveLike() {
+        // ...snip...
+      }
+    }
+    ```
+
+    In this example, when the button is clicked `saveLike` will be invoked,
+    it will **not** have access to the component instance. In other
+    words, it will have no `this` context, so please make sure your functions
+    are bound (via `@action` or other means) before passing into `on`!
+
+    @method on
+    @for Ember.Templates.helpers
+    @public
+    @since 3.11.0
+  */
+}

package/types/stable/@ember/-internals/glimmer/lib/renderer.d.ts

@@ -0,0 +1,96 @@
+declare module '@ember/-internals/glimmer/lib/renderer.d.ts' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type { Bounds, CompileTimeCompilationContext, Cursor, DebugRenderTree, DynamicScope as GlimmerDynamicScope, ElementBuilder, Environment, Option, RenderResult, RuntimeContext, Template, TemplateFactory } from '@glimmer/interfaces';
+  import type { Reference } from '@glimmer/reference';
+  import type { CurriedValue } from '@glimmer/runtime';
+  import { clientBuilder } from '@glimmer/runtime';
+  import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
+  import RSVP from 'rsvp';
+  import type Component from './component';
+  import { BOUNDS } from './component-managers/curly';
+  import ResolverImpl from './resolver';
+  import type { OutletState } from './utils/outlet';
+  import OutletView from './views/outlet';
+  export type IBuilder = (env: Environment, cursor: Cursor) => ElementBuilder;
+  export interface View {
+      parentView: Option<View>;
+      renderer: Renderer;
+      tagName: string | null;
+      elementId: string | null;
+      isDestroying: boolean;
+      isDestroyed: boolean;
+      [BOUNDS]: Bounds | null;
+  }
+  export class DynamicScope implements GlimmerDynamicScope {
+      view: View | null;
+      outletState: Reference<OutletState | undefined>;
+      constructor(view: View | null, outletState: Reference<OutletState | undefined>);
+      child(): DynamicScope;
+      get(key: 'outletState'): Reference<OutletState | undefined>;
+      set(key: 'outletState', value: Reference<OutletState | undefined>): Reference<OutletState | undefined>;
+  }
+  class RootState {
+      root: Component | OutletView;
+      runtime: RuntimeContext;
+      id: string;
+      result: RenderResult | undefined;
+      destroyed: boolean;
+      render: () => void;
+      constructor(root: Component | OutletView, runtime: RuntimeContext, context: CompileTimeCompilationContext, owner: InternalOwner, template: Template, self: Reference<unknown>, parentElement: SimpleElement, dynamicScope: DynamicScope, builder: IBuilder);
+      isFor(possibleRoot: unknown): boolean;
+      destroy(): void;
+  }
+  export function _resetRenderers(): void;
+  export function renderSettled(): RSVP.Promise<void>;
+  interface ViewRegistry {
+      [viewId: string]: unknown;
+  }
+  export class Renderer {
+      private _rootTemplate;
+      private _viewRegistry;
+      private _roots;
+      private _removedRoots;
+      private _builder;
+      private _inRenderTransaction;
+      private _owner;
+      private _context;
+      private _runtime;
+      private _lastRevision;
+      private _destroyed;
+      /** @internal */
+      _isInteractive: boolean;
+      readonly _runtimeResolver: ResolverImpl;
+      static create(props: {
+          _viewRegistry: any;
+      }): Renderer;
+      constructor(owner: InternalOwner, document: SimpleDocument, env: {
+          isInteractive: boolean;
+          hasDOM: boolean;
+      }, rootTemplate: TemplateFactory, viewRegistry: ViewRegistry, builder?: typeof clientBuilder);
+      get debugRenderTree(): DebugRenderTree;
+      appendOutletView(view: OutletView, target: SimpleElement): void;
+      appendTo(view: Component, target: SimpleElement): void;
+      _appendDefinition(root: OutletView | Component, definition: CurriedValue, target: SimpleElement): void;
+      rerender(): void;
+      register(view: any): void;
+      unregister(view: any): void;
+      remove(view: Component): void;
+      cleanupRootFor(view: unknown): void;
+      destroy(): void;
+      getElement(view: View): Option<SimpleElement>;
+      getBounds(view: View): {
+          parentElement: SimpleElement;
+          firstNode: SimpleNode;
+          lastNode: SimpleNode;
+      };
+      createElement(tagName: string): SimpleElement;
+      _renderRoot(root: RootState): void;
+      _renderRoots(): void;
+      _renderRootsTransaction(): void;
+      _clearAllRoots(): void;
+      _scheduleRevalidate(): void;
+      _isValid(): boolean;
+      _revalidate(): void;
+  }
+  export {};
+}

package/types/stable/@ember/-internals/glimmer/lib/resolver.d.ts

@@ -0,0 +1,16 @@
+declare module '@ember/-internals/glimmer/lib/resolver.d.ts' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type { CompileTimeResolver, HelperDefinitionState, ModifierDefinitionState, Option, ResolvedComponentDefinition, RuntimeResolver } from '@glimmer/interfaces';
+  const BUILTIN_KEYWORD_MODIFIERS: Record<string, ModifierDefinitionState>;
+  export default class ResolverImpl implements RuntimeResolver<InternalOwner>, CompileTimeResolver<InternalOwner> {
+      private componentDefinitionCache;
+      lookupPartial(): null;
+      lookupHelper(name: string, owner: InternalOwner): Option<HelperDefinitionState>;
+      lookupBuiltInHelper(name: string): HelperDefinitionState | null;
+      lookupModifier(name: string, owner: InternalOwner): Option<ModifierDefinitionState>;
+      lookupBuiltInModifier<K extends keyof typeof BUILTIN_KEYWORD_MODIFIERS>(name: K): typeof BUILTIN_KEYWORD_MODIFIERS[K];
+      lookupBuiltInModifier(name: string): null;
+      lookupComponent(name: string, owner: InternalOwner): ResolvedComponentDefinition | null;
+  }
+  export {};
+}

package/types/stable/@ember/-internals/glimmer/lib/setup-registry.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/setup-registry.d.ts' {
+  import type { Registry } from '@ember/-internals/container';
+  export function setupApplicationRegistry(registry: Registry): void;
+  export function setupEngineRegistry(registry: Registry): void;
+}

package/types/stable/@ember/-internals/glimmer/lib/syntax/in-element.d.ts

@@ -0,0 +1,46 @@
+declare module '@ember/-internals/glimmer/lib/syntax/in-element.d.ts' {
+  /**
+   @module ember
+   */
+  /**
+   The `in-element` helper renders its block content outside of the regular flow,
+   into a DOM element given by its `destinationElement` positional argument.
+
+   Common use cases - often referred to as "portals" or "wormholes" - are rendering
+   dropdowns, modals or tooltips close to the root of the page to bypass CSS overflow
+   rules, or to render content to parts of the page that are outside of the control
+   of the Ember app itself (e.g. embedded into a static or server rendered HTML page).
+
+   ```handlebars
+   {{#in-element this.destinationElement}}
+     <div>Some content</div>
+   {{/in-element}}
+   ```
+
+   ### Arguments
+
+   `{{in-element}}` requires a single positional argument:
+
+   - `destinationElement` -- the DOM element to render into. It must exist at the time
+   of rendering.
+
+   It also supports an optional named argument:
+
+   - `insertBefore` -- by default the DOM element's content is replaced when used as
+   `destinationElement`. Passing `null` to `insertBefore` changes the behaviour to
+   append the block content to the end of any existing content. Any other value than
+   `null` is currently not supported.
+
+       For example:
+
+       ```handlebars
+       {{#in-element this.destinationElement insertBefore=null}}
+         <div>Some content</div>
+       {{/in-element}}
+       ```
+
+   @method in-element
+   @for Ember.Templates.helpers
+   @public
+   */
+}

package/types/stable/@ember/-internals/glimmer/lib/syntax/let.d.ts

@@ -0,0 +1,54 @@
+declare module '@ember/-internals/glimmer/lib/syntax/let.d.ts' {
+  /**
+  @module ember
+  */
+  /**
+      The `let` helper receives one or more positional arguments and yields
+      them out as block params.
+
+      This allows the developer to introduce shorter names for certain computations
+      in the template.
+
+      This is especially useful if you are passing properties to a component
+      that receives a lot of options and you want to clean up the invocation.
+
+      For the following example, the template receives a `post` object with
+      `content` and `title` properties.
+
+      We are going to call the `my-post` component, passing a title which is
+      the title of the post suffixed with the name of the blog, the content
+      of the post, and a series of options defined in-place.
+
+      ```handlebars
+      {{#let
+          (concat post.title ' | The Ember.js Blog')
+          post.content
+          (hash
+            theme="high-contrast"
+            enableComments=true
+          )
+          as |title content options|
+      }}
+        <MyPost @title={{title}} @content={{content}} @options={{options}} />
+      {{/let}}
+    ```
+   or
+    ```handlebars
+      {{#let
+          (concat post.title ' | The Ember.js Blog')
+          post.content
+          (hash
+            theme="high-contrast"
+            enableComments=true
+          )
+          as |title content options|
+      }}
+        {{my-post title=title content=content options=options}}
+      {{/let}}
+    ```
+
+    @method let
+    @for Ember.Templates.helpers
+    @public
+  */
+}

package/types/stable/@ember/-internals/glimmer/lib/syntax/mount.d.ts

@@ -0,0 +1,43 @@
+declare module '@ember/-internals/glimmer/lib/syntax/mount.d.ts' {
+  /**
+    The `{{mount}}` helper lets you embed a routeless engine in a template.
+    Mounting an engine will cause an instance to be booted and its `application`
+    template to be rendered.
+
+    For example, the following template mounts the `ember-chat` engine:
+
+    ```handlebars
+    {{! application.hbs }}
+    {{mount "ember-chat"}}
+    ```
+
+    Additionally, you can also pass in a `model` argument that will be
+    set as the engines model. This can be an existing object:
+
+    ```
+    <div>
+      {{mount 'admin' model=userSettings}}
+    </div>
+    ```
+
+    Or an inline `hash`, and you can even pass components:
+
+    ```
+    <div>
+      <h1>Application template!</h1>
+      {{mount 'admin' model=(hash
+          title='Secret Admin'
+          signInButton=(component 'sign-in-button')
+      )}}
+    </div>
+    ```
+
+    @method mount
+    @param {String} name Name of the engine to mount.
+    @param {Object} [model] Object that will be set as
+                            the model of the engine.
+    @for Ember.Templates.helpers
+    @public
+  */
+  export const mountHelper: object;
+}

package/types/stable/@ember/-internals/glimmer/lib/syntax/outlet.d.ts

@@ -0,0 +1,27 @@
+declare module '@ember/-internals/glimmer/lib/syntax/outlet.d.ts' {
+  /**
+    The `{{outlet}}` helper lets you specify where a child route will render in
+    your template. An important use of the `{{outlet}}` helper is in your
+    application's `application.hbs` file:
+
+    ```app/templates/application.hbs
+    <MyHeader />
+
+    <div class="my-dynamic-content">
+      <!-- this content will change based on the current route, which depends on the current URL -->
+      {{outlet}}
+    </div>
+
+    <MyFooter />
+    ```
+
+    See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
+    information on how your `route` interacts with the `{{outlet}}` helper.
+    Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
+
+    @method outlet
+    @for Ember.Templates.helpers
+    @public
+  */
+  export const outletHelper: object;
+}

package/types/stable/@ember/-internals/glimmer/lib/syntax/utils.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/syntax/utils.d.ts' {
+  import type { Core, Option } from '@glimmer/interfaces';
+  export function hashToArgs(hash: Option<Core.Hash>): Option<Core.Hash>;
+}

package/types/stable/@ember/-internals/glimmer/lib/template.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember/-internals/glimmer/lib/template.d.ts' {
+  import type { SerializedTemplateWithLazyBlock, Template, TemplateFactory } from '@glimmer/interfaces';
+  export type StaticTemplate = SerializedTemplateWithLazyBlock;
+  export type OwnedTemplate = Template;
+  export function isTemplateFactory(template: Template | TemplateFactory): template is TemplateFactory;
+}

package/types/stable/@ember/-internals/glimmer/lib/template_registry.d.ts

@@ -0,0 +1,11 @@
+declare module '@ember/-internals/glimmer/lib/template_registry.d.ts' {
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  export interface TemplatesRegistry {
+      [name: string]: TemplateFactory;
+  }
+  export function setTemplates(templates: TemplatesRegistry): void;
+  export function getTemplates(): TemplatesRegistry;
+  export function getTemplate(name: string): TemplateFactory | void;
+  export function hasTemplate(name: string): boolean;
+  export function setTemplate(name: string, template: TemplateFactory): TemplateFactory;
+}

package/types/stable/@ember/-internals/glimmer/lib/utils/bindings.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/-internals/glimmer/lib/utils/bindings.d.ts' {
+  import type { ElementOperations } from '@glimmer/interfaces';
+  import type { Reference } from '@glimmer/reference';
+  import type Component from '../component';
+  export function parseAttributeBinding(microsyntax: string): [string, string, boolean];
+  export function installAttributeBinding(component: Component, rootRef: Reference<Component>, parsed: [string, string, boolean], operations: ElementOperations): void;
+  export function createClassNameBindingRef(rootRef: Reference<Component>, microsyntax: string, operations: ElementOperations): void;
+  export function createSimpleClassNameBindingRef(inner: Reference, path?: string): Reference<string | null>;
+  export function createColonClassNameBindingRef(inner: Reference, truthy: string, falsy: string | undefined): Reference<string | undefined>;
+}