quantity-stepper headless API

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

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

interface QuantityStepperButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
  readonly children?: ReactNode;
}

interface QuantityStepperRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "value" | "defaultValue">, QuantityStepperInput {
  readonly ariaLabel?: string;
  readonly id?: string;
  readonly onValueChange?: (detail: QuantityStepperChangeDetail) => void;
  readonly children?: ReactNode;
}

interface QuantityStepperRootProviderProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
  readonly value: UseQuantityStepperResult;
  readonly children?: ReactNode;
}

interface QuantityStepperValueProps extends HTMLAttributes<HTMLSpanElement> {
  readonly children?: ReactNode;
}

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

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

declare function useQuantityStepper(input: QuantityStepperInput, options?: UseQuantityStepperOptions): UseQuantityStepperResult;

interface UseQuantityStepperOptions {
  readonly id?: string;
  readonly ariaLabel?: string;
  readonly onValueChange?: (detail: QuantityStepperChangeDetail) => void;
}

interface UseQuantityStepperResult {
  readonly service: QuantityStepperService;
  readonly connector: QuantityStepperApi;
  readonly scope: PartScope;
  readonly snapshot: QuantityStepperSnapshot;
}

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

export declare const Decrement: 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 Increment: 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 Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  min: NumberConstructor;
  max: NumberConstructor;
  step: NumberConstructor;
  value: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  disabled: BooleanConstructor;
  ariaLabel: StringConstructor;
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: QuantityStepperChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  min: NumberConstructor;
  max: NumberConstructor;
  step: NumberConstructor;
  value: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  disabled: BooleanConstructor;
  ariaLabel: StringConstructor;
}>> & Readonly<{
  onValueChange?: ((_detail: QuantityStepperChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: number | undefined;
  defaultValue: number | undefined;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const RootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<UseQuantityStepperResult>;
    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;
  };
  value: {
    type: PropType<UseQuantityStepperResult>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useQuantityStepper(input: () => QuantityStepperInput, options?: () => QuantityStepperOptions): UseQuantityStepperResult;

interface UseQuantityStepperResult {
  readonly service: QuantityStepperService;
  readonly connector: QuantityStepperApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<QuantityStepperSnapshot>;
}

export declare const Value: 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 function createQuantityStepperStore(initial: QuantityStepperInput, options?: CreateQuantityStepperStoreOptions): QuantityStepperStore;

export interface CreateQuantityStepperStoreOptions {
    readonly ariaLabel?: string;
    readonly onValueChange?: (detail: QuantityStepperChangeDetail) => void;
    readonly onCommit?: () => void;
}

export declare class GrQuantityStepperDecrement implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrQuantityStepperDecrement, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrQuantityStepperDecrement, "[grQuantityStepperDecrement]", never, {}, {}, never, never, true, never>;
}

export declare class GrQuantityStepperIncrement implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrQuantityStepperIncrement, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrQuantityStepperIncrement, "[grQuantityStepperIncrement]", never, {}, {}, never, never, true, never>;
}

export declare class GrQuantityStepperRoot implements OnDestroy {
    readonly min: import("@angular/core").InputSignal<number | undefined>;
    readonly max: import("@angular/core").InputSignal<number | undefined>;
    readonly step: import("@angular/core").InputSignal<number | undefined>;
    readonly value: import("@angular/core").InputSignal<number | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<number | undefined>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<QuantityStepperChangeDetail>;
    readonly store: QuantityStepperStore;
    private readonly host;
    private readonly listeners;
    private last;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrQuantityStepperRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrQuantityStepperRoot, "[grQuantityStepperRoot]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

export declare class GrQuantityStepperRootProvider implements OnDestroy {
    private readonly store;
    private readonly host;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrQuantityStepperRootProvider, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrQuantityStepperRootProvider, "[grQuantityStepperRootProvider]", never, {}, {}, never, never, true, never>;
}

export declare class GrQuantityStepperValue implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private readonly hasChildren;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrQuantityStepperValue, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrQuantityStepperValue, "[grQuantityStepperValue]", never, {}, {}, never, never, true, never>;
}

export interface QuantityStepperStore {
    readonly service: QuantityStepperService;
    readonly connector: QuantityStepperApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: QuantityStepperInput): void;
    syncOptions(options: Record<string, unknown>): void;
}

export declare function createQuantityStepper(input: () => QuantityStepperInput, options?: UseQuantityStepperOptions): UseQuantityStepperResult;

export declare const Decrement: LegacyComponentType;

export declare const Increment: LegacyComponentType;

export declare const Parts: LegacyComponentType;

export declare const Root: LegacyComponentType;

export declare const RootProvider: LegacyComponentType;

export interface UseQuantityStepperOptions {
    readonly id?: string;
    readonly ariaLabel?: string;
    readonly onValueChange?: (detail: import("@grassroot/ui-headless-core/quantity-stepper").QuantityStepperChangeDetail) => void;
}

export interface UseQuantityStepperResult {
    readonly service: QuantityStepperService;
    readonly connector: QuantityStepperApi;
    readonly scope: ReturnType<typeof import("@grassroot/ui-headless-core").createPartScope>;
    readonly version: () => number;
}

export declare const Value: LegacyComponentType;

export declare function Decrement(props?: QuantityStepperButtonProps): JSX.Element;

export declare function Increment(props?: QuantityStepperButtonProps): JSX.Element;

export interface QuantityStepperButtonProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement> {
    readonly children?: JSX.Element;
}

export interface QuantityStepperRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange" | "value" | "defaultValue">, QuantityStepperInput {
    readonly ariaLabel?: string;
    readonly id?: string;
    readonly onValueChange?: (detail: QuantityStepperChangeDetail) => void;
    readonly children?: JSX.Element;
}

export interface QuantityStepperRootProviderProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange"> {
    readonly value: UseQuantityStepperResult;
    readonly children?: JSX.Element;
}

export interface QuantityStepperValueProps extends JSX.HTMLAttributes<HTMLSpanElement> {
    readonly children?: JSX.Element;
}

export declare function Root(props: QuantityStepperRootProps): JSX.Element;