select headless API

export declare const Content: import("react").ForwardRefExoticComponent<SelectContentProps & import("react").RefAttributes<HTMLUListElement>>;

export declare const HiddenInput: import("react").ForwardRefExoticComponent<SelectHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;

export declare const Item: import("react").ForwardRefExoticComponent<SelectItemProps & import("react").RefAttributes<HTMLLIElement>>;

export declare const ItemText: import("react").ForwardRefExoticComponent<SelectItemTextProps & import("react").RefAttributes<HTMLSpanElement>>;

export declare const Positioner: import("react").ForwardRefExoticComponent<SelectPositionerProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Root: import("react").ForwardRefExoticComponent<SelectRootProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const RootProvider: import("react").ForwardRefExoticComponent<SelectRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Select: {
  Root: import("react").ForwardRefExoticComponent<SelectRootProps & import("react").RefAttributes<HTMLDivElement>>;
  RootProvider: import("react").ForwardRefExoticComponent<SelectRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
  Trigger: import("react").ForwardRefExoticComponent<SelectTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Positioner: import("react").ForwardRefExoticComponent<SelectPositionerProps & import("react").RefAttributes<HTMLDivElement>>;
  Content: import("react").ForwardRefExoticComponent<SelectContentProps & import("react").RefAttributes<HTMLUListElement>>;
  Item: import("react").ForwardRefExoticComponent<SelectItemProps & import("react").RefAttributes<HTMLLIElement>>;
  ItemText: import("react").ForwardRefExoticComponent<SelectItemTextProps & import("react").RefAttributes<HTMLSpanElement>>;
  HiddenInput: import("react").ForwardRefExoticComponent<SelectHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
};

interface SelectContentProps extends ComponentPropsWithoutRef<"ul"> {
  readonly asChild?: boolean;
  /** Keep the content mounted (with `data-state="closed"`) instead of unmounting it. */
  readonly forceMount?: boolean;
}

export declare const SelectContext: import("react").Context<SelectContextValue | null>;

interface SelectContextValue {
  readonly service: SelectService;
  readonly connector: SelectApi;
  readonly scope: PartScope;
  /**
   * `select.spec.md` requires `aria-required` on the trigger when the
   * field is required, but `connectSelect().triggerProps()` (frozen
   * platform code) does not expose a `required` input and never emits it.
   * The adapter carries the flag via context and `Trigger` layers
   * `aria-required` on top of the connector's prop bag to satisfy the
   * spec without reimplementing connector semantics.
   */
  readonly required?: boolean;
}

interface SelectHiddenInputProps extends Omit<ComponentPropsWithoutRef<"input">, "name" | "required"> {
  readonly asChild?: boolean;
  readonly name?: string;
  readonly required?: boolean;
}

interface SelectItemProps extends ComponentPropsWithoutRef<"li"> {
  readonly asChild?: boolean;
  readonly option: SelectOptionInput;
}

interface SelectItemTextProps extends ComponentPropsWithoutRef<"span"> {
  readonly asChild?: boolean;
  readonly option: SelectOptionInput;
}

interface SelectPositionerProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  /** Render children into `document.body` via a portal, after mount only (SSR-safe). */
  readonly portalled?: boolean;
}

interface SelectRootProps extends Omit<ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "dir" | "onChange"> {
  readonly asChild?: boolean;
  readonly options: SelectInput["options"];
  readonly value?: SelectInput["value"];
  readonly defaultValue?: SelectInput["defaultValue"];
  readonly defaultOpen?: SelectInput["defaultOpen"];
  readonly loop?: SelectInput["loop"];
  readonly selectionMode?: SelectInput["selectionMode"];
  readonly name?: string;
  readonly required?: boolean;
  readonly dir?: "ltr" | "rtl";
  readonly onValueChange?: (detail: SelectValueChangeDetail) => void;
}

interface SelectRootProviderProps extends Omit<ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "dir" | "onChange"> {
  readonly asChild?: boolean;
  /** An existing `useSelect()` result (advanced composition). */
  readonly value: UseSelectResult;
  readonly name?: string;
  readonly required?: boolean;
}

interface SelectTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
}

interface SelectValueChangeDetail {
  readonly value: SelectValue;
  readonly reason: SelectChangeReason;
}

export declare const Trigger: import("react").ForwardRefExoticComponent<SelectTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

declare function useSelect(input: SelectInput, options?: UseSelectOptions): UseSelectResult;

