Skip to main content
On this pageFunctions

Ui/Combobox

Functions

create

functionsource
/**
 * Creates a checked single-select Combobox Block. Pass an Item Schema to
 * retain its exact Message and OutMessage payloads.
 */
(): Completed<string>

<Item extends string, ItemEncoded>(Item: ItemSchema<Item, ItemEncoded>): Completed<Item, ItemEncoded>

groupContiguous

functionsource
/** Groups items into contiguous segments by a key function. Adjacent items with the same key are collected into a single segment. */
<A>(
  items: readonly Array<A>,
  toKey: (item: A, index: number) => string
): readonly Array<Readonly<{
  items: readonly Array<A>
  key: string
}>>

inputId

functionsource
/**
 * Returns the bare DOM id of the combobox input, derived from the
 *  combobox's base id. Use this to associate an external label with the
 *  input via a native `<label for={Combobox.inputId(id)}>` or an
 *  `aria-labelledby` reference. Mirrors `inputSelector`, which returns the
 *  CSS selector form (`#${id}-input`) rather than the bare id.
 */
(id: string): string

Types

BaseViewInputsCommon

typesource
/**
 * Per-render view inputs passed to a Combobox connection's `embedView` method.
 * 
 *  The Combobox emits a `Selected({ value })` OutMessage on commit.
 *  Fold it through the Combobox connection: single-select
 *  stores the value, while multi-select toggles the value's membership.
 *  `restingInputValue` is the text the input returns to on
 *  close (the selection's display text for single-select, empty for
 *  multi-select). The selection is not part of this shared shape. Each
 *  variant adds its own selection field.
 */
type BaseViewInputsCommon = Readonly<{
  anchor: AnchorConfig
  ariaLabel: string
  ariaLabelledBy: string
  attributes: ReadonlyArray<ChildAttribute>
  backdropAttributes: ReadonlyArray<ChildAttribute>
  backdropClassName: string
  buttonAttributes: ReadonlyArray<ChildAttribute>
  buttonClassName: string
  buttonContent: Html
  className: string
  formName: string
  groupAttributes: ReadonlyArray<ChildAttribute>
  groupClassName: string
  groupToHeading: (groupKey: string) => GroupHeading | undefined
  inputAttributes: ReadonlyArray<ChildAttribute>
  inputClassName: string
  inputPlaceholder: string
  inputWrapperAttributes: ReadonlyArray<ChildAttribute>
  inputWrapperClassName: string
  isDisabled: boolean
  isInvalid: boolean
  isItemDisabled: (item: Item, index: number) => boolean
  isReadOnly: boolean
  itemGroupKey: (item: Item, index: number) => string
  items: ReadonlyArray<Item>
  itemsAttributes: ReadonlyArray<ChildAttribute>
  itemsClassName: string
  itemsScrollAttributes: ReadonlyArray<ChildAttribute>
  itemsScrollClassName: string
  itemToConfig: (item: Item, context: Readonly<{
    isActive: boolean
    isDisabled: boolean
    isReadOnly: boolean
    isSelected: boolean
  }>) => ItemConfig
  itemToDisplayText: (item: Item, index: number) => string
  itemToValue: (item: Item, index: number) => Item
  openOnFocus: boolean
  restingInputValue: string
  separatorAttributes: ReadonlyArray<ChildAttribute>
  separatorClassName: string
}>

GroupHeading

typesource
/** Configuration for a group heading rendered above a group of items. */
type GroupHeading = Readonly<{
  className: string
  content: Html
}>

InitConfig

typesource
/** Configuration for creating a single-select combobox model with `init`. `isAnimated` enables CSS transition coordination (default `false`). `isModal` locks page scroll and inerts other elements when open (default `false`). */
type InitConfig = BaseInitConfig

ItemConfig

typesource
/** Configuration for an individual combobox item's appearance. */
type ItemConfig = Readonly<{
  className: string
  content: Html
}>

ViewInputs

typesource
/** Per-render view inputs passed to the view via `h.block`'s `viewInputs` field. */
type ViewInputs = BaseViewInputsCommon<Item> & Readonly<{
  maybeSelectedValue: Option.Option<Item>
}>

Interfaces

Completed

