rating headless API

interface RatingRootProps extends Omit<HTMLAttributes<HTMLSpanElement>, "onChange" | "defaultValue" | "value">, RatingInput {
  readonly ariaLabel?: string;
  readonly id?: string;
  readonly onValueChange?: (detail: RatingChangeDetail) => void;
  readonly children?: ReactNode;
}

interface RatingRootProviderProps extends Omit<HTMLAttributes<HTMLSpanElement>, "onChange"> {
  readonly value: UseRatingResult;
  readonly children?: ReactNode;
}

interface RatingStarProps extends HTMLAttributes<HTMLElement> {
  readonly index: number;
  readonly children?: ReactNode;
}

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

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

export declare const Star: import("react").ForwardRefExoticComponent<RatingStarProps & import("react").RefAttributes<HTMLElement>>;

declare function useRating(input: RatingInput, options?: UseRatingOptions): UseRatingResult;

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

interface UseRatingResult {
  readonly service: RatingService;
  readonly connector: RatingApi;
  readonly scope: ReturnType<typeof import("@grassroot/ui-headless-core").createPartScope>;
  readonly snapshot: RatingSnapshot;
}

export declare const Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  max: NumberConstructor;
  value: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: boolean;
  };
  ariaLabel: StringConstructor;
  id: StringConstructor;
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: RatingChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  max: NumberConstructor;
  value: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: boolean;
  };
  ariaLabel: StringConstructor;
  id: StringConstructor;
}>> & Readonly<{
  onValueChange?: ((_detail: RatingChangeDetail) => any) | undefined;
}>, {
  value: number | undefined;
  defaultValue: number | undefined;
  readOnly: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

export declare const Star: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  index: {
    type: NumberConstructor;
    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<{
  index: {
    type: NumberConstructor;
    required: true;
  };
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useRating(input: () => RatingInput, options?: () => RatingOptions): UseRatingResult;

interface UseRatingResult {
  readonly service: RatingService;
  readonly connector: RatingApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<RatingSnapshot>;
}

export declare function createRatingStore(initial: RatingInput, options?: RatingOptions): RatingStore;

export declare class GrRatingRoot implements OnDestroy {
    readonly max: import("@angular/core").InputSignal<number | undefined>;
    readonly value: import("@angular/core").InputSignal<number | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<number | undefined>;
    readonly readOnly: import("@angular/core").InputSignal<boolean>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly className: import("@angular/core").InputSignal<string | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<RatingChangeDetail>;
    readonly store: RatingStore;
    private readonly host;
    private readonly listeners;
    private last;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRatingRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrRatingRoot, "gr-rating-root", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "className": { "alias": "class"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
}

export declare class GrRatingRootProvider implements OnDestroy {
    private readonly store;
    private readonly host;
    private readonly listeners;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRatingRootProvider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrRatingRootProvider, "gr-rating-root-provider", never, {}, {}, never, ["*"], true, never>;
}

export declare class GrRatingStar implements OnDestroy {
    readonly index: import("@angular/core").InputSignal<number>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRatingStar, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRatingStar, "[grRatingStar]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export interface RatingStore {
    readonly service: RatingService;
    readonly connector: RatingApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: RatingInput): void;
    syncOptions(options: Record<string, unknown>): void;
}

export declare function createRating(input: () => RatingInput, options?: UseRatingOptions): UseRatingResult;

export declare const Parts: LegacyComponentType;

export declare const Root: LegacyComponentType;

export declare const RootProvider: LegacyComponentType;

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

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

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

export declare function RootProvider(props: RatingRootProviderProps): JSX.Element;

export declare function Star(props: RatingStarProps): JSX.Element;

export declare function useRating(input: Accessor<RatingInput>, options?: UseRatingOptions): UseRatingResult;

export interface UseRatingOptions {
    readonly id?: string;
    readonly ariaLabel?: string;
    readonly onValueChange?: (detail: RatingChangeDetail) => void;
}

export interface UseRatingResult {
    readonly service: RatingService;
    readonly connector: RatingApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<RatingSnapshot>;
}