theme-menu headless API

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

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

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

declare function Root(props: ThemeMenuRootProps): import("react").JSX.Element;

export declare const ThemeMenu: {
  Root: typeof Root;
  Trigger: import("react").ForwardRefExoticComponent<ThemeMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Positioner: import("react").ForwardRefExoticComponent<ThemeMenuPositionerProps & import("react").RefAttributes<HTMLDivElement>>;
  Content: import("react").ForwardRefExoticComponent<ThemeMenuContentProps & import("react").RefAttributes<HTMLDivElement>>;
  Item: import("react").ForwardRefExoticComponent<ThemeMenuItemProps & import("react").RefAttributes<HTMLButtonElement>>;
};

interface ThemeMenuChangeDetail {
  readonly theme: string;
}

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

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

interface ThemeMenuContextValue {
  readonly service: ThemeMenuService;
  readonly connector: ThemeMenuApi;
  readonly scope: PartScope;
}

interface ThemeMenuItemProps extends ComponentPropsWithoutRef<"button"> {
  readonly asChild?: boolean;
  readonly item: ThemeMenuItem;
}

interface ThemeMenuOpenChangeDetail {
  readonly open: boolean;
  readonly reason: ThemeMenuChangeReason;
}

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

interface ThemeMenuRootProps {
  readonly open?: ThemeMenuInput["open"];
  readonly defaultOpen?: ThemeMenuInput["defaultOpen"];
  readonly items: ThemeMenuInput["items"];
  readonly theme?: ThemeMenuInput["theme"];
  readonly defaultTheme: ThemeMenuInput["defaultTheme"];
  readonly storageKey: ThemeMenuInput["storageKey"];
  readonly typeaheadTimeoutMs?: ThemeMenuInput["typeaheadTimeoutMs"];
  readonly align?: UseThemeMenuOptions["align"];
  readonly onOpenChange?: (detail: ThemeMenuOpenChangeDetail) => void;
  readonly onThemeChange?: (detail: ThemeMenuChangeDetail) => void;
  readonly scheduler?: UseThemeMenuOptions["scheduler"];
  readonly children?: ReactNode;
}

interface ThemeMenuTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
}

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

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

declare function useThemeMenu(input: ThemeMenuInput, options?: UseThemeMenuOptions): UseThemeMenuResult;

declare function useThemeMenuContext(partName: string): ThemeMenuContextValue;

interface UseThemeMenuOptions {
  readonly onOpenChange?: (detail: ThemeMenuOpenChangeDetail) => void;
  readonly onThemeChange?: (detail: ThemeMenuChangeDetail) => void;
  readonly align?: "start" | "end";
  readonly scheduler?: Scheduler;
}

interface UseThemeMenuResult {
  readonly service: ThemeMenuService;
  readonly connector: ThemeMenuApi;
  readonly scope: PartScope;
  readonly snapshot: ThemeMenuSnapshot;
}

interface ThemeMenuChangeDetail {
  readonly theme: string;
}

export declare const ThemeMenuContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, 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 ThemeMenuContextKey: InjectionKey<ThemeMenuContextValue>;

interface ThemeMenuContextValue {
  readonly service: ThemeMenuService;
  readonly connector: ThemeMenuApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<ThemeMenuSnapshot>;
}

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

interface ThemeMenuOpenChangeDetail {
  readonly open: boolean;
  readonly reason: ThemeMenuChangeReason;
}

export declare const ThemeMenuPositioner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, 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 ThemeMenuRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<ThemeMenuInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<ThemeMenuInput["defaultOpen"]>;
    default: undefined;
  };
  items: {
    type: PropType<ThemeMenuInput["items"]>;
    required: true;
  };
  theme: {
    type: PropType<ThemeMenuInput["theme"]>;
    default: undefined;
  };
  defaultTheme: {
    type: PropType<ThemeMenuInput["defaultTheme"]>;
    required: true;
  };
  storageKey: {
    type: PropType<ThemeMenuInput["storageKey"]>;
    required: true;
  };
  typeaheadTimeoutMs: {
    type: PropType<ThemeMenuInput["typeaheadTimeoutMs"]>;
    default: undefined;
  };
  align: {
    type: PropType<UseThemeMenuOptions["align"]>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseThemeMenuOptions["scheduler"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: ThemeMenuOpenChangeDetail) => true;
  themeChange: (_detail: ThemeMenuChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<ThemeMenuInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<ThemeMenuInput["defaultOpen"]>;
    default: undefined;
  };
  items: {
    type: PropType<ThemeMenuInput["items"]>;
    required: true;
  };
  theme: {
    type: PropType<ThemeMenuInput["theme"]>;
    default: undefined;
  };
  defaultTheme: {
    type: PropType<ThemeMenuInput["defaultTheme"]>;
    required: true;
  };
  storageKey: {
    type: PropType<ThemeMenuInput["storageKey"]>;
    required: true;
  };
  typeaheadTimeoutMs: {
    type: PropType<ThemeMenuInput["typeaheadTimeoutMs"]>;
    default: undefined;
  };
  align: {
    type: PropType<UseThemeMenuOptions["align"]>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseThemeMenuOptions["scheduler"]>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: ThemeMenuOpenChangeDetail) => any) | undefined;
  onThemeChange?: ((_detail: ThemeMenuChangeDetail) => any) | undefined;
}>, {
  open: boolean | undefined;
  defaultOpen: boolean | undefined;
  theme: string | undefined;
  typeaheadTimeoutMs: number | undefined;
  align: "end" | "start" | undefined;
  scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const ThemeMenuTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, 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>;

declare function useThemeMenu(input: ThemeMenuInput | (() => ThemeMenuInput), options?: UseThemeMenuOptions): UseThemeMenuResult;

declare function useThemeMenuContext(partName: string): ThemeMenuContextValue;

interface UseThemeMenuOptions {
  readonly onOpenChange?: (detail: ThemeMenuOpenChangeDetail) => void;
  readonly onThemeChange?: (detail: ThemeMenuChangeDetail) => void;
  readonly align?: "start" | "end";
  readonly scheduler?: Scheduler;
}

interface UseThemeMenuResult {
  readonly service: ThemeMenuService;
  readonly connector: ThemeMenuApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<ThemeMenuSnapshot>;
}

export declare function createThemeMenuStore(initialInput: ThemeMenuInput, options?: CreateThemeMenuStoreOptions): ThemeMenuStore;

export interface CreateThemeMenuStoreOptions {
    readonly onOpenChange?: (detail: ThemeMenuOpenChangeDetail) => void;
    readonly onThemeChange?: (detail: ThemeMenuChangeDetail) => void;
    readonly onCommit?: () => void;
    readonly align?: "start" | "end" | (() => "start" | "end" | undefined);
    readonly scheduler?: Scheduler;
}

export declare const GR_THEME_MENU_DECLARATIONS: readonly [typeof ThemeMenuRoot, typeof GrThemeMenuTrigger, typeof GrThemeMenuOpen, typeof GrThemeMenuPositioner, typeof GrThemeMenuContent, typeof GrThemeMenuItem];

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