assistant-thread headless API

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

interface AssistantThreadContextValue {
  readonly connector: AssistantThreadApi;
  readonly scope: PartScope;
  readonly viewportStore: ThreadViewportStore;
  readonly viewportRef: RefObject<HTMLDivElement | null>;
  readonly following: boolean;
  readonly scrollToBottom: () => void;
}

interface AssistantThreadMessagesProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode | ((props: {
    readonly message: ThreadMessage;
    readonly index: number;
  }) => ReactNode);
  readonly components?: Partial<Record<"UserMessage" | "AssistantMessage" | "SystemMessage", ComponentType<{
    readonly message: ThreadMessage;
  }>>>;
}

interface AssistantThreadRootProps extends Omit<ComponentPropsWithoutRef<"div">, "onScroll"> {
  readonly asChild?: boolean;
  readonly autoScroll?: boolean;
  readonly turnAnchor?: boolean;
  readonly topAnchorMessageClamp?: number;
  readonly scrollToBottomOnRunStart?: boolean;
  readonly scrollToBottomOnInitialize?: boolean;
  readonly scrollToBottomOnThreadSwitch?: boolean;
  readonly children?: ReactNode;
}

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

interface AssistantThreadViewportFooterProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}

interface AssistantThreadViewportProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}

declare function MessageByIndex(props: {
  readonly index: number;
  readonly message?: ThreadMessage;
  readonly children?: ReactNode;
}): import("react").JSX.Element;

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

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

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

declare function SuggestionByIndex(props: {
  readonly index: number;
  readonly text: string;
  readonly children?: ReactNode;
}): import("react").JSX.Element;

declare function Suggestions(props: {
  readonly children?: ReactNode;
}): import("react").JSX.Element;

export declare const Thread: {
  Root: import("react").ForwardRefExoticComponent<AssistantThreadRootProps & import("react").RefAttributes<HTMLDivElement>>;
  Viewport: import("react").ForwardRefExoticComponent<AssistantThreadViewportProps & import("react").RefAttributes<HTMLDivElement>>;
  ViewportProvider: typeof ViewportProvider;
  ViewportFooter: import("react").ForwardRefExoticComponent<AssistantThreadViewportFooterProps & import("react").RefAttributes<HTMLDivElement>>;
  Messages: import("react").ForwardRefExoticComponent<AssistantThreadMessagesProps & import("react").RefAttributes<HTMLDivElement>>;
  MessageByIndex: typeof MessageByIndex;
  UnstableMessageById: typeof UnstableMessageById;
  ScrollToBottom: import("react").ForwardRefExoticComponent<AssistantThreadScrollToBottomProps & import("react").RefAttributes<HTMLButtonElement>>;
  Suggestions: typeof Suggestions;
  SuggestionByIndex: typeof SuggestionByIndex;
};

declare function UnstableMessageById(props: {
  readonly messageId: string;
  readonly children?: ReactNode;
}): import("react").JSX.Element;

declare function useAssistantThreadContext(partName: string): AssistantThreadContextValue;

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

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

declare function ViewportProvider(props: {
  readonly children?: ReactNode;
}): import("react").JSX.Element;

