tabs headless API

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

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

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

export declare const Tabs: {
  Root: import("react").ForwardRefExoticComponent<TabsRootProps & import("react").RefAttributes<HTMLDivElement>>;
  List: import("react").ForwardRefExoticComponent<TabsListProps & import("react").RefAttributes<HTMLDivElement>>;
  Trigger: import("react").ForwardRefExoticComponent<TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Content: import("react").ForwardRefExoticComponent<TabsContentProps & import("react").RefAttributes<HTMLDivElement>>;
};

interface TabsContentProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly value: TabsItemValue;
}

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

interface TabsContextValue {
  readonly service: TabsService;
  readonly connector: TabsApi;
  readonly scope: PartScope;
}

interface TabsListProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
}

interface TabsRootProps extends Omit<ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "dir" | "onChange"> {
  readonly asChild?: boolean;
  readonly tabs: TabsInput["tabs"];
  readonly value?: TabsInput["value"];
  readonly defaultValue?: TabsInput["defaultValue"];
  readonly orientation?: TabsInput["orientation"];
  readonly activation?: TabsInput["activation"];
  readonly loop?: TabsInput["loop"];
  readonly dir?: "ltr" | "rtl";
  readonly onValueChange?: (detail: TabsValueChangeDetail) => void;
  readonly children?: ReactNode;
}

interface TabsTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "type" | "value"> {
  readonly asChild?: boolean;
  readonly tab: TabsItem<TabsItemValue>;
}

interface TabsValueChangeDetail {
  readonly value: string;
  readonly reason: TabsChangeReason;
}

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

declare function useServiceVersion<S extends Service<any, any, any, any, any, any>>(service: S): ReturnType<S["getSnapshot"]>;

declare function useTabs(input: TabsInput, options?: UseTabsOptions): UseTabsResult;

declare function useTabsContext(partName: string): TabsContextValue;

interface UseTabsOptions {
  readonly dir?: "ltr" | "rtl";
  readonly onValueChange?: (detail: TabsValueChangeDetail) => void;
}

interface UseTabsResult {
  readonly service: TabsService;
  readonly connector: TabsApi;
  readonly scope: PartScope;
  readonly snapshot: TabsSnapshot;
}

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

export declare const TabsContextKey: InjectionKey<TabsContextValue>;

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

export declare const TabsList: 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 TabsRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  tabs: {
    type: PropType<TabsInput["tabs"]>;
    required: true;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  orientation: {
    type: PropType<TabsInput["orientation"]>;
    default: undefined;
  };
  activation: {
    type: PropType<TabsInput["activation"]>;
    default: undefined;
  };
  loop: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  dir: {
    type: PropType<"ltr" | "rtl" | undefined>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: TabsValueChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  tabs: {
    type: PropType<TabsInput["tabs"]>;
    required: true;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  orientation: {
    type: PropType<TabsInput["orientation"]>;
    default: undefined;
  };
  activation: {
    type: PropType<TabsInput["activation"]>;
    default: undefined;
  };
  loop: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  dir: {
    type: PropType<"ltr" | "rtl" | undefined>;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: TabsValueChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  orientation: import("@grassroot/ui-machines/tabs").TabsOrientation | undefined;
  activation: import("@grassroot/ui-machines/tabs").TabsActivation | undefined;
  loop: boolean | undefined;
  dir: "ltr" | "rtl" | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

interface TabsValueChangeDetail {
  readonly value: string;
  readonly reason: TabsChangeReason;
}

declare function useTabs(input: TabsInput | (() => TabsInput), options?: UseTabsOptions): UseTabsResult;

declare function useTabsContext(partName: string): TabsContextValue;

interface UseTabsOptions {
  readonly dir?: "ltr" | "rtl";
  readonly onValueChange?: (detail: TabsValueChangeDetail) => void;
}

interface UseTabsResult {
  readonly service: TabsService;
  readonly connector: TabsApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<TabsSnapshot>;
}

export declare function createTabsStore(initialInput: TabsInput, options?: CreateTabsStoreOptions): TabsStore;

export interface CreateTabsStoreOptions {
    readonly dir?: "ltr" | "rtl";
    readonly onValueChange?: (detail: TabsValueChangeDetail) => void;
    readonly onCommit?: () => void;
}

export declare const GR_TABS_DECLARATIONS: readonly [typeof GrTabsRoot, typeof GrTabsList, typeof GrTabsTrigger, typeof GrTabsContent];

export declare class GrTabsContent implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registeredKey;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTabsContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrTabsContent, "[grTabsContent]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

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

export declare class GrTabsRoot implements OnDestroy {
    readonly tabs: import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/tabs").TabsItem<string>[]>;
    readonly value: import("@angular/core").InputSignal<string | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<string | undefined>;
    readonly orientation: import("@angular/core").InputSignal<import("@grassroot/ui-machines/tabs").TabsOrientation | undefined>;
    readonly activation: import("@angular/core").InputSignal<import("@grassroot/ui-machines/tabs").TabsActivation | undefined>;
    readonly loop: import("@angular/core").InputSignal<boolean | undefined>;
    readonly dir: import("@angular/core").InputSignal<"rtl" | "ltr" | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<TabsValueChangeDetail>;
    private readonly elementRef;
    private readonly injector;
    private readonly listeners;
    private lastSynced;
    readonly store: TabsStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTabsRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrTabsRoot, "gr-tabs-root", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "activation": { "alias": "activation"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
}

export declare class GrTabsTrigger implements OnDestroy {
    readonly tab: import("@angular/core").InputSignal<TabsItem<string>>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registeredKey;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTabsTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrTabsTrigger, "[grTabsTrigger]", never, { "tab": { "alias": "tab"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}