input-otp headless API

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

interface InputOTPInputProps extends InputHTMLAttributes<HTMLInputElement> {
  readonly index: number;
  readonly children?: ReactNode;
}

interface InputOTPRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue">, InputOTPInput {
  readonly ariaLabel?: string;
  readonly id?: string;
  readonly onValueChange?: (detail: InputOTPChangeDetail) => void;
  readonly onComplete?: (value: string) => void;
  readonly children?: ReactNode;
}

interface InputOTPRootProviderProps extends HTMLAttributes<HTMLDivElement> {
  readonly value: UseInputOTPResult;
  readonly children?: ReactNode;
}

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

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

declare function useInputOTP(input: InputOTPInput, options?: UseInputOTPOptions): UseInputOTPResult;

interface UseInputOTPOptions {
  readonly id?: string;
  readonly ariaLabel?: string;
  readonly onValueChange?: (detail: InputOTPChangeDetail) => void;
  readonly onComplete?: (value: string) => void;
}

interface UseInputOTPResult {
  readonly service: InputOTPService;
  readonly connector: InputOTPApi;
  readonly scope: PartScope;
  readonly snapshot: InputOTPSnapshot;
}

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

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

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

declare function useInputOTP(input: () => InputOTPInput, options?: () => InputOTPOptions): UseInputOTPResult;

interface UseInputOTPResult {
  readonly service: InputOTPService;
  readonly connector: InputOTPApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<InputOTPSnapshot>;
}

export declare function createInputOTPStore(initial: InputOTPInput, options?: InputOTPOptions): InputOTPStore;

export declare class GrInputOTPInput 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<GrInputOTPInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrInputOTPInput, "[grInputOtpInput]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export declare class GrInputOTPRoot implements OnDestroy {
    readonly length: import("@angular/core").InputSignal<number | undefined>;
    readonly value: import("@angular/core").InputSignal<string | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<string | undefined>;
    readonly disabled: import("@angular/core").InputSignal<boolean>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<InputOTPChangeDetail>;
    readonly complete: import("@angular/core").OutputEmitterRef<string>;
    readonly store: InputOTPStore;
    private readonly host;
    private readonly listeners;
    private last;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrInputOTPRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrInputOTPRoot, "gr-input-otp-root", never, { "length": { "alias": "length"; "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"; "complete": "complete"; }, never, ["*"], true, never>;
}

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

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

export declare function createInputOTP(input: () => InputOTPInput, options?: UseInputOTPOptions): UseInputOTPResult;

export declare const Input: LegacyComponentType;

export declare const Root: LegacyComponentType;

export declare const RootProvider: LegacyComponentType;

export interface UseInputOTPOptions {
    readonly id?: string;
    readonly ariaLabel?: string;
    readonly onValueChange?: (detail: InputOTPChangeDetail) => void;
    readonly onComplete?: (value: string) => void;
}

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

export declare function Input(props: InputOTPInputProps): JSX.Element;

export interface InputOTPInputProps extends JSX.InputHTMLAttributes<HTMLInputElement> {
    readonly index: number;
}

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

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

export declare function RootProvider(props: {
    readonly value: UseInputOTPResult;
    readonly children?: JSX.Element;
} & JSX.HTMLAttributes<HTMLDivElement>): JSX.Element;

export declare function useInputOTP(input: () => InputOTPInput, options?: UseInputOTPOptions): UseInputOTPResult;

export interface UseInputOTPResult {
    readonly service: InputOTPService;
    readonly connector: InputOTPApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<number>;
}