switch headless API

export declare const Control: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLSpanElement>>;

export declare const Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLSpanElement>>;

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

export declare const Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLSpanElement>>;

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

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

export declare const Switch: {
  Root: import("react").ForwardRefExoticComponent<SwitchRootProps & import("react").RefAttributes<HTMLLabelElement>>;
  RootProvider: import("react").ForwardRefExoticComponent<SwitchRootProviderProps & import("react").RefAttributes<HTMLLabelElement>>;
  HiddenInput: import("react").ForwardRefExoticComponent<SwitchHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
  Control: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
  Thumb: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
  Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
  Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
};

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

interface SwitchContextValue {
  readonly service: SwitchService;
  readonly connector: SwitchApi;
  readonly scope: PartScope;
}

interface SwitchHiddenInputProps extends Omit<ComponentPropsWithoutRef<"input">, "checked" | "defaultChecked" | "disabled"> {
  readonly asChild?: boolean;
}

interface SwitchRootProps extends Omit<ComponentPropsWithoutRef<"label">, "defaultChecked" | "checked" | "disabled" | "onChange"> {
  readonly asChild?: boolean;
  readonly checked?: SwitchInput["checked"];
  readonly defaultChecked?: SwitchInput["defaultChecked"];
  readonly disabled?: SwitchInput["disabled"];
  readonly readOnly?: SwitchInput["readOnly"];
  readonly name?: string;
  readonly value?: string;
  readonly required?: boolean;
  /** Accessible-name escape hatch [baseline #17] — see `Switch.Label` for the primary path. */
  readonly ariaLabel?: string;
  /**
   * Seeds the part scope INSTEAD of the generated id when supplied
   * [baseline #10]: `<Switch.Root id="wifi">` yields deterministic
   * `hidden-input`/`label`/`description` ids derived from `"wifi"`. Feeds
   * `useSwitch`'s `id` option — see that hook's doc comment. Intercepted
   * here rather than left in the native passthrough, so it configures the
   * scope seed instead of landing on the rendered `<label>` as a plain
   * HTML `id` attribute.
   */
  readonly id?: string;
  readonly onCheckedChange?: (detail: SwitchChangeDetail) => void;
  readonly onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
  readonly children?: ReactNode;
}

interface SwitchRootProviderProps extends Omit<ComponentPropsWithoutRef<"label">, "defaultChecked" | "checked" | "disabled" | "onChange" | "value"> {
  readonly asChild?: boolean;
  /** An existing `useSwitch()` result (advanced composition) — already fully configured. */
  readonly value: UseSwitchResult;
  readonly children?: ReactNode;
}

export declare const Thumb: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLSpanElement>>;

declare function useSwitch(input: SwitchInput, options?: UseSwitchOptions): UseSwitchResult;

declare function useSwitchContext(partName: string): SwitchContextValue;

interface UseSwitchOptions {
  readonly onCheckedChange?: (detail: SwitchChangeDetail) => void;
  readonly onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
  readonly name?: string;
  readonly value?: string;
  readonly required?: boolean;
  readonly ariaLabel?: string;
  readonly id?: string;
}

interface UseSwitchResult {
  readonly service: SwitchService;
  readonly connector: SwitchApi;
  readonly scope: PartScope;
  readonly snapshot: SwitchSnapshot;
}

export declare const SwitchContextKey: InjectionKey<SwitchContextValue>;

interface SwitchContextValue {
  readonly service: SwitchService;
  readonly connector: SwitchApi;
  readonly scope: PartScope;
  /** Bumped on every committed machine update; parts read `.value` to establish a reactive dependency. */
  readonly snapshot: ShallowRef<SwitchSnapshot>;
}

export declare const SwitchControl: 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>;

export declare const SwitchDescription: 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>;

export declare const SwitchHiddenInput: 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>;

export declare const SwitchLabel: 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>;