declare function useSelectContext(partName: string): SelectContextValue;

interface UseSelectOptions {
  readonly dir?: "ltr" | "rtl";
  readonly typeaheadTimeout?: number;
  readonly now?: () => number;
  readonly onValueChange?: (detail: SelectValueChangeDetail) => void;
}

interface UseSelectResult {
  readonly service: SelectService;
  readonly connector: SelectApi;
  readonly scope: PartScope;
  readonly snapshot: SelectSnapshot;
}

declare function useServiceVersion<S extends Service<any, any, any, any, any, any>>(service: S): ReturnType<S["getSnapshot"]>;

export declare const SelectContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** Keep the content mounted (with `data-state="closed"`) instead of unmounting it. */
  forceMount: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** Keep the content mounted (with `data-state="closed"`) instead of unmounting it. */
  forceMount: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  forceMount: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectContextKey: InjectionKey<SelectContextValue>;

interface SelectContextValue {
  readonly service: SelectService;
  readonly connector: SelectApi;
  readonly scope: PartScope;
  /** Bumped on every committed machine update; parts read `.value` to establish a reactive dependency. */
  readonly snapshot: ShallowRef<SelectSnapshot>;
  /**
   * `select.spec.md` requires `aria-required` on the trigger when the
   * field is required, but `connectSelect().triggerProps()` (frozen
   * platform code) does not expose a `required` input and never emits it.
   * The adapter carries the flag via context and `Trigger` layers
   * `aria-required` on top of the connector's prop bag to satisfy the
   * spec without reimplementing connector semantics.
   */
  readonly required?: boolean;
}

export declare const SelectHiddenInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  name: string;
  required: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  option: {
    type: PropType<SelectOptionInput>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  option: {
    type: PropType<SelectOptionInput>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectItemText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  option: {
    type: PropType<SelectOptionInput>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  option: {
    type: PropType<SelectOptionInput>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectPositioner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** Render children into `document.body` via a `<Teleport>`, after mount only (SSR-safe). */
  portalled: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** Render children into `document.body` via a `<Teleport>`, after mount only (SSR-safe). */
  portalled: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  portalled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  options: {
    type: PropType<SelectInput["options"]>;
    required: true;
  };
  value: {
    type: PropType<SelectInput["value"]>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<SelectInput["defaultValue"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  loop: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  selectionMode: {
    type: PropType<SelectInput["selectionMode"]>;
    default: undefined;
  };
  name: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  required: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  dir: {
    type: PropType<"ltr" | "rtl" | undefined>;
    default: undefined;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: SelectValueChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  options: {
    type: PropType<SelectInput["options"]>;
    required: true;
  };
  value: {
    type: PropType<SelectInput["value"]>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<SelectInput["defaultValue"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  loop: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  selectionMode: {
    type: PropType<SelectInput["selectionMode"]>;
    default: undefined;
  };
  name: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  required: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  dir: {
    type: PropType<"ltr" | "rtl" | undefined>;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: SelectValueChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: import("@grassroot/ui-machines/select").SelectValue<string> | undefined;
  defaultValue: import("@grassroot/ui-machines/select").SelectValue<string> | undefined;
  defaultOpen: boolean | undefined;
  loop: boolean | undefined;
  selectionMode: import("@grassroot/ui-machines/select").SelectSelectionMode | undefined;
  name: string | undefined;
  required: boolean | undefined;
  dir: "ltr" | "rtl" | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectRootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** An existing `useSelect()` result (advanced composition). */
  value: {
    type: PropType<UseSelectResult>;
    required: true;
  };
  name: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  required: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** An existing `useSelect()` result (advanced composition). */
  value: {
    type: PropType<UseSelectResult>;
    required: true;
  };
  name: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  required: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  name: string | undefined;
  required: boolean | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SelectTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

interface SelectValueChangeDetail {
  readonly value: SelectValue;
  readonly reason: SelectChangeReason;
}

declare function useSelect(input: SelectInput | (() => SelectInput), options?: UseSelectOptions): UseSelectResult;

declare function useSelectContext(partName: string): SelectContextValue;

interface UseSelectOptions {
  readonly dir?: "ltr" | "rtl";
  readonly typeaheadTimeout?: number;
  readonly now?: () => number;
  readonly onValueChange?: (detail: SelectValueChangeDetail) => void;
}

interface UseSelectResult {
  readonly service: SelectService;
  readonly connector: SelectApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<SelectSnapshot>;
}