interfacesource
/** A completed single-select Combobox Block refined to one Item Schema. */
interface Completed {
  [CompletionTypeId]: true
  [DefaultViewTypeId]: OwnedAuthoredView<BlockView<{
    activationTrigger: "Pointer" | "Keyboard"
    animation: {
      id: string
      isShowing: boolean
      transitionGeneration: number
      transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
    }
    id: string
    immediate: boolean
    inputValue: string
    isAnimated: boolean
    isModal: boolean
    isOpen: boolean
    maybeActiveItemIndex: Option<number>
    maybeLastPointerPosition: Option<{
      screenX: number
      screenY: number
    }>
    nullable: boolean
    selectInputOnFocus: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, AuthoredViewInputs<ViewInputs<Item>>, DefinitionViewRequirements<Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
    anchor: Struct<{
      gap: optional<unknown>
      isPlacementLocked: optional<unknown>
      offset: optional<unknown>
      padding: optional<unknown>
      placement: optional<unknown>
      portal: optional<unknown>
    }>
    buttonId: String
  }, {
    _tag: "CompletedAnchor"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/Anchor", unknown & unknown, {
      _tag: unknown
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
    _tag: "CompletedAttachPreventBlur"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachPreventBlur", Readonly<unknown>, {
      _tag: unknown
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
    _tag: "CompletedAttachSelectOnFocus"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachSelectOnFocus", Readonly<unknown>, {
      _tag: unknown
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
    _tag: "CompletedPortalBackdrop"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/PortalBackdrop", Readonly<unknown>, {
      _tag: unknown
    }>, never, never>
  }>>, readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: unknown
      isShowing: unknown
      transitionGeneration: unknown
      transitionState: unknown
    }>, MessageUnion<{
      CompletedWaitForPaint: unknown
      EndedAnimation: unknown
      Hid: unknown
      RequestedFinish: unknown
      RequestedHide: unknown
      RequestedImmediateReset: unknown
      RequestedResume: unknown
      RequestedShow: unknown
      RequestedToggle: unknown
      RequestedWaitForLeaveSettlement: unknown
      Showed: unknown
    }>, MessageUnion<{
      StartedLeaveAnimating: unknown
      TransitionedOut: unknown
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: unknown
      init: unknown
      operations: unknown
      update: unknown
      view: unknown
    }>>>>, Struct<{
      activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
      }>
      id: String
      immediate: Boolean
      inputValue: String
      isAnimated: Boolean
      isModal: Boolean
      isOpen: Boolean
      maybeActiveItemIndex: Option<Number>
      maybeLastPointerPosition: Option<Struct<{
        screenX: Number
        screenY: Number
      }>>
      nullable: Boolean
      selectInputOnFocus: Boolean
    }>, MessageUnion<Omit<{
      ActivatedItem: {
        activationTrigger: Literals<unknown>
        index: Number
        maybeImmediateSelection: Option<unknown>
      }
      BlurredInput: {
        isClearable: Boolean
        restingInputValue: String
      }
      Closed: {
        isClearable: Boolean
        restingInputValue: String
      }
      CompletedAnchor: {}
      CompletedAttachPreventBlur: {}
      CompletedAttachSelectOnFocus: {}
      CompletedClickItem: {}
      CompletedDetectMovementOrAnimationEnd: {
        generation: Number
      }
      CompletedFocusInput: {}
      CompletedInertOthers: {}
      CompletedLockScroll: {}
      CompletedPortalBackdrop: {}
      CompletedRestoreInert: {}
      CompletedScrollItemIntoView: {}
      CompletedUnlockScroll: {}
      DeactivatedItem: {}
      MovedPointerOverItem: {
        index: Number
        screenX: Number
        screenY: Number
      }
      Opened: {
        maybeActiveItemIndex: Option<unknown>
      }
      PressedToggleButton: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedClose: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedItemClick: {
        index: Number
      }
      RequestedOpen: {}
      RequestedSelectItem: {
        displayText: String
        item: ItemSchema<unknown, unknown>
      }
      SelectedItem: {
        displayText: String
        item: ItemSchema<unknown, unknown>
        wasSelected: Boolean
      }
      SuppressedEmptyItemNavigation: {}
      SuppressedItemCommit: {}
      UpdatedInputValue: {
        value: String
      }
    }, "RequestedSelectItem" | "ActivatedItem" | "SelectedItem"> & Readonly<{
      ActivatedItem: Omit<unknown, unknown> & Readonly<unknown>
      RequestedSelectItem: Omit<unknown, unknown> & Readonly<unknown>
      SelectedItem: Omit<unknown, unknown> & Readonly<unknown>
    }>>, OutMessageSchema<Item, ItemEncoded>, {
      field: "animation"
      init: false
    }, never, {
      fold: OutMessageFold<{
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }, DefinedCaseSteps<{
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: unknown | unknown | unknown | unknown | unknown
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: unknown
          screenY: unknown
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, {
        StartedLeaveAnimating: (__namedParameters: {
          _tag: unknown
          generation: unknown
        }) => NoInfer<unknown>
        TransitionedOut: DefineStepNoop<{
          activationTrigger: unknown
          animation: unknown
          id: unknown
          immediate: unknown
          inputValue: unknown
          isAnimated: unknown
          isModal: unknown
          isOpen: unknown
          maybeActiveItemIndex: unknown
          maybeLastPointerPosition: unknown
          nullable: unknown
          selectInputOnFocus: unknown
        }>
      }>, readonly []>
    }>
  ]>>, Owner<"Combobox", true>, {
    activationTrigger: "Pointer" | "Keyboard"
    animation: {
      id: string
      isShowing: boolean
      transitionGeneration: number
      transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
    }
    id: string
    immediate: boolean
    inputValue: string
    isAnimated: boolean
    isModal: boolean
    isOpen: boolean
    maybeActiveItemIndex: Option<number>
    maybeLastPointerPosition: Option<{
      screenX: number
      screenY: number
    }>
    nullable: boolean
    selectInputOnFocus: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, DefinitionViewRequirements<Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
    anchor: Struct<{
      gap: optional<Number>
      isPlacementLocked: optional<Boolean>
      offset: optional<Number>
      padding: optional<Union<unknown>>
      placement: optional<Literals<unknown>>
      portal: optional<Boolean>
    }>
    buttonId: String
  }, {
    _tag: "CompletedAnchor"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/Anchor", Readonly<unknown> & {
      anchor: unknown
      buttonId: unknown
    }, {
      _tag: "CompletedAnchor"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
    _tag: "CompletedAttachPreventBlur"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachPreventBlur", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }>, {
      _tag: "CompletedAttachPreventBlur"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
    _tag: "CompletedAttachSelectOnFocus"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachSelectOnFocus", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }>, {
      _tag: "CompletedAttachSelectOnFocus"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
    _tag: "CompletedPortalBackdrop"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/PortalBackdrop", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }>, {
      _tag: "CompletedPortalBackdrop"
    }>, never, never>
  }>>, readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<unknown>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: unknown
      }
      EndedAnimation: {
        generation: unknown
      }
      Hid: {}
      RequestedFinish: {
        generation: unknown
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: unknown
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<unknown, unknown, unknown>
      init: (args: unknown) => unknown
      operations: Readonly<unknown>
      update: (model: unknown, message: unknown) => unknown
      view: OwnedAuthoredView<unknown, unknown, unknown, unknown, unknown>
    }>>>>, Struct<{
      activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
      }>
      id: String
      immediate: Boolean
      inputValue: String
      isAnimated: Boolean
      isModal: Boolean
      isOpen: Boolean
      maybeActiveItemIndex: Option<Number>
      maybeLastPointerPosition: Option<Struct<{
        screenX: Number
        screenY: Number
      }>>
      nullable: Boolean
      selectInputOnFocus: Boolean
    }>, MessageUnion<Omit<{
      ActivatedItem: {
        activationTrigger: Literals<readonly [unknown, unknown]>
        index: Number
        maybeImmediateSelection: Option<Struct<unknown>>
      }
      BlurredInput: {
        isClearable: Boolean
        restingInputValue: String
      }
      Closed: {
        isClearable: Boolean
        restingInputValue: String
      }
      CompletedAnchor: {}
      CompletedAttachPreventBlur: {}
      CompletedAttachSelectOnFocus: {}
      CompletedClickItem: {}
      CompletedDetectMovementOrAnimationEnd: {
        generation: Number
      }
      CompletedFocusInput: {}
      CompletedInertOthers: {}
      CompletedLockScroll: {}
      CompletedPortalBackdrop: {}
      CompletedRestoreInert: {}
      CompletedScrollItemIntoView: {}
      CompletedUnlockScroll: {}
      DeactivatedItem: {}
      MovedPointerOverItem: {
        index: Number
        screenX: Number
        screenY: Number
      }
      Opened: {
        maybeActiveItemIndex: Option<Number>
      }
      PressedToggleButton: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedClose: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedItemClick: {
        index: Number
      }
      RequestedOpen: {}
      RequestedSelectItem: {
        displayText: String
        item: ItemSchema<string, string>
      }
      SelectedItem: {
        displayText: String
        item: ItemSchema<string, string>
        wasSelected: Boolean
      }
      SuppressedEmptyItemNavigation: {}
      SuppressedItemCommit: {}
      UpdatedInputValue: {
        value: String
      }
    }, "RequestedSelectItem" | "ActivatedItem" | "SelectedItem"> & Readonly<{
      ActivatedItem: Omit<{
        activationTrigger: unknown
        index: unknown
        maybeImmediateSelection: unknown
      }, "maybeImmediateSelection"> & Readonly<{
        maybeImmediateSelection: unknown
      }>
      RequestedSelectItem: Omit<{
        displayText: unknown
        item: unknown
      }, "item"> & Readonly<{
        item: unknown
      }>
      SelectedItem: Omit<{
        displayText: unknown
        item: unknown
        wasSelected: unknown
      }, "item"> & Readonly<{
        item: unknown
      }>
    }>>, OutMessageSchema<Item, ItemEncoded>, {
      field: "animation"
      init: false
    }, never, {
      fold: OutMessageFold<{
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }, DefinedCaseSteps<{
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, {
        StartedLeaveAnimating: (__namedParameters: {
          _tag: "StartedLeaveAnimating"
          generation: number
        }) => NoInfer<DefinedStep<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown>>
        TransitionedOut: DefineStepNoop<{
          activationTrigger: unknown | unknown
          animation: {
            id: unknown
            isShowing: unknown
            transitionGeneration: unknown
            transitionState: unknown
          }
          id: string
          immediate: boolean
          inputValue: string
          isAnimated: boolean
          isModal: boolean
          isOpen: boolean
          maybeActiveItemIndex: Option<unknown>
          maybeLastPointerPosition: Option<unknown>
          nullable: boolean
          selectInputOnFocus: boolean
        }>
      }>, readonly []>
    }>
  ]>>
  bindings: readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: Number
      }
      EndedAnimation: {
        generation: Number
      }
      Hid: {}
      RequestedFinish: {
        generation: Number
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: Number
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<Handler<unknown, unknown, unknown> | Handler<unknown, unknown, unknown>, never, never>
      init: (args: [config: Readonly<unknown>]) => Return<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, never>
      operations: Readonly<{
        requestFinish: (model: unknown, args: unknown) => unknown
        requestHide: (model: unknown, args: unknown) => unknown
        requestImmediateReset: (model: unknown, args: unknown) => unknown
        requestResume: (model: unknown, args: unknown) => unknown
        requestShow: (model: unknown, args: unknown) => unknown
        requestToggle: (model: unknown, args: unknown) => unknown
        requestWaitForLeaveSettlement: (model: unknown, args: unknown) => unknown
      }>
      update: (model: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: unknown | unknown | unknown | unknown | unknown
      }, message: {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
        generation: unknown
      }) => ReturnWithOutMessage<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, unknown | unknown, unknown | unknown>
      view: OwnedAuthoredView<BlockView<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, Readonly<unknown>, never>, Owner<"Animation", true>, {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: unknown | unknown | unknown | unknown | unknown
      }, {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
        generation: unknown
      }, never>
    }>>>>, Struct<{
      activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
      }>
      id: String
      immediate: Boolean
      inputValue: String
      isAnimated: Boolean
      isModal: Boolean
      isOpen: Boolean
      maybeActiveItemIndex: Option<Number>
      maybeLastPointerPosition: Option<Struct<{
        screenX: Number
        screenY: Number
      }>>
      nullable: Boolean
      selectInputOnFocus: Boolean
    }>, MessageUnion<Omit<{
      ActivatedItem: {
        activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
        index: Number
        maybeImmediateSelection: Option<Struct<{
          item: ItemSchema<unknown, unknown>
        }>>
      }
      BlurredInput: {
        isClearable: Boolean
        restingInputValue: String
      }
      Closed: {
        isClearable: Boolean
        restingInputValue: String
      }
      CompletedAnchor: {}
      CompletedAttachPreventBlur: {}
      CompletedAttachSelectOnFocus: {}
      CompletedClickItem: {}
      CompletedDetectMovementOrAnimationEnd: {
        generation: Number
      }
      CompletedFocusInput: {}
      CompletedInertOthers: {}
      CompletedLockScroll: {}
      CompletedPortalBackdrop: {}
      CompletedRestoreInert: {}
      CompletedScrollItemIntoView: {}
      CompletedUnlockScroll: {}
      DeactivatedItem: {}
      MovedPointerOverItem: {
        index: Number
        screenX: Number
        screenY: Number
      }
      Opened: {
        maybeActiveItemIndex: Option<Number>
      }
      PressedToggleButton: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedClose: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedItemClick: {
        index: Number
      }
      RequestedOpen: {}
      RequestedSelectItem: {
        displayText: String
        item: ItemSchema<string, string>
      }
      SelectedItem: {
        displayText: String
        item: ItemSchema<string, string>
        wasSelected: Boolean
      }
      SuppressedEmptyItemNavigation: {}
      SuppressedItemCommit: {}
      UpdatedInputValue: {
        value: String
      }
    }, "RequestedSelectItem" | "ActivatedItem" | "SelectedItem"> & Readonly<{
      ActivatedItem: Omit<{
        activationTrigger: Literals<readonly [unknown, unknown]>
        index: Number
        maybeImmediateSelection: Option<Struct<unknown>>
      }, "maybeImmediateSelection"> & Readonly<{
        maybeImmediateSelection: Option<Struct<unknown>>
      }>
      RequestedSelectItem: Omit<{
        displayText: String
        item: ItemSchema<string, string>
      }, "item"> & Readonly<{
        item: ItemSchema<Item, ItemEncoded>
      }>
      SelectedItem: Omit<{
        displayText: String
        item: ItemSchema<string, string>
        wasSelected: Boolean
      }, "item"> & Readonly<{
        item: ItemSchema<Item, ItemEncoded>
      }>
    }>>, OutMessageSchema<Item, ItemEncoded>, {
      field: "animation"
      init: false
    }, never, {
      fold: OutMessageFold<{
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }, DefinedCaseSteps<{
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, {
        StartedLeaveAnimating: (__namedParameters: {
          _tag: "StartedLeaveAnimating"
          generation: number
        }) => NoInfer<DefinedStep<{
          activationTrigger: unknown | unknown
          animation: {
            id: unknown
            isShowing: unknown
            transitionGeneration: unknown
            transitionState: unknown
          }
          id: string
          immediate: boolean
          inputValue: string
          isAnimated: boolean
          isModal: boolean
          isOpen: boolean
          maybeActiveItemIndex: Option<unknown>
          maybeLastPointerPosition: Option<unknown>
          nullable: boolean
          selectInputOnFocus: boolean
        }, {
          _tag: "CompletedDetectMovementOrAnimationEnd"
          generation: number
        }, readonly [], never, Handler<"Combobox/DetectMovementOrAnimationEnd", {
          generation: unknown
          id: unknown
        }, {
          _tag: unknown
          generation: unknown
        }>, never, "None", never>>
        TransitionedOut: DefineStepNoop<{
          activationTrigger: "Pointer" | "Keyboard"
          animation: {
            id: string
            isShowing: boolean
            transitionGeneration: number
            transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
          }
          id: string
          immediate: boolean
          inputValue: string
          isAnimated: boolean
          isModal: boolean
          isOpen: boolean
          maybeActiveItemIndex: Option<number>
          maybeLastPointerPosition: Option<{
            screenX: number
            screenY: number
          }>
          nullable: boolean
          selectInputOnFocus: boolean
        }>
      }>, readonly []>
    }>
  ]
  EffectsLayer: CompleteEffectsLayer<Layer<Handler<"Combobox/LockScroll", void, {
    _tag: "CompletedLockScroll"
  }> | Handler<"Combobox/UnlockScroll", void, {
    _tag: "CompletedUnlockScroll"
  }> | Handler<"Combobox/InertOthers", {
    id: string
  }, {
    _tag: "CompletedInertOthers"
  }> | Handler<"Combobox/RestoreInert", {
    id: string
  }, {
    _tag: "CompletedRestoreInert"
  }> | Handler<"Combobox/FocusInput", {
    id: string
  }, {
    _tag: "CompletedFocusInput"
  }> | Handler<"Combobox/ScrollItemIntoView", {
    id: string
    index: number
  }, {
    _tag: "CompletedScrollItemIntoView"
  }> | Handler<"Combobox/ClickItem", {
    id: string
    index: number
  }, {
    _tag: "CompletedClickItem"
  }> | Handler<"Combobox/DetectMovementOrAnimationEnd", {
    generation: number
    id: string
  }, {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  }> | Handler<"Combobox/Anchor", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }> & {
    anchor: Anchor.AnchorConfig
    buttonId: string
  }, {
    _tag: "CompletedAnchor"
  }> | Handler<"Combobox/AttachPreventBlur", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }>, {
    _tag: "CompletedAttachPreventBlur"
  }> | Handler<"Combobox/AttachSelectOnFocus", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }>, {
    _tag: "CompletedAttachSelectOnFocus"
  }> | Handler<"Combobox/PortalBackdrop", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }>, {
    _tag: "CompletedPortalBackdrop"
  }>, never, never>, readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: Number
      }
      EndedAnimation: {
        generation: Number
      }
      Hid: {}
      RequestedFinish: {
        generation: Number
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: Number
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<unknown | unknown, never, never>
      init: (args: [config: unknown]) => Return<unknown, unknown, unknown>
      operations: Readonly<{
        requestFinish: unknown
        requestHide: unknown
        requestImmediateReset: unknown
        requestResume: unknown
        requestShow: unknown
        requestToggle: unknown
        requestWaitForLeaveSettlement: unknown
      }>
      update: (model: {
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, message: unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown) => ReturnWithOutMessage<unknown, unknown, unknown, unknown>
      view: OwnedAuthoredView<BlockView<unknown, unknown, unknown, unknown>, Owner<unknown, unknown>, {
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, never>
    }>>>>, Struct<{
      activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
      }>
      id: String
      immediate: Boolean
      inputValue: String
      isAnimated: Boolean
      isModal: Boolean
      isOpen: Boolean
      maybeActiveItemIndex: Option<Number>
      maybeLastPointerPosition: Option<Struct<{
        screenX: Number
        screenY: Number
      }>>
      nullable: Boolean
      selectInputOnFocus: Boolean
    }>, MessageUnion<Omit<{
      ActivatedItem: {
        activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
        index: Number
        maybeImmediateSelection: Option<Struct<{
          item: unknown
        }>>
      }
      BlurredInput: {
        isClearable: Boolean
        restingInputValue: String
      }
      Closed: {
        isClearable: Boolean
        restingInputValue: String
      }
      CompletedAnchor: {}
      CompletedAttachPreventBlur: {}
      CompletedAttachSelectOnFocus: {}
      CompletedClickItem: {}
      CompletedDetectMovementOrAnimationEnd: {
        generation: Number
      }
      CompletedFocusInput: {}
      CompletedInertOthers: {}
      CompletedLockScroll: {}
      CompletedPortalBackdrop: {}
      CompletedRestoreInert: {}
      CompletedScrollItemIntoView: {}
      CompletedUnlockScroll: {}
      DeactivatedItem: {}
      MovedPointerOverItem: {
        index: Number
        screenX: Number
        screenY: Number
      }
      Opened: {
        maybeActiveItemIndex: Option<Number>
      }
      PressedToggleButton: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedClose: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedItemClick: {
        index: Number
      }
      RequestedOpen: {}
      RequestedSelectItem: {
        displayText: String
        item: ItemSchema<string, string>
      }
      SelectedItem: {
        displayText: String
        item: ItemSchema<string, string>
        wasSelected: Boolean
      }
      SuppressedEmptyItemNavigation: {}
      SuppressedItemCommit: {}
      UpdatedInputValue: {
        value: String
      }
    }, "RequestedSelectItem" | "ActivatedItem" | "SelectedItem"> & Readonly<{
      ActivatedItem: Omit<{
        activationTrigger: Literals<unknown>
        index: Number
        maybeImmediateSelection: Option<unknown>
      }, "maybeImmediateSelection"> & Readonly<{
        maybeImmediateSelection: Option<unknown>
      }>
      RequestedSelectItem: Omit<{
        displayText: String
        item: ItemSchema<unknown, unknown>
      }, "item"> & Readonly<{
        item: ItemSchema<unknown, unknown>
      }>
      SelectedItem: Omit<{
        displayText: String
        item: ItemSchema<unknown, unknown>
        wasSelected: Boolean
      }, "item"> & Readonly<{
        item: ItemSchema<unknown, unknown>
      }>
    }>>, OutMessageSchema<Item, ItemEncoded>, {
      field: "animation"
      init: false
    }, never, {
      fold: OutMessageFold<{
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }, DefinedCaseSteps<{
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, {
        StartedLeaveAnimating: (__namedParameters: {
          _tag: "StartedLeaveAnimating"
          generation: number
        }) => NoInfer<DefinedStep<{
          activationTrigger: unknown
          animation: unknown
          id: unknown
          immediate: unknown
          inputValue: unknown
          isAnimated: unknown
          isModal: unknown
          isOpen: unknown
          maybeActiveItemIndex: unknown
          maybeLastPointerPosition: unknown
          nullable: unknown
          selectInputOnFocus: unknown
        }, {
          _tag: unknown
          generation: unknown
        }, readonly [], never, Handler<unknown, unknown, unknown>, never, "None", never>>
        TransitionedOut: DefineStepNoop<{
          activationTrigger: "Pointer" | "Keyboard"
          animation: {
            id: string
            isShowing: boolean
            transitionGeneration: number
            transitionState: unknown | unknown | unknown | unknown | unknown
          }
          id: string
          immediate: boolean
          inputValue: string
          isAnimated: boolean
          isModal: boolean
          isOpen: boolean
          maybeActiveItemIndex: Option<number>
          maybeLastPointerPosition: Option<{
            screenX: unknown
            screenY: unknown
          }>
          nullable: boolean
          selectInputOnFocus: boolean
        }>
      }>, readonly []>
    }>
  ]>
  hostHandlers: readonly []
  init: (args: [
    config: Readonly<{
      id: string
      immediate: boolean
      isAnimated: boolean
      isModal: boolean
      nullable: boolean
      selectInputOnFocus: boolean
    }>
  ]) => Return<{
    activationTrigger: "Pointer" | "Keyboard"
    animation: {
      id: string
      isShowing: boolean
      transitionGeneration: number
      transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
    }
    id: string
    immediate: boolean
    inputValue: string
    isAnimated: boolean
    isModal: boolean
    isOpen: boolean
    maybeActiveItemIndex: Option<number>
    maybeLastPointerPosition: Option<{
      screenX: number
      screenY: number
    }>
    nullable: boolean
    selectInputOnFocus: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, never>
  makeView: DefineView<Owner<"Combobox", true>, {
    activationTrigger: "Pointer" | "Keyboard"
    animation: {
      id: string
      isShowing: boolean
      transitionGeneration: number
      transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
    }
    id: string
    immediate: boolean
    inputValue: string
    isAnimated: boolean
    isModal: boolean
    isOpen: boolean
    maybeActiveItemIndex: Option<number>
    maybeLastPointerPosition: Option<{
      screenX: number
      screenY: number
    }>
    nullable: boolean
    selectInputOnFocus: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, DefinitionViewRequirements<Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
    anchor: Struct<{
      gap: optional<Number>
      isPlacementLocked: optional<Boolean>
      offset: optional<Number>
      padding: optional<Union<unknown>>
      placement: optional<Literals<unknown>>
      portal: optional<Boolean>
    }>
    buttonId: String
  }, {
    _tag: "CompletedAnchor"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/Anchor", Readonly<unknown> & {
      anchor: unknown
      buttonId: unknown
    }, {
      _tag: "CompletedAnchor"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
    _tag: "CompletedAttachPreventBlur"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachPreventBlur", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }>, {
      _tag: "CompletedAttachPreventBlur"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
    _tag: "CompletedAttachSelectOnFocus"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachSelectOnFocus", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }>, {
      _tag: "CompletedAttachSelectOnFocus"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
    _tag: "CompletedPortalBackdrop"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/PortalBackdrop", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }>, {
      _tag: "CompletedPortalBackdrop"
    }>, never, never>
  }>>, readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<unknown>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: unknown
      }
      EndedAnimation: {
        generation: unknown
      }
      Hid: {}
      RequestedFinish: {
        generation: unknown
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: unknown
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<unknown, unknown, unknown>
      init: (args: unknown) => unknown
      operations: Readonly<unknown>
      update: (model: unknown, message: unknown) => unknown
      view: OwnedAuthoredView<unknown, unknown, unknown, unknown, unknown>
    }>>>>, Struct<{
      activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
      }>
      id: String
      immediate: Boolean
      inputValue: String
      isAnimated: Boolean
      isModal: Boolean
      isOpen: Boolean
      maybeActiveItemIndex: Option<Number>
      maybeLastPointerPosition: Option<Struct<{
        screenX: Number
        screenY: Number
      }>>
      nullable: Boolean
      selectInputOnFocus: Boolean
    }>, MessageUnion<Omit<{
      ActivatedItem: {
        activationTrigger: Literals<readonly [unknown, unknown]>
        index: Number
        maybeImmediateSelection: Option<Struct<unknown>>
      }
      BlurredInput: {
        isClearable: Boolean
        restingInputValue: String
      }
      Closed: {
        isClearable: Boolean
        restingInputValue: String
      }
      CompletedAnchor: {}
      CompletedAttachPreventBlur: {}
      CompletedAttachSelectOnFocus: {}
      CompletedClickItem: {}
      CompletedDetectMovementOrAnimationEnd: {
        generation: Number
      }
      CompletedFocusInput: {}
      CompletedInertOthers: {}
      CompletedLockScroll: {}
      CompletedPortalBackdrop: {}
      CompletedRestoreInert: {}
      CompletedScrollItemIntoView: {}
      CompletedUnlockScroll: {}
      DeactivatedItem: {}
      MovedPointerOverItem: {
        index: Number
        screenX: Number
        screenY: Number
      }
      Opened: {
        maybeActiveItemIndex: Option<Number>
      }
      PressedToggleButton: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedClose: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedItemClick: {
        index: Number
      }
      RequestedOpen: {}
      RequestedSelectItem: {
        displayText: String
        item: ItemSchema<string, string>
      }
      SelectedItem: {
        displayText: String
        item: ItemSchema<string, string>
        wasSelected: Boolean
      }
      SuppressedEmptyItemNavigation: {}
      SuppressedItemCommit: {}
      UpdatedInputValue: {
        value: String
      }
    }, "RequestedSelectItem" | "ActivatedItem" | "SelectedItem"> & Readonly<{
      ActivatedItem: Omit<{
        activationTrigger: unknown
        index: unknown
        maybeImmediateSelection: unknown
      }, "maybeImmediateSelection"> & Readonly<{
        maybeImmediateSelection: unknown
      }>
      RequestedSelectItem: Omit<{
        displayText: unknown
        item: unknown
      }, "item"> & Readonly<{
        item: unknown
      }>
      SelectedItem: Omit<{
        displayText: unknown
        item: unknown
        wasSelected: unknown
      }, "item"> & Readonly<{
        item: unknown
      }>
    }>>, OutMessageSchema<Item, ItemEncoded>, {
      field: "animation"
      init: false
    }, never, {
      fold: OutMessageFold<{
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }, DefinedCaseSteps<{
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, {
        StartedLeaveAnimating: (__namedParameters: {
          _tag: "StartedLeaveAnimating"
          generation: number
        }) => NoInfer<DefinedStep<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown>>
        TransitionedOut: DefineStepNoop<{
          activationTrigger: unknown | unknown
          animation: {
            id: unknown
            isShowing: unknown
            transitionGeneration: unknown
            transitionState: unknown
          }
          id: string
          immediate: boolean
          inputValue: string
          isAnimated: boolean
          isModal: boolean
          isOpen: boolean
          maybeActiveItemIndex: Option<unknown>
          maybeLastPointerPosition: Option<unknown>
          nullable: boolean
          selectInputOnFocus: boolean
        }>
      }>, readonly []>
    }>
  ]>>
  managedResources: Readonly<Record<never, never>> & Namespaced<"animation", {}>
  Message: Codec<Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: ItemEncoded
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: ItemEncoded
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: ItemEncoded
    wasSelected: boolean
  }, never, never> & LocalConstructors<MessageSchema<Item, ItemEncoded>>
  Model: Struct
  mounts: readonly Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
    anchor: Struct<{
      gap: optional<Number>
      isPlacementLocked: optional<Boolean>
      offset: optional<Number>
      padding: optional<Union<readonly [Number, Struct<unknown>]>>
      placement: optional<Literals<readonly ["top", "right", "bottom", "left", "top-start", "top-end", "right-start", "right-end", "bottom-start", "bottom-end", "left-start", "left-end"]>>
      portal: optional<Boolean>
    }>
    buttonId: String
  }, {
    _tag: "CompletedAnchor"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/Anchor", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown>
    }> & {
      anchor: Anchor.AnchorConfig
      buttonId: string
    }, {
      _tag: "CompletedAnchor"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
    _tag: "CompletedAttachPreventBlur"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachPreventBlur", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }>, {
      _tag: "CompletedAttachPreventBlur"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
    _tag: "CompletedAttachSelectOnFocus"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachSelectOnFocus", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }>, {
      _tag: "CompletedAttachSelectOnFocus"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
    _tag: "CompletedPortalBackdrop"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/PortalBackdrop", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }>, {
      _tag: "CompletedPortalBackdrop"
    }>, never, never>
  }>>
  operations: ImplementationExposedOperations<ImplementationValue>
  OutMessage: OutMessageSchema
  provideHandlers: never
  replaceEffectsLayer: ReplaceEffectsLayer<Owner<"Combobox", true>, Struct<{
    activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
    animation: Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>
    id: String
    immediate: Boolean
    inputValue: String
    isAnimated: Boolean
    isModal: Boolean
    isOpen: Boolean
    maybeActiveItemIndex: Option<Number>
    maybeLastPointerPosition: Option<Struct<{
      screenX: Number
      screenY: Number
    }>>
    nullable: Boolean
    selectInputOnFocus: Boolean
  }>, Codec<Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: ItemEncoded
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: ItemEncoded
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: ItemEncoded
    wasSelected: boolean
  }, never, never> & LocalConstructors<MessageSchema<Item, ItemEncoded>>, OutMessageSchema<Item, ItemEncoded>, Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
    anchor: Struct<{
      gap: optional<Number>
      isPlacementLocked: optional<Boolean>
      offset: optional<Number>
      padding: optional<Union<readonly [unknown, unknown]>>
      placement: optional<Literals<readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]>>
      portal: optional<Boolean>
    }>
    buttonId: String
  }, {
    _tag: "CompletedAnchor"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/Anchor", Readonly<{
      element: unknown
      viewStateChanges: unknown
    }> & {
      anchor: Anchor.AnchorConfig
      buttonId: string
    }, {
      _tag: "CompletedAnchor"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
    _tag: "CompletedAttachPreventBlur"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachPreventBlur", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown>
    }>, {
      _tag: "CompletedAttachPreventBlur"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
    _tag: "CompletedAttachSelectOnFocus"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/AttachSelectOnFocus", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown>
    }>, {
      _tag: "CompletedAttachSelectOnFocus"
    }>, never, never>
  }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
    _tag: "CompletedPortalBackdrop"
  }> & Readonly<{
    layer: Layer<Handler<"Combobox/PortalBackdrop", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown>
    }>, {
      _tag: "CompletedPortalBackdrop"
    }>, never, never>
  }>>, readonly [
    SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
    }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<Owner<"Animation", true>, Struct<{
      id: String
      isShowing: Boolean
      transitionGeneration: Number
      transitionState: Literals<readonly [unknown, unknown, unknown, unknown, unknown]>
    }>, MessageUnion<{
      CompletedWaitForPaint: {
        generation: Number
      }
      EndedAnimation: {
        generation: Number
      }
      Hid: {}
      RequestedFinish: {
        generation: Number
      }
      RequestedHide: {}
      RequestedImmediateReset: {}
      RequestedResume: {}
      RequestedShow: {}
      RequestedToggle: {}
      RequestedWaitForLeaveSettlement: {}
      Showed: {}
    }>, MessageUnion<{
      StartedLeaveAnimating: {
        generation: Number
      }
      TransitionedOut: {}
    }>, readonly [], readonly [], Readonly<{
      EffectsLayer: Layer<unknown | unknown, never, never>
      init: (args: [config: unknown]) => Return<unknown, unknown, unknown>
      operations: Readonly<{
        requestFinish: unknown
        requestHide: unknown
        requestImmediateReset: unknown
        requestResume: unknown
        requestShow: unknown
        requestToggle: unknown
        requestWaitForLeaveSettlement: unknown
      }>
      update: (model: {
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, message: unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown) => ReturnWithOutMessage<unknown, unknown, unknown, unknown>
      view: OwnedAuthoredView<BlockView<unknown, unknown, unknown, unknown>, Owner<unknown, unknown>, {
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }, unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown, never>
    }>>>>, Struct<{
      activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
      animation: Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<readonly ["Idle", "EnterStart", "EnterAnimating", "LeaveStart", "LeaveAnimating"]>
      }>
      id: String
      immediate: Boolean
      inputValue: String
      isAnimated: Boolean
      isModal: Boolean
      isOpen: Boolean
      maybeActiveItemIndex: Option<Number>
      maybeLastPointerPosition: Option<Struct<{
        screenX: Number
        screenY: Number
      }>>
      nullable: Boolean
      selectInputOnFocus: Boolean
    }>, MessageUnion<Omit<{
      ActivatedItem: {
        activationTrigger: Literals<readonly ["Pointer", "Keyboard"]>
        index: Number
        maybeImmediateSelection: Option<Struct<{
          item: unknown
        }>>
      }
      BlurredInput: {
        isClearable: Boolean
        restingInputValue: String
      }
      Closed: {
        isClearable: Boolean
        restingInputValue: String
      }
      CompletedAnchor: {}
      CompletedAttachPreventBlur: {}
      CompletedAttachSelectOnFocus: {}
      CompletedClickItem: {}
      CompletedDetectMovementOrAnimationEnd: {
        generation: Number
      }
      CompletedFocusInput: {}
      CompletedInertOthers: {}
      CompletedLockScroll: {}
      CompletedPortalBackdrop: {}
      CompletedRestoreInert: {}
      CompletedScrollItemIntoView: {}
      CompletedUnlockScroll: {}
      DeactivatedItem: {}
      MovedPointerOverItem: {
        index: Number
        screenX: Number
        screenY: Number
      }
      Opened: {
        maybeActiveItemIndex: Option<Number>
      }
      PressedToggleButton: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedClose: {
        isClearable: Boolean
        restingInputValue: String
      }
      RequestedItemClick: {
        index: Number
      }
      RequestedOpen: {}
      RequestedSelectItem: {
        displayText: String
        item: ItemSchema<string, string>
      }
      SelectedItem: {
        displayText: String
        item: ItemSchema<string, string>
        wasSelected: Boolean
      }
      SuppressedEmptyItemNavigation: {}
      SuppressedItemCommit: {}
      UpdatedInputValue: {
        value: String
      }
    }, "RequestedSelectItem" | "ActivatedItem" | "SelectedItem"> & Readonly<{
      ActivatedItem: Omit<{
        activationTrigger: Literals<unknown>
        index: Number
        maybeImmediateSelection: Option<unknown>
      }, "maybeImmediateSelection"> & Readonly<{
        maybeImmediateSelection: Option<unknown>
      }>
      RequestedSelectItem: Omit<{
        displayText: String
        item: ItemSchema<unknown, unknown>
      }, "item"> & Readonly<{
        item: ItemSchema<unknown, unknown>
      }>
      SelectedItem: Omit<{
        displayText: String
        item: ItemSchema<unknown, unknown>
        wasSelected: Boolean
      }, "item"> & Readonly<{
        item: ItemSchema<unknown, unknown>
      }>
    }>>, OutMessageSchema<Item, ItemEncoded>, {
      field: "animation"
      init: false
    }, never, {
      fold: OutMessageFold<{
        _tag: "StartedLeaveAnimating"
        generation: number
      } | {
        _tag: "TransitionedOut"
      }, DefinedCaseSteps<{
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, {
        StartedLeaveAnimating: (__namedParameters: {
          _tag: "StartedLeaveAnimating"
          generation: number
        }) => NoInfer<DefinedStep<{
          activationTrigger: unknown
          animation: unknown
          id: unknown
          immediate: unknown
          inputValue: unknown
          isAnimated: unknown
          isModal: unknown
          isOpen: unknown
          maybeActiveItemIndex: unknown
          maybeLastPointerPosition: unknown
          nullable: unknown
          selectInputOnFocus: unknown
        }, {
          _tag: unknown
          generation: unknown
        }, readonly [], never, Handler<unknown, unknown, unknown>, never, "None", never>>
        TransitionedOut: DefineStepNoop<{
          activationTrigger: "Pointer" | "Keyboard"
          animation: {
            id: string
            isShowing: boolean
            transitionGeneration: number
            transitionState: unknown | unknown | unknown | unknown | unknown
          }
          id: string
          immediate: boolean
          inputValue: string
          isAnimated: boolean
          isModal: boolean
          isOpen: boolean
          maybeActiveItemIndex: Option<number>
          maybeLastPointerPosition: Option<{
            screenX: unknown
            screenY: unknown
          }>
          nullable: boolean
          selectInputOnFocus: boolean
        }>
      }>, readonly []>
    }>
  ], Readonly<{
    EffectsLayer: Layer<Handler<"Combobox/LockScroll", void, {
      _tag: "CompletedLockScroll"
    }> | Handler<"Combobox/UnlockScroll", void, {
      _tag: "CompletedUnlockScroll"
    }> | Handler<"Combobox/InertOthers", {
      id: string
    }, {
      _tag: "CompletedInertOthers"
    }> | Handler<"Combobox/RestoreInert", {
      id: string
    }, {
      _tag: "CompletedRestoreInert"
    }> | Handler<"Combobox/FocusInput", {
      id: string
    }, {
      _tag: "CompletedFocusInput"
    }> | Handler<"Combobox/ScrollItemIntoView", {
      id: string
      index: number
    }, {
      _tag: "CompletedScrollItemIntoView"
    }> | Handler<"Combobox/ClickItem", {
      id: string
      index: number
    }, {
      _tag: "CompletedClickItem"
    }> | Handler<"Combobox/DetectMovementOrAnimationEnd", {
      generation: number
      id: string
    }, {
      _tag: "CompletedDetectMovementOrAnimationEnd"
      generation: number
    }> | Handler<"Combobox/Anchor", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }> & {
      anchor: Anchor.AnchorConfig
      buttonId: string
    }, {
      _tag: "CompletedAnchor"
    }> | Handler<"Combobox/AttachPreventBlur", Readonly<{
      element: Element
      viewStateChanges: Stream<"Live" | "Paused">
    }>, {
      _tag: "CompletedAttachPreventBlur"
    }> | Handler<"Combobox/AttachSelectOnFocus", Readonly<{
      element: Element
      viewStateChanges: Stream<"Live" | "Paused">
    }>, {
      _tag: "CompletedAttachSelectOnFocus"
    }> | Handler<"Combobox/PortalBackdrop", Readonly<{
      element: Element
      viewStateChanges: Stream<"Live" | "Paused">
    }>, {
      _tag: "CompletedPortalBackdrop"
    }>, never, never>
    init: (args: [
      config: Readonly<{
        id: string
        immediate: boolean
        isAnimated: boolean
        isModal: boolean
        nullable: boolean
        selectInputOnFocus: boolean
      }>
    ]) => Return<{
      activationTrigger: "Pointer" | "Keyboard"
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      immediate: boolean
      inputValue: string
      isAnimated: boolean
      isModal: boolean
      isOpen: boolean
      maybeActiveItemIndex: Option<number>
      maybeLastPointerPosition: Option<{
        screenX: number
        screenY: number
      }>
      nullable: boolean
      selectInputOnFocus: boolean
    }, Readonly<{
      _tag: "GotAnimationMessage"
      generation: number
      message: {
        _tag: "Showed"
      } | {
        _tag: "Hid"
      } | {
        _tag: "RequestedShow"
      } | {
        _tag: "RequestedHide"
      } | {
        _tag: "RequestedWaitForLeaveSettlement"
      } | {
        _tag: "RequestedFinish"
        generation: number
      } | {
        _tag: "RequestedToggle"
      } | {
        _tag: "RequestedResume"
      } | {
        _tag: "RequestedImmediateReset"
      } | {
        _tag: "CompletedWaitForPaint"
        generation: number
      } | {
        _tag: "EndedAnimation"
        generation: number
      }
      placement: "animation"
    }> | {
      _tag: "Opened"
      maybeActiveItemIndex: Option<number>
    } | {
      _tag: "Closed"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "RequestedOpen"
    } | {
      _tag: "RequestedClose"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "BlurredInput"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "DeactivatedItem"
    } | {
      _tag: "MovedPointerOverItem"
      index: number
      screenX: number
      screenY: number
    } | {
      _tag: "RequestedItemClick"
      index: number
    } | {
      _tag: "SuppressedItemCommit"
    } | {
      _tag: "SuppressedEmptyItemNavigation"
    } | {
      _tag: "CompletedLockScroll"
    } | {
      _tag: "CompletedUnlockScroll"
    } | {
      _tag: "CompletedInertOthers"
    } | {
      _tag: "CompletedRestoreInert"
    } | {
      _tag: "CompletedFocusInput"
    } | {
      _tag: "CompletedScrollItemIntoView"
    } | {
      _tag: "CompletedClickItem"
    } | {
      _tag: "UpdatedInputValue"
      value: string
    } | {
      _tag: "PressedToggleButton"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "CompletedAnchor"
    } | {
      _tag: "CompletedAttachPreventBlur"
    } | {
      _tag: "CompletedAttachSelectOnFocus"
    } | {
      _tag: "CompletedPortalBackdrop"
    } | {
      _tag: "CompletedDetectMovementOrAnimationEnd"
      generation: number
    } | {
      _tag: "RequestedSelectItem"
      displayText: string
      item: Item
    } | {
      _tag: "ActivatedItem"
      activationTrigger: "Pointer" | "Keyboard"
      index: number
      maybeImmediateSelection: Option<{
        item: Item
      }>
    } | {
      _tag: "SelectedItem"
      displayText: string
      item: Item
      wasSelected: boolean
    }, never>
    operations: Readonly<{
      requestClose: (model: {
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, args: [restingInputValue: string]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestOpen: (model: {
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, args: []) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestSelectItem: (model: {
        activationTrigger: "Pointer" | "Keyboard"
        animation: {
          id: string
          isShowing: boolean
          transitionGeneration: number
          transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
        }
        id: string
        immediate: boolean
        inputValue: string
        isAnimated: boolean
        isModal: boolean
        isOpen: boolean
        maybeActiveItemIndex: Option<number>
        maybeLastPointerPosition: Option<{
          screenX: number
          screenY: number
        }>
        nullable: boolean
        selectInputOnFocus: boolean
      }, args: [item: Item, displayText: string]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
    }>
    update: (message: Readonly<{
      _tag: "GotAnimationMessage"
      generation: number
      message: {
        _tag: "Showed"
      } | {
        _tag: "Hid"
      } | {
        _tag: "RequestedShow"
      } | {
        _tag: "RequestedHide"
      } | {
        _tag: "RequestedWaitForLeaveSettlement"
      } | {
        _tag: "RequestedFinish"
        generation: number
      } | {
        _tag: "RequestedToggle"
      } | {
        _tag: "RequestedResume"
      } | {
        _tag: "RequestedImmediateReset"
      } | {
        _tag: "CompletedWaitForPaint"
        generation: number
      } | {
        _tag: "EndedAnimation"
        generation: number
      }
      placement: "animation"
    }> | {
      _tag: "Opened"
      maybeActiveItemIndex: Option<number>
    } | {
      _tag: "Closed"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "RequestedOpen"
    } | {
      _tag: "RequestedClose"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "BlurredInput"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "DeactivatedItem"
    } | {
      _tag: "MovedPointerOverItem"
      index: number
      screenX: number
      screenY: number
    } | {
      _tag: "RequestedItemClick"
      index: number
    } | {
      _tag: "SuppressedItemCommit"
    } | {
      _tag: "SuppressedEmptyItemNavigation"
    } | {
      _tag: "CompletedLockScroll"
    } | {
      _tag: "CompletedUnlockScroll"
    } | {
      _tag: "CompletedInertOthers"
    } | {
      _tag: "CompletedRestoreInert"
    } | {
      _tag: "CompletedFocusInput"
    } | {
      _tag: "CompletedScrollItemIntoView"
    } | {
      _tag: "CompletedClickItem"
    } | {
      _tag: "UpdatedInputValue"
      value: string
    } | {
      _tag: "PressedToggleButton"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "CompletedAnchor"
    } | {
      _tag: "CompletedAttachPreventBlur"
    } | {
      _tag: "CompletedAttachSelectOnFocus"
    } | {
      _tag: "CompletedPortalBackdrop"
    } | {
      _tag: "CompletedDetectMovementOrAnimationEnd"
      generation: number
    } | {
      _tag: "RequestedSelectItem"
      displayText: string
      item: Item
    } | {
      _tag: "ActivatedItem"
      activationTrigger: "Pointer" | "Keyboard"
      index: number
      maybeImmediateSelection: Option<{
        item: Item
      }>
    } | {
      _tag: "SelectedItem"
      displayText: string
      item: Item
      wasSelected: boolean
    }) => (model: {
      activationTrigger: "Pointer" | "Keyboard"
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      immediate: boolean
      inputValue: string
      isAnimated: boolean
      isModal: boolean
      isOpen: boolean
      maybeActiveItemIndex: Option<number>
      maybeLastPointerPosition: Option<{
        screenX: number
        screenY: number
      }>
      nullable: boolean
      selectInputOnFocus: boolean
    }, context: []) => ReturnWithOutMessage<{
      activationTrigger: "Pointer" | "Keyboard"
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      immediate: boolean
      inputValue: string
      isAnimated: boolean
      isModal: boolean
      isOpen: boolean
      maybeActiveItemIndex: Option<number>
      maybeLastPointerPosition: Option<{
        screenX: number
        screenY: number
      }>
      nullable: boolean
      selectInputOnFocus: boolean
    }, Readonly<{
      _tag: "GotAnimationMessage"
      generation: number
      message: {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
      } | {
        _tag: unknown
        generation: unknown
      } | {
        _tag: unknown
        generation: unknown
      }
      placement: "animation"
    }> | {
      _tag: "Opened"
      maybeActiveItemIndex: Option<number>
    } | {
      _tag: "Closed"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "RequestedOpen"
    } | {
      _tag: "RequestedClose"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "BlurredInput"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "DeactivatedItem"
    } | {
      _tag: "MovedPointerOverItem"
      index: number
      screenX: number
      screenY: number
    } | {
      _tag: "RequestedItemClick"
      index: number
    } | {
      _tag: "SuppressedItemCommit"
    } | {
      _tag: "SuppressedEmptyItemNavigation"
    } | {
      _tag: "CompletedLockScroll"
    } | {
      _tag: "CompletedUnlockScroll"
    } | {
      _tag: "CompletedInertOthers"
    } | {
      _tag: "CompletedRestoreInert"
    } | {
      _tag: "CompletedFocusInput"
    } | {
      _tag: "CompletedScrollItemIntoView"
    } | {
      _tag: "CompletedClickItem"
    } | {
      _tag: "UpdatedInputValue"
      value: string
    } | {
      _tag: "PressedToggleButton"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "CompletedAnchor"
    } | {
      _tag: "CompletedAttachPreventBlur"
    } | {
      _tag: "CompletedAttachSelectOnFocus"
    } | {
      _tag: "CompletedPortalBackdrop"
    } | {
      _tag: "CompletedDetectMovementOrAnimationEnd"
      generation: number
    } | {
      _tag: "RequestedSelectItem"
      displayText: string
      item: Item
    } | {
      _tag: "ActivatedItem"
      activationTrigger: "Pointer" | "Keyboard"
      index: number
      maybeImmediateSelection: Option<{
        item: Item
      }>
    } | {
      _tag: "SelectedItem"
      displayText: string
      item: Item
      wasSelected: boolean
    }, OutMessage<Item>>
    view: OwnedAuthoredView<BlockView<{
      activationTrigger: "Pointer" | "Keyboard"
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      immediate: boolean
      inputValue: string
      isAnimated: boolean
      isModal: boolean
      isOpen: boolean
      maybeActiveItemIndex: Option<number>
      maybeLastPointerPosition: Option<{
        screenX: number
        screenY: number
      }>
      nullable: boolean
      selectInputOnFocus: boolean
    }, Readonly<{
      _tag: "GotAnimationMessage"
      generation: number
      message: {
        _tag: "Showed"
      } | {
        _tag: "Hid"
      } | {
        _tag: "RequestedShow"
      } | {
        _tag: "RequestedHide"
      } | {
        _tag: "RequestedWaitForLeaveSettlement"
      } | {
        _tag: "RequestedFinish"
        generation: number
      } | {
        _tag: "RequestedToggle"
      } | {
        _tag: "RequestedResume"
      } | {
        _tag: "RequestedImmediateReset"
      } | {
        _tag: "CompletedWaitForPaint"
        generation: number
      } | {
        _tag: "EndedAnimation"
        generation: number
      }
      placement: "animation"
    }> | {
      _tag: "Opened"
      maybeActiveItemIndex: Option<number>
    } | {
      _tag: "Closed"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "RequestedOpen"
    } | {
      _tag: "RequestedClose"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "BlurredInput"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "DeactivatedItem"
    } | {
      _tag: "MovedPointerOverItem"
      index: number
      screenX: number
      screenY: number
    } | {
      _tag: "RequestedItemClick"
      index: number
    } | {
      _tag: "SuppressedItemCommit"
    } | {
      _tag: "SuppressedEmptyItemNavigation"
    } | {
      _tag: "CompletedLockScroll"
    } | {
      _tag: "CompletedUnlockScroll"
    } | {
      _tag: "CompletedInertOthers"
    } | {
      _tag: "CompletedRestoreInert"
    } | {
      _tag: "CompletedFocusInput"
    } | {
      _tag: "CompletedScrollItemIntoView"
    } | {
      _tag: "CompletedClickItem"
    } | {
      _tag: "UpdatedInputValue"
      value: string
    } | {
      _tag: "PressedToggleButton"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "CompletedAnchor"
    } | {
      _tag: "CompletedAttachPreventBlur"
    } | {
      _tag: "CompletedAttachSelectOnFocus"
    } | {
      _tag: "CompletedPortalBackdrop"
    } | {
      _tag: "CompletedDetectMovementOrAnimationEnd"
      generation: number
    } | {
      _tag: "RequestedSelectItem"
      displayText: string
      item: Item
    } | {
      _tag: "ActivatedItem"
      activationTrigger: "Pointer" | "Keyboard"
      index: number
      maybeImmediateSelection: Option<{
        item: Item
      }>
    } | {
      _tag: "SelectedItem"
      displayText: string
      item: Item
      wasSelected: boolean
    }, AuthoredViewInputs<ViewInputs<Item>>, DefinitionViewRequirements<Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
      anchor: unknown
      buttonId: unknown
    }, {
      _tag: unknown
    }> & Readonly<{
      layer: unknown
    }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
      _tag: unknown
    }> & Readonly<{
      layer: unknown
    }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
      _tag: unknown
    }> & Readonly<{
      layer: unknown
    }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
      _tag: unknown
    }> & Readonly<{
      layer: unknown
    }>>, readonly [
      SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
        id: unknown
        isShowing: unknown
        transitionGeneration: unknown
        transitionState: unknown
      }>, () => AssemblyDraft<unknown>>, Struct<{
        activationTrigger: Literals<unknown>
        animation: Struct<unknown>
        id: String
        immediate: Boolean
        inputValue: String
        isAnimated: Boolean
        isModal: Boolean
        isOpen: Boolean
        maybeActiveItemIndex: Option<unknown>
        maybeLastPointerPosition: Option<unknown>
        nullable: Boolean
        selectInputOnFocus: Boolean
      }>, MessageUnion<Omit<unknown, unknown> & Readonly<unknown>>, OutMessageSchema<Item, ItemEncoded>, {
        field: "animation"
        init: false
      }, never, {
        fold: OutMessageFold<unknown | unknown, DefinedCaseSteps<unknown, unknown>, readonly []>
      }>
    ]>>, Owner<"Combobox", true>, {
      activationTrigger: "Pointer" | "Keyboard"
      animation: {
        id: string
        isShowing: boolean
        transitionGeneration: number
        transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
      }
      id: string
      immediate: boolean
      inputValue: string
      isAnimated: boolean
      isModal: boolean
      isOpen: boolean
      maybeActiveItemIndex: Option<number>
      maybeLastPointerPosition: Option<{
        screenX: number
        screenY: number
      }>
      nullable: boolean
      selectInputOnFocus: boolean
    }, Readonly<{
      _tag: "GotAnimationMessage"
      generation: number
      message: {
        _tag: "Showed"
      } | {
        _tag: "Hid"
      } | {
        _tag: "RequestedShow"
      } | {
        _tag: "RequestedHide"
      } | {
        _tag: "RequestedWaitForLeaveSettlement"
      } | {
        _tag: "RequestedFinish"
        generation: number
      } | {
        _tag: "RequestedToggle"
      } | {
        _tag: "RequestedResume"
      } | {
        _tag: "RequestedImmediateReset"
      } | {
        _tag: "CompletedWaitForPaint"
        generation: number
      } | {
        _tag: "EndedAnimation"
        generation: number
      }
      placement: "animation"
    }> | {
      _tag: "Opened"
      maybeActiveItemIndex: Option<number>
    } | {
      _tag: "Closed"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "RequestedOpen"
    } | {
      _tag: "RequestedClose"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "BlurredInput"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "DeactivatedItem"
    } | {
      _tag: "MovedPointerOverItem"
      index: number
      screenX: number
      screenY: number
    } | {
      _tag: "RequestedItemClick"
      index: number
    } | {
      _tag: "SuppressedItemCommit"
    } | {
      _tag: "SuppressedEmptyItemNavigation"
    } | {
      _tag: "CompletedLockScroll"
    } | {
      _tag: "CompletedUnlockScroll"
    } | {
      _tag: "CompletedInertOthers"
    } | {
      _tag: "CompletedRestoreInert"
    } | {
      _tag: "CompletedFocusInput"
    } | {
      _tag: "CompletedScrollItemIntoView"
    } | {
      _tag: "CompletedClickItem"
    } | {
      _tag: "UpdatedInputValue"
      value: string
    } | {
      _tag: "PressedToggleButton"
      isClearable: boolean
      restingInputValue: string
    } | {
      _tag: "CompletedAnchor"
    } | {
      _tag: "CompletedAttachPreventBlur"
    } | {
      _tag: "CompletedAttachSelectOnFocus"
    } | {
      _tag: "CompletedPortalBackdrop"
    } | {
      _tag: "CompletedDetectMovementOrAnimationEnd"
      generation: number
    } | {
      _tag: "RequestedSelectItem"
      displayText: string
      item: Item
    } | {
      _tag: "ActivatedItem"
      activationTrigger: "Pointer" | "Keyboard"
      index: number
      maybeImmediateSelection: Option<{
        item: Item
      }>
    } | {
      _tag: "SelectedItem"
      displayText: string
      item: Item
      wasSelected: boolean
    }, DefinitionViewRequirements<Array<LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
      anchor: Struct<unknown>
      buttonId: String
    }, {
      _tag: "CompletedAnchor"
    }> & Readonly<{
      layer: Layer<unknown, unknown, unknown>
    }> | LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
      _tag: "CompletedAttachPreventBlur"
    }> & Readonly<{
      layer: Layer<unknown, unknown, unknown>
    }> | LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
      _tag: "CompletedAttachSelectOnFocus"
    }> & Readonly<{
      layer: Layer<unknown, unknown, unknown>
    }> | LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
      _tag: "CompletedPortalBackdrop"
    }> & Readonly<{
      layer: Layer<unknown, unknown, unknown>
    }>>, readonly [
      SelectedChildBinding<AssemblyWithViewAndOutMessage<Struct<{
        id: String
        isShowing: Boolean
        transitionGeneration: Number
        transitionState: Literals<unknown>
      }>, () => AssemblyDraft<CompletedBlockWithViewAndOutMessage<unknown, unknown, unknown, unknown, unknown, unknown, unknown>>>, Struct<{
        activationTrigger: Literals<readonly [unknown, unknown]>
        animation: Struct<{
          id: unknown
          isShowing: unknown
          transitionGeneration: unknown
          transitionState: unknown
        }>
        id: String
        immediate: Boolean
        inputValue: String
        isAnimated: Boolean
        isModal: Boolean
        isOpen: Boolean
        maybeActiveItemIndex: Option<Number>
        maybeLastPointerPosition: Option<Struct<unknown>>
        nullable: Boolean
        selectInputOnFocus: Boolean
      }>, MessageUnion<Omit<{
        ActivatedItem: unknown
        BlurredInput: unknown
        Closed: unknown
        CompletedAnchor: unknown
        CompletedAttachPreventBlur: unknown
        CompletedAttachSelectOnFocus: unknown
        CompletedClickItem: unknown
        CompletedDetectMovementOrAnimationEnd: unknown
        CompletedFocusInput: unknown
        CompletedInertOthers: unknown
        CompletedLockScroll: unknown
        CompletedPortalBackdrop: unknown
        CompletedRestoreInert: unknown
        CompletedScrollItemIntoView: unknown
        CompletedUnlockScroll: unknown
        DeactivatedItem: unknown
        MovedPointerOverItem: unknown
        Opened: unknown
        PressedToggleButton: unknown
        RequestedClose: unknown
        RequestedItemClick: unknown
        RequestedOpen: unknown
        RequestedSelectItem: unknown
        SelectedItem: unknown
        SuppressedEmptyItemNavigation: unknown
        SuppressedItemCommit: unknown
        UpdatedInputValue: unknown
      }, unknown | unknown | unknown> & Readonly<{
        ActivatedItem: unknown
        RequestedSelectItem: unknown
        SelectedItem: unknown
      }>>, OutMessageSchema<Item, ItemEncoded>, {
        field: "animation"
        init: false
      }, never, {
        fold: OutMessageFold<{
          _tag: unknown
          generation: unknown
        } | {
          _tag: unknown
        }, DefinedCaseSteps<{
          activationTrigger: unknown
          animation: unknown
          id: unknown
          immediate: unknown
          inputValue: unknown
          isAnimated: unknown
          isModal: unknown
          isOpen: unknown
          maybeActiveItemIndex: unknown
          maybeLastPointerPosition: unknown
          nullable: unknown
          selectInputOnFocus: unknown
        }, {
          StartedLeaveAnimating: unknown
          TransitionedOut: unknown
        }>, readonly []>
      }>
    ]>>
  }>>
  subscriptions: Readonly<Record<never, never>> & Namespaced<"animation", {}>
  update: (message: Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }) => (model: {
    activationTrigger: "Pointer" | "Keyboard"
    animation: {
      id: string
      isShowing: boolean
      transitionGeneration: number
      transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
    }
    id: string
    immediate: boolean
    inputValue: string
    isAnimated: boolean
    isModal: boolean
    isOpen: boolean
    maybeActiveItemIndex: Option<number>
    maybeLastPointerPosition: Option<{
      screenX: number
      screenY: number
    }>
    nullable: boolean
    selectInputOnFocus: boolean
  }, context: []) => ReturnWithOutMessage<{
    activationTrigger: "Pointer" | "Keyboard"
    animation: {
      id: string
      isShowing: boolean
      transitionGeneration: number
      transitionState: "Idle" | "EnterStart" | "EnterAnimating" | "LeaveStart" | "LeaveAnimating"
    }
    id: string
    immediate: boolean
    inputValue: string
    isAnimated: boolean
    isModal: boolean
    isOpen: boolean
    maybeActiveItemIndex: Option<number>
    maybeLastPointerPosition: Option<{
      screenX: number
      screenY: number
    }>
    nullable: boolean
    selectInputOnFocus: boolean
  }, Readonly<{
    _tag: "GotAnimationMessage"
    generation: number
    message: {
      _tag: "Showed"
    } | {
      _tag: "Hid"
    } | {
      _tag: "RequestedShow"
    } | {
      _tag: "RequestedHide"
    } | {
      _tag: "RequestedWaitForLeaveSettlement"
    } | {
      _tag: "RequestedFinish"
      generation: number
    } | {
      _tag: "RequestedToggle"
    } | {
      _tag: "RequestedResume"
    } | {
      _tag: "RequestedImmediateReset"
    } | {
      _tag: "CompletedWaitForPaint"
      generation: number
    } | {
      _tag: "EndedAnimation"
      generation: number
    }
    placement: "animation"
  }> | {
    _tag: "Opened"
    maybeActiveItemIndex: Option<number>
  } | {
    _tag: "Closed"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "RequestedOpen"
  } | {
    _tag: "RequestedClose"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "BlurredInput"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "DeactivatedItem"
  } | {
    _tag: "MovedPointerOverItem"
    index: number
    screenX: number
    screenY: number
  } | {
    _tag: "RequestedItemClick"
    index: number
  } | {
    _tag: "SuppressedItemCommit"
  } | {
    _tag: "SuppressedEmptyItemNavigation"
  } | {
    _tag: "CompletedLockScroll"
  } | {
    _tag: "CompletedUnlockScroll"
  } | {
    _tag: "CompletedInertOthers"
  } | {
    _tag: "CompletedRestoreInert"
  } | {
    _tag: "CompletedFocusInput"
  } | {
    _tag: "CompletedScrollItemIntoView"
  } | {
    _tag: "CompletedClickItem"
  } | {
    _tag: "UpdatedInputValue"
    value: string
  } | {
    _tag: "PressedToggleButton"
    isClearable: boolean
    restingInputValue: string
  } | {
    _tag: "CompletedAnchor"
  } | {
    _tag: "CompletedAttachPreventBlur"
  } | {
    _tag: "CompletedAttachSelectOnFocus"
  } | {
    _tag: "CompletedPortalBackdrop"
  } | {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  } | {
    _tag: "RequestedSelectItem"
    displayText: string
    item: Item
  } | {
    _tag: "ActivatedItem"
    activationTrigger: "Pointer" | "Keyboard"
    index: number
    maybeImmediateSelection: Option<{
      item: Item
    }>
  } | {
    _tag: "SelectedItem"
    displayText: string
    item: Item
    wasSelected: boolean
  }, OutMessage<Item>>
}

Constants

ActivationTrigger

constsource
/** Schema for the activation trigger: whether the user interacted via mouse or keyboard. */
const ActivationTrigger: Literals<readonly ["Pointer", "Keyboard"]>