export declare const SwitchRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  checked: {
    type: PropType<SwitchInput["checked"]>;
    default: undefined;
  };
  defaultChecked: {
    type: PropType<SwitchInput["defaultChecked"]>;
    default: undefined;
  };
  disabled: {
    type: PropType<SwitchInput["disabled"]>;
    default: undefined;
  };
  readOnly: {
    type: PropType<SwitchInput["readOnly"]>;
    default: undefined;
  };
  name: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  required: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  /** Accessible-name escape hatch [baseline #17] — see `SwitchLabel` for the primary path. */
  ariaLabel: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  /**
   * Seeds the part scope INSTEAD of the generated id when supplied
   * [baseline #10]: `<SwitchRoot id="wifi">` yields deterministic
   * `hidden-input`/`label`/`description` ids derived from `"wifi"`. Feeds
   * `useSwitch`'s `id` option — see that composable's doc comment. Declared
   * as a real prop (not left to fall through to `attrs`) so it configures
   * the scope seed instead of landing on the rendered `<label>` as a plain
   * HTML `id` attribute.
   */
  id: {
    type: PropType<string | undefined>;
    default: undefined;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  checkedChange: (_detail: SwitchChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  checked: {
    type: PropType<SwitchInput["checked"]>;
    default: undefined;
  };
  defaultChecked: {
    type: PropType<SwitchInput["defaultChecked"]>;
    default: undefined;
  };
  disabled: {
    type: PropType<SwitchInput["disabled"]>;
    default: undefined;
  };
  readOnly: {
    type: PropType<SwitchInput["readOnly"]>;
    default: undefined;
  };
  name: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  required: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  /** Accessible-name escape hatch [baseline #17] — see `SwitchLabel` for the primary path. */
  ariaLabel: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  /**
   * Seeds the part scope INSTEAD of the generated id when supplied
   * [baseline #10]: `<SwitchRoot id="wifi">` yields deterministic
   * `hidden-input`/`label`/`description` ids derived from `"wifi"`. Feeds
   * `useSwitch`'s `id` option — see that composable's doc comment. Declared
   * as a real prop (not left to fall through to `attrs`) so it configures
   * the scope seed instead of landing on the rendered `<label>` as a plain
   * HTML `id` attribute.
   */
  id: {
    type: PropType<string | undefined>;
    default: undefined;
  };
}>> & Readonly<{
  onCheckedChange?: ((_detail: SwitchChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  checked: boolean | undefined;
  defaultChecked: boolean | undefined;
  disabled: boolean | undefined;
  readOnly: boolean | undefined;
  name: string | undefined;
  value: string | undefined;
  required: boolean | undefined;
  ariaLabel: string | undefined;
  id: string | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SwitchRootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** An existing `useSwitch()` result (advanced composition) — already fully configured. */
  value: {
    type: PropType<UseSwitchResult>;
    required: true;
  };
}>, () => 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 `useSwitch()` result (advanced composition) — already fully configured. */
  value: {
    type: PropType<UseSwitchResult>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const SwitchThumb: 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>;

declare function useSwitch(input: SwitchInput | (() => SwitchInput), options?: UseSwitchOptions | (() => UseSwitchOptions)): UseSwitchResult;

declare function useSwitchContext(partName: string): SwitchContextValue;

interface UseSwitchOptions {
  readonly onCheckedChange?: (detail: SwitchChangeDetail) => void;
  readonly onChange?: (event: Event) => void;
  readonly name?: string;
  readonly value?: string;
  readonly required?: boolean;
  readonly ariaLabel?: string;
  readonly id?: string;
}

interface UseSwitchResult {
  readonly service: SwitchService;
  readonly connector: SwitchApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<SwitchSnapshot>;
}

export declare function createSwitchStore(initialInput: SwitchInput, options?: CreateSwitchStoreOptions): SwitchStore;

export interface CreateSwitchStoreOptions {
    readonly onCheckedChange?: (detail: SwitchChangeDetail) => void;
    readonly onChange?: (event: unknown) => void;
    readonly onCommit?: () => void;
    readonly id?: string;
}