checkbox headless API

export declare const Checkbox: {
  Root: import("react").ForwardRefExoticComponent<CheckboxRootProps & import("react").RefAttributes<HTMLLabelElement>>;
  RootProvider: import("react").ForwardRefExoticComponent<CheckboxRootProviderProps & import("react").RefAttributes<HTMLLabelElement>>;
  HiddenInput: import("react").ForwardRefExoticComponent<CheckboxHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
  Control: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
  Indicator: 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 CheckboxContext: import("react").Context<CheckboxContextValue | null>;

interface CheckboxContextValue {
  readonly service: CheckboxService;
  readonly connector: CheckboxApi;
  readonly scope: PartScope;
}

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

interface CheckboxRootProps extends Omit<ComponentPropsWithoutRef<"label">, "defaultChecked" | "checked" | "disabled" | "onChange"> {
  readonly asChild?: boolean;
  readonly checked?: CheckboxInput["checked"];
  readonly defaultChecked?: CheckboxInput["defaultChecked"];
  readonly disabled?: CheckboxInput["disabled"];
  readonly readOnly?: CheckboxInput["readOnly"];
  readonly name?: string;
  readonly value?: string;
  readonly required?: boolean;
  /** Accessible-name escape hatch [inherited from Switch's baseline #17] — see `Checkbox.Label` for the primary path. */
  readonly ariaLabel?: string;
  /**
   * Seeds the part scope INSTEAD of the generated id when supplied
   * [inherited from Switch's baseline #10]: `<Checkbox.Root id="terms">`
   * yields deterministic `hidden-input`/`label`/`description` ids derived
   * from `"terms"`. Feeds `useCheckbox`'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: CheckboxChangeDetail) => void;
  readonly onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
  readonly children?: ReactNode;
}

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

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<CheckboxHiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;

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

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<CheckboxRootProps & import("react").RefAttributes<HTMLLabelElement>>;

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

declare function useCheckbox(input: CheckboxInput, options?: UseCheckboxOptions): UseCheckboxResult;

declare function useCheckboxContext(partName: string): CheckboxContextValue;

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

interface UseCheckboxResult {
  readonly service: CheckboxService;
  readonly connector: CheckboxApi;
  readonly scope: PartScope;
  readonly snapshot: CheckboxSnapshot;
}

export declare const CheckboxContextKey: InjectionKey<CheckboxContextValue>;

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

export declare const CheckboxControl: 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 CheckboxDescription: 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 CheckboxHiddenInput: 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 CheckboxIndicator: 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 CheckboxLabel: 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 CheckboxRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  checked: {
    type: PropType<CheckboxInput["checked"]>;
    default: undefined;
  };
  defaultChecked: {
    type: PropType<CheckboxInput["defaultChecked"]>;
    default: undefined;
  };
  disabled: {
    type: PropType<CheckboxInput["disabled"]>;
    default: undefined;
  };
  readOnly: {
    type: PropType<CheckboxInput["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, inherited] — see `CheckboxLabel` for the primary path. */
  ariaLabel: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  /**
   * Seeds the part scope INSTEAD of the generated id when supplied
   * [baseline #10, inherited]: `<CheckboxRoot id="terms">` yields
   * deterministic `hidden-input`/`label`/`description` ids derived from
   * `"terms"`. Feeds `useCheckbox`'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: CheckboxChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  checked: {
    type: PropType<CheckboxInput["checked"]>;
    default: undefined;
  };
  defaultChecked: {
    type: PropType<CheckboxInput["defaultChecked"]>;
    default: undefined;
  };
  disabled: {
    type: PropType<CheckboxInput["disabled"]>;
    default: undefined;
  };
  readOnly: {
    type: PropType<CheckboxInput["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, inherited] — see `CheckboxLabel` for the primary path. */
  ariaLabel: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  /**
   * Seeds the part scope INSTEAD of the generated id when supplied
   * [baseline #10, inherited]: `<CheckboxRoot id="terms">` yields
   * deterministic `hidden-input`/`label`/`description` ids derived from
   * `"terms"`. Feeds `useCheckbox`'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: CheckboxChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  checked: import("@grassroot/ui-machines/checkbox").CheckboxCheckedValue | undefined;
  defaultChecked: import("@grassroot/ui-machines/checkbox").CheckboxCheckedValue | 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 CheckboxRootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  /** An existing `useCheckbox()` result (advanced composition) — already fully configured. */
  value: {
    type: PropType<UseCheckboxResult>;
    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 `useCheckbox()` result (advanced composition) — already fully configured. */
  value: {
    type: PropType<UseCheckboxResult>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useCheckbox(input: CheckboxInput | (() => CheckboxInput), options?: UseCheckboxOptions | (() => UseCheckboxOptions)): UseCheckboxResult;

declare function useCheckboxContext(partName: string): CheckboxContextValue;

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