export declare const Assistant: {
  readonly Provider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    client: {
      type: PropType<AssistantClient>;
      required: true;
    };
  }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    client: {
      type: PropType<AssistantClient>;
      required: true;
    };
  }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  readonly Thread: {
    readonly Root: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Viewport: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Messages: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ViewportFooter: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ScrollToBottom: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly MessageByIndex: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      index: {
        type: NumberConstructor;
        required: true;
      };
      message: {
        type: PropType<ThreadMessage>;
        default: undefined;
      };
    }>, () => 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<{
      index: {
        type: NumberConstructor;
        required: true;
      };
      message: {
        type: PropType<ThreadMessage>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      message: ThreadMessage;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Suggestions: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly SuggestionByIndex: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      index: {
        type: NumberConstructor;
        required: true;
      };
      text: {
        type: StringConstructor;
        required: true;
      };
    }>, () => 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;
      };
      text: {
        type: StringConstructor;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly Message: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      message: {
        type: PropType<{
          id: string;
          role?: "user" | "assistant" | "system";
        }>;
        required: true;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      message: {
        type: PropType<{
          id: string;
          role?: "user" | "assistant" | "system";
        }>;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Parts: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly GroupedParts: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      parts: {
        type: PropType<readonly ThreadMessagePart[]>;
        default: undefined;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      parts: {
        type: PropType<readonly ThreadMessagePart[]>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      parts: readonly ThreadMessagePart[];
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly PartByIndex: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      index: {
        type: NumberConstructor;
        required: true;
      };
      part: {
        type: PropType<ThreadMessagePart>;
        default: undefined;
      };
    }>, () => 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<{
      index: {
        type: NumberConstructor;
        required: true;
      };
      part: {
        type: PropType<ThreadMessagePart>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      part: ThreadMessagePart;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly GenerativeUI: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<GenerativeUIMessagePart>;
        default: undefined;
      };
      spec: {
        type: PropType<unknown>;
        default: undefined;
      };
    }>, () => 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<{
      part: {
        type: PropType<GenerativeUIMessagePart>;
        default: undefined;
      };
      spec: {
        type: PropType<unknown>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      part: GenerativeUIMessagePart;
      spec: undefined;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Attachments: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      attachments: {
        type: PropType<readonly CompleteAttachment[]>;
        default: undefined;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      attachments: {
        type: PropType<readonly CompleteAttachment[]>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      attachments: readonly CompleteAttachment[];
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Quote: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Error: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      message: {
        type: PropType<{
          status?: AssistantErrorStatus;
        }>;
        required: true;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      message: {
        type: PropType<{
          status?: AssistantErrorStatus;
        }>;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly MessagePart: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<ThreadMessagePart>;
        required: true;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<ThreadMessagePart>;
        required: true;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
    }>> & Readonly<{}>, {
      index: number;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Text: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<AssistantMessagePartValue>;
        default: undefined;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
      asChild: {
        type: BooleanConstructor;
        default: boolean;
      };
    }>, () => 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<{
      part: {
        type: PropType<AssistantMessagePartValue>;
        default: undefined;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
      asChild: {
        type: BooleanConstructor;
        default: boolean;
      };
    }>> & Readonly<{}>, {
      part: AssistantMessagePartValue;
      index: number;
      asChild: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Image: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<ImageMessagePart>;
        default: undefined;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
      alt: {
        type: StringConstructor;
        default: string;
      };
    }>, () => 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<{
      part: {
        type: PropType<ImageMessagePart>;
        default: undefined;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
      alt: {
        type: StringConstructor;
        default: string;
      };
    }>> & Readonly<{}>, {
      part: ImageMessagePart;
      index: number;
      alt: string;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly InProgress: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<AssistantMessagePartValue>;
        default: undefined;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<AssistantMessagePartValue>;
        default: undefined;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
    }>> & Readonly<{}>, {
      part: AssistantMessagePartValue;
      index: number;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly GenerativeUI: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<GenerativeUIMessagePart>;
        default: undefined;
      };
      spec: {
        type: PropType<unknown>;
        default: undefined;
      };
    }>, () => 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<{
      part: {
        type: PropType<GenerativeUIMessagePart>;
        default: undefined;
      };
      spec: {
        type: PropType<unknown>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      part: GenerativeUIMessagePart;
      spec: undefined;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Render: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<ThreadMessagePart>;
        required: true;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      part: {
        type: PropType<ThreadMessagePart>;
        required: true;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
    }>> & Readonly<{}>, {
      index: number;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly If: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    condition: {
      type: PropType<AssistantIfCondition>;
      required: true;
    };
    fallback: {
      type: PropType<unknown>;
      default: undefined;
    };
  }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>[] | VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }> | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    condition: {
      type: PropType<AssistantIfCondition>;
      required: true;
    };
    fallback: {
      type: PropType<unknown>;
      default: undefined;
    };
  }>> & Readonly<{}>, {
    fallback: undefined;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  readonly GenerativeUI: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    spec: {
      type: PropType<unknown>;
      required: true;
    };
    unknown: {
      type: PropType<import("@grassroot/ui-headless-core").GenerativeUIUnknownMode>;
      default: string;
    };
  }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    spec: {
      type: PropType<unknown>;
      required: true;
    };
    unknown: {
      type: PropType<import("@grassroot/ui-headless-core").GenerativeUIUnknownMode>;
      default: string;
    };
  }>> & Readonly<{}>, {
    unknown: import("@grassroot/ui-headless-core").GenerativeUIUnknownMode;
  }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  readonly BranchPicker: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      branches: {
        type: PropType<readonly string[]>;
        required: true;
      };
      currentIndex: {
        type: NumberConstructor;
        default: number;
      };
      isRunning: {
        type: BooleanConstructor;
        default: boolean;
      };
      switchBranchDuringRun: {
        type: BooleanConstructor;
        default: boolean;
      };
      onSwitch: {
        type: PropType<(branchId: string) => void>;
        default: undefined;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      branches: {
        type: PropType<readonly string[]>;
        required: true;
      };
      currentIndex: {
        type: NumberConstructor;
        default: number;
      };
      isRunning: {
        type: BooleanConstructor;
        default: boolean;
      };
      switchBranchDuringRun: {
        type: BooleanConstructor;
        default: boolean;
      };
      onSwitch: {
        type: PropType<(branchId: string) => void>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      currentIndex: number;
      isRunning: boolean;
      switchBranchDuringRun: boolean;
      onSwitch: (branchId: string) => void;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Previous: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Next: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Number: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Count: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly Error: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    message: {
      type: PropType<{
        status?: AssistantErrorStatus;
      }>;
      required: true;
    };
  }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    message: {
      type: PropType<{
        status?: AssistantErrorStatus;
      }>;
      required: true;
    };
  }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  readonly Suggestion: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      text: {
        type: StringConstructor;
        required: true;
      };
      send: {
        type: BooleanConstructor;
        default: boolean;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      text: {
        type: StringConstructor;
        required: true;
      };
      send: {
        type: BooleanConstructor;
        default: boolean;
      };
    }>> & Readonly<{}>, {
      send: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Title: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Description: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Trigger: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly Composer: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      compact: BooleanConstructor;
      submitMode: PropType<import("@grassroot/ui-headless-core").AssistantComposerConnectOptions["submitMode"]>;
      cancelOnEscape: BooleanConstructor;
      addAttachmentOnPaste: BooleanConstructor;
      steerHotkey: PropType<import("@grassroot/ui-headless-core").AssistantComposerConnectOptions["steerHotkey"]>;
      unstableInsertNewlineOnTouchEnter: BooleanConstructor;
      inputLabel: StringConstructor;
      attachmentAccept: StringConstructor;
      attachmentMultiple: {
        type: BooleanConstructor;
        default: boolean;
      };
      onSubmit: PropType<(event?: unknown) => void>;
      onAddAttachment: PropType<(files: readonly File[]) => void>;
      onDictate: PropType<() => void>;
      onStopDictation: PropType<() => void>;
      onQuoteDismiss: PropType<() => void>;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      compact: BooleanConstructor;
      submitMode: PropType<import("@grassroot/ui-headless-core").AssistantComposerConnectOptions["submitMode"]>;
      cancelOnEscape: BooleanConstructor;
      addAttachmentOnPaste: BooleanConstructor;
      steerHotkey: PropType<import("@grassroot/ui-headless-core").AssistantComposerConnectOptions["steerHotkey"]>;
      unstableInsertNewlineOnTouchEnter: BooleanConstructor;
      inputLabel: StringConstructor;
      attachmentAccept: StringConstructor;
      attachmentMultiple: {
        type: BooleanConstructor;
        default: boolean;
      };
      onSubmit: PropType<(event?: unknown) => void>;
      onAddAttachment: PropType<(files: readonly File[]) => void>;
      onDictate: PropType<() => void>;
      onStopDictation: PropType<() => void>;
      onQuoteDismiss: PropType<() => void>;
    }>> & Readonly<{}>, {
      compact: boolean;
      cancelOnEscape: boolean;
      addAttachmentOnPaste: boolean;
      unstableInsertNewlineOnTouchEnter: boolean;
      attachmentMultiple: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Input: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      submitMode: PropType<import("@grassroot/ui-headless-core").AssistantComposerInputOptions["submitMode"]>;
      cancelOnEscape: BooleanConstructor;
      addAttachmentOnPaste: BooleanConstructor;
      steerHotkey: PropType<import("@grassroot/ui-headless-core").AssistantComposerInputOptions["steerHotkey"]>;
      unstableInsertNewlineOnTouchEnter: BooleanConstructor;
      inputLabel: StringConstructor;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      submitMode: PropType<import("@grassroot/ui-headless-core").AssistantComposerInputOptions["submitMode"]>;
      cancelOnEscape: BooleanConstructor;
      addAttachmentOnPaste: BooleanConstructor;
      steerHotkey: PropType<import("@grassroot/ui-headless-core").AssistantComposerInputOptions["steerHotkey"]>;
      unstableInsertNewlineOnTouchEnter: BooleanConstructor;
      inputLabel: StringConstructor;
    }>> & Readonly<{}>, {
      cancelOnEscape: boolean;
      addAttachmentOnPaste: boolean;
      unstableInsertNewlineOnTouchEnter: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Send: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Cancel: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly AddAttachment: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly AddAttachmentInput: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Attachments: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly AttachmentByIndex: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      index: {
        type: NumberConstructor;
        required: true;
      };
    }>, () => 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<{
      index: {
        type: NumberConstructor;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly AttachmentDropzone: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Dictate: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly StopDictation: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly DictationTranscript: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Quote: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly QuoteText: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly QuoteDismiss: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Queue: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopoverRoot: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopover: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopoverCategories: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopoverCategoryItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      category: {
        type: StringConstructor;
        required: true;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      category: {
        type: StringConstructor;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopoverItems: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopoverItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      item: {
        type: PropType<import("@grassroot/ui-headless-core").TriggerPopoverItem>;
        required: true;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      item: {
        type: PropType<import("@grassroot/ui-headless-core").TriggerPopoverItem>;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly TriggerPopoverBack: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly ActionBar: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      message: PropType<import("@grassroot/ui-headless-core").ExportableMessage>;
      messageId: StringConstructor;
      copyText: StringConstructor;
      hideWhenRunning: BooleanConstructor;
      autohide: PropType<"always" | "not-last" | "never">;
      autohideFloat: BooleanConstructor;
      isLast: BooleanConstructor;
      copiedDuration: NumberConstructor;
      onFeedback: PropType<(feedback: "positive" | "negative") => void>;
      onExport: PropType<(markdown: string) => void>;
      onReload: PropType<() => void>;
      onEdit: PropType<() => void>;
      onSpeak: PropType<() => void>;
      onStopSpeaking: PropType<() => void>;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      message: PropType<import("@grassroot/ui-headless-core").ExportableMessage>;
      messageId: StringConstructor;
      copyText: StringConstructor;
      hideWhenRunning: BooleanConstructor;
      autohide: PropType<"always" | "not-last" | "never">;
      autohideFloat: BooleanConstructor;
      isLast: BooleanConstructor;
      copiedDuration: NumberConstructor;
      onFeedback: PropType<(feedback: "positive" | "negative") => void>;
      onExport: PropType<(markdown: string) => void>;
      onReload: PropType<() => void>;
      onEdit: PropType<() => void>;
      onSpeak: PropType<() => void>;
      onStopSpeaking: PropType<() => void>;
    }>> & Readonly<{}>, {
      hideWhenRunning: boolean;
      autohideFloat: boolean;
      isLast: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Copy: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Reload: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Edit: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Speak: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly StopSpeaking: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly FeedbackPositive: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly FeedbackNegative: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ExportMarkdown: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly More: {
      readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        open: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["open"]>;
          default: undefined;
        };
        defaultOpen: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["defaultOpen"]>;
          default: undefined;
        };
        items: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["items"]>;
          required: true;
        };
        typeaheadTimeoutMs: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["typeaheadTimeoutMs"]>;
          default: undefined;
        };
        align: {
          type: PropType<UseDropdownMenuOptions["align"]>;
          default: undefined;
        };
        scheduler: {
          type: PropType<UseDropdownMenuOptions["scheduler"]>;
          default: undefined;
        };
      }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
      }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        openChange: (_detail: DropdownMenuOpenChangeDetail) => true;
        select: (_id: string) => true;
      }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        open: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["open"]>;
          default: undefined;
        };
        defaultOpen: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["defaultOpen"]>;
          default: undefined;
        };
        items: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["items"]>;
          required: true;
        };
        typeaheadTimeoutMs: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["typeaheadTimeoutMs"]>;
          default: undefined;
        };
        align: {
          type: PropType<UseDropdownMenuOptions["align"]>;
          default: undefined;
        };
        scheduler: {
          type: PropType<UseDropdownMenuOptions["scheduler"]>;
          default: undefined;
        };
      }>> & Readonly<{
        onOpenChange?: ((_detail: DropdownMenuOpenChangeDetail) => any) | undefined;
        onSelect?: ((_id: string) => any) | undefined;
      }>, {
        open: boolean | undefined;
        defaultOpen: boolean | undefined;
        typeaheadTimeoutMs: number | undefined;
        align: "end" | "start" | undefined;
        scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
      }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
      readonly Trigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
      }>, () => 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>;
      readonly Positioner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
      }>, () => 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>;
      readonly Content: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
      }>, () => 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>;
      readonly Item: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
        item: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuItem>;
          required: true;
        };
      }>, () => 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<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuItem>;
          required: true;
        };
      }>> & Readonly<{}>, {
        asChild: boolean;
      }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    };
  };
  readonly Attachment: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      attachment: {
        type: PropType<import("@grassroot/ui-headless-core").AssistantComposerAttachmentLike>;
        required: true;
      };
      inMessage: BooleanConstructor;
      onRemove: PropType<() => void>;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      attachment: {
        type: PropType<import("@grassroot/ui-headless-core").AssistantComposerAttachmentLike>;
        required: true;
      };
      inMessage: BooleanConstructor;
      onRemove: PropType<() => void>;
    }>> & Readonly<{}>, {
      inMessage: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly UnstableThumb: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Name: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Remove: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly ThreadList: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      dir: {
        type: PropType<"ltr" | "rtl">;
        default: string;
      };
      canCreate: {
        type: BooleanConstructor;
        default: undefined;
      };
      onNew: PropType<() => void>;
      onSelect: PropType<(id: string) => void>;
      onLoadMore: PropType<() => void>;
      onOpenMore: PropType<(item: import("@grassroot/ui-headless-core").AssistantThreadListItemLike, index: number) => void>;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      dir: {
        type: PropType<"ltr" | "rtl">;
        default: string;
      };
      canCreate: {
        type: BooleanConstructor;
        default: undefined;
      };
      onNew: PropType<() => void>;
      onSelect: PropType<(id: string) => void>;
      onLoadMore: PropType<() => void>;
      onOpenMore: PropType<(item: import("@grassroot/ui-headless-core").AssistantThreadListItemLike, index: number) => void>;
    }>> & Readonly<{}>, {
      dir: "ltr" | "rtl";
      canCreate: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly New: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Items: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Item: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      item: {
        type: PropType<import("@grassroot/ui-headless-core").AssistantThreadListItemLike>;
        required: true;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
      fallbackTitle: StringConstructor;
      onSelect: PropType<() => void>;
      onArchive: PropType<() => void>;
      onUnarchive: PropType<() => void>;
      onDelete: PropType<() => void>;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      item: {
        type: PropType<import("@grassroot/ui-headless-core").AssistantThreadListItemLike>;
        required: true;
      };
      index: {
        type: NumberConstructor;
        default: number;
      };
      fallbackTitle: StringConstructor;
      onSelect: PropType<() => void>;
      onArchive: PropType<() => void>;
      onUnarchive: PropType<() => void>;
      onDelete: PropType<() => void>;
    }>> & Readonly<{}>, {
      index: number;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ItemByIndex: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      index: {
        type: NumberConstructor;
        required: true;
      };
    }>, () => 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<{
      index: {
        type: NumberConstructor;
        required: true;
      };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ItemTrigger: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ItemTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      fallback: StringConstructor;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      fallback: StringConstructor;
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Archive: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Unarchive: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Delete: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ItemArchive: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ItemUnarchive: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ItemDelete: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly LoadMore: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly More: {
      readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        open: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["open"]>;
          default: undefined;
        };
        defaultOpen: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["defaultOpen"]>;
          default: undefined;
        };
        items: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["items"]>;
          required: true;
        };
        typeaheadTimeoutMs: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["typeaheadTimeoutMs"]>;
          default: undefined;
        };
        align: {
          type: PropType<UseDropdownMenuOptions["align"]>;
          default: undefined;
        };
        scheduler: {
          type: PropType<UseDropdownMenuOptions["scheduler"]>;
          default: undefined;
        };
      }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
      }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        openChange: (_detail: DropdownMenuOpenChangeDetail) => true;
        select: (_id: string) => true;
      }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        open: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["open"]>;
          default: undefined;
        };
        defaultOpen: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["defaultOpen"]>;
          default: undefined;
        };
        items: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["items"]>;
          required: true;
        };
        typeaheadTimeoutMs: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuInput["typeaheadTimeoutMs"]>;
          default: undefined;
        };
        align: {
          type: PropType<UseDropdownMenuOptions["align"]>;
          default: undefined;
        };
        scheduler: {
          type: PropType<UseDropdownMenuOptions["scheduler"]>;
          default: undefined;
        };
      }>> & Readonly<{
        onOpenChange?: ((_detail: DropdownMenuOpenChangeDetail) => any) | undefined;
        onSelect?: ((_id: string) => any) | undefined;
      }>, {
        open: boolean | undefined;
        defaultOpen: boolean | undefined;
        typeaheadTimeoutMs: number | undefined;
        align: "end" | "start" | undefined;
        scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
      }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
      readonly Trigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
      }>, () => 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>;
      readonly Positioner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
      }>, () => 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>;
      readonly Content: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
      }>, () => 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>;
      readonly Item: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        asChild: {
          type: BooleanConstructor;
          default: boolean;
        };
        item: {
          type: PropType<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuItem>;
          required: true;
        };
      }>, () => 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<import("@grassroot/ui-machines/dropdown-menu").DropdownMenuItem>;
          required: true;
        };
      }>> & Readonly<{}>, {
        asChild: boolean;
      }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    };
  };
  readonly Modal: {
    readonly Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      open: PropType<import("@grassroot/ui-machines/popover").PopoverInput["open"]>;
      defaultOpen: PropType<import("@grassroot/ui-machines/popover").PopoverInput["defaultOpen"]>;
      side: PropType<import("@grassroot/ui-machines/popover").PopoverInput["side"]>;
      align: PropType<import("@grassroot/ui-machines/popover").PopoverInput["align"]>;
      modal: {
        type: BooleanConstructor;
        default: boolean;
      };
      unstableOpenOnRunStart: BooleanConstructor;
      dissmissOnInteractOutside: BooleanConstructor;
      dismissOnInteractOutside: BooleanConstructor;
      onOpenChange: PropType<(detail: {
        open: boolean;
        reason: any;
      }) => void>;
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      open: PropType<import("@grassroot/ui-machines/popover").PopoverInput["open"]>;
      defaultOpen: PropType<import("@grassroot/ui-machines/popover").PopoverInput["defaultOpen"]>;
      side: PropType<import("@grassroot/ui-machines/popover").PopoverInput["side"]>;
      align: PropType<import("@grassroot/ui-machines/popover").PopoverInput["align"]>;
      modal: {
        type: BooleanConstructor;
        default: boolean;
      };
      unstableOpenOnRunStart: BooleanConstructor;
      dissmissOnInteractOutside: BooleanConstructor;
      dismissOnInteractOutside: BooleanConstructor;
      onOpenChange: PropType<(detail: {
        open: boolean;
        reason: any;
      }) => void>;
    }>> & Readonly<{}>, {
      modal: boolean;
      unstableOpenOnRunStart: boolean;
      dissmissOnInteractOutside: boolean;
      dismissOnInteractOutside: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Trigger: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Anchor: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Content: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Title: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Description: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Close: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly SelectionToolbar: {
    Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      onQuote: {
        type: PropType<(selection: import("@grassroot/ui-headless-core").SelectionObserverSelection) => void>;
        default: undefined;
      };
      quoteLabel: {
        type: StringConstructor;
        default: undefined;
      };
    }>, () => 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<{
      onQuote: {
        type: PropType<(selection: import("@grassroot/ui-headless-core").SelectionObserverSelection) => void>;
        default: undefined;
      };
      quoteLabel: {
        type: StringConstructor;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      onQuote: (selection: import("@grassroot/ui-headless-core").SelectionObserverSelection) => void;
      quoteLabel: string;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Quote: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly ChainOfThought: {
    Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      open: {
        type: BooleanConstructor;
        default: undefined;
      };
      defaultOpen: {
        type: BooleanConstructor;
        default: undefined;
      };
      disabled: {
        type: BooleanConstructor;
        default: undefined;
      };
      onOpenChange: {
        type: PropType<(detail: {
          open: boolean;
          reason: string;
        }) => void>;
        default: undefined;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      open: {
        type: BooleanConstructor;
        default: undefined;
      };
      defaultOpen: {
        type: BooleanConstructor;
        default: undefined;
      };
      disabled: {
        type: BooleanConstructor;
        default: undefined;
      };
      onOpenChange: {
        type: PropType<(detail: {
          open: boolean;
          reason: string;
        }) => void>;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      open: boolean;
      defaultOpen: boolean;
      disabled: boolean;
      onOpenChange: (detail: {
        open: boolean;
        reason: string;
      }) => void;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    AccordionTrigger: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Trigger: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Parts: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
  readonly QueueItem: {
    Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
      item: {
        type: PropType<import("@grassroot/ui-headless-core").AssistantQueueItemLike>;
        required: true;
      };
      onSteer: {
        type: PropType<(item: import("@grassroot/ui-headless-core").AssistantQueueItemLike) => void>;
        default: undefined;
      };
      onRemove: {
        type: PropType<(item: import("@grassroot/ui-headless-core").AssistantQueueItemLike) => void>;
        default: undefined;
      };
      disabled: {
        type: BooleanConstructor;
        default: undefined;
      };
    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
      item: {
        type: PropType<import("@grassroot/ui-headless-core").AssistantQueueItemLike>;
        required: true;
      };
      onSteer: {
        type: PropType<(item: import("@grassroot/ui-headless-core").AssistantQueueItemLike) => void>;
        default: undefined;
      };
      onRemove: {
        type: PropType<(item: import("@grassroot/ui-headless-core").AssistantQueueItemLike) => void>;
        default: undefined;
      };
      disabled: {
        type: BooleanConstructor;
        default: undefined;
      };
    }>> & Readonly<{}>, {
      onSteer: (item: import("@grassroot/ui-headless-core").AssistantQueueItemLike) => void;
      onRemove: (item: import("@grassroot/ui-headless-core").AssistantQueueItemLike) => void;
      disabled: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Text: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Steer: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Remove: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
      [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
  };
};