grassroot
Install

DocsAPI referenceHeadlessassistant-chain-of-thought

assistant-chain-of-thought headless API

The core connector and vanilla mount are always visible. Use the framework choice to inspect native composition, props, outputs, context and hooks for the selected adapter.

@grassroot/ui-headless-core/assistant-chain-of-thought

Core connector and vanilla API

4 exports
View source packages/ui-headless/core/src/assistant-chain-of-thought/index.ts

assistantChainOfThoughtAnatomy

value
DeclarationView source
assistantChainOfThoughtAnatomyts
export declare const assistantChainOfThoughtAnatomy: {
  readonly scope: "assistant-chain-of-thought";
  readonly parts: readonly ["root", "accordion-trigger", "parts"];
};
Name
Kind
Type
Requirement
parts
property
readonly ["root", "accordion-trigger", "parts"]
required
scope
property
"assistant-chain-of-thought"
required
Name
parts
Kind
property
Type
readonly ["root", "accordion-trigger", "parts"]
Requirement
required
Name
scope
Kind
property
Type
"assistant-chain-of-thought"
Requirement
required

AssistantChainOfThoughtApi

interface
DeclarationView source
AssistantChainOfThoughtApits
interface AssistantChainOfThoughtApi {
  rootProps(): PartProps;
  triggerProps(): PartProps;
  partsProps(): PartProps;
  readonly open: boolean;
}
Name
Kind
Type
Requirement
open
property
boolean
required
partsProps
method
() => PartProps
required
rootProps
method
() => PartProps
required
triggerProps
method
() => PartProps
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
partsProps
Kind
method
Type
() => PartProps
Requirement
required
Name
rootProps
Kind
method
Type
() => PartProps
Requirement
required
Name
triggerProps
Kind
method
Type
() => PartProps
Requirement
required

AssistantChainOfThoughtPart

type
DeclarationView source
AssistantChainOfThoughtPartts
type AssistantChainOfThoughtPart = (typeof assistantChainOfThoughtAnatomy.parts)[number];

connectAssistantChainOfThought

function
DeclarationView source
connectAssistantChainOfThoughtts
declare function connectAssistantChainOfThought(collapsible: CollapsibleApi, scope: PartScope): AssistantChainOfThoughtApi;
Name
Kind
Type
Requirement
collapsible
parameter
CollapsibleApi
required
scope
parameter
PartScope
required
return
return value
AssistantChainOfThoughtApi
n/a
Name
collapsible
Kind
parameter
Type
CollapsibleApi
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
return
Kind
return value
Type
AssistantChainOfThoughtApi
Requirement
n/a

Framework adapters

Each panel keeps its adapter's public vocabulary. React compound exports, Vue composables, standalone Angular declarations, Svelte components, and Solid hooks stay native to their framework.

React example follows below.

React imports

@grassroot/ui-headless-react/assistant-chain-of-thoughtts
import { AccordionTrigger, ChainOfThought, Parts, Root, Trigger } from "@grassroot/ui-headless-react/assistant-chain-of-thought";

Vue imports

@grassroot/ui-headless-vue/assistant-chain-of-thoughtts
<script setup lang="ts">
import { AccordionTrigger, AssistantChainOfThought, Parts, Root, Trigger } from "@grassroot/ui-headless-vue/assistant-chain-of-thought";
</script>

Angular imports

@grassroot/ui-headless-angular/assistant-chain-of-thoughtts
import { GrAssistantB3Surface, GrAssistantChainOfThoughtParts, GrAssistantChainOfThoughtRoot, GrAssistantChainOfThoughtTrigger } from "@grassroot/ui-headless-angular/assistant-chain-of-thought";

Svelte imports

@grassroot/ui-headless-svelte/assistant-chain-of-thoughtts
<script lang="ts">
  import { AccordionTrigger, AssistantChainOfThought, Parts, Root, Trigger } from "@grassroot/ui-headless-svelte/assistant-chain-of-thought";
</script>

Solid imports

@grassroot/ui-headless-solid/assistant-chain-of-thoughtts
import { AccordionTrigger, AssistantChainOfThought, Parts, Root, Trigger } from "@grassroot/ui-headless-solid/assistant-chain-of-thought";

@grassroot/ui-headless-react/assistant-chain-of-thought

React adapter

13 exports
View source packages/ui-headless/react/src/assistant-chain-of-thought/index.ts

AccordionTrigger

value
DeclarationView source
AccordionTriggerts
export declare const AccordionTrigger: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AssistantChainOfThoughtChangeDetail

interface
DeclarationView source
AssistantChainOfThoughtChangeDetailts
interface AssistantChainOfThoughtChangeDetail {
  readonly open: boolean;
  readonly reason: CollapsibleChangeReason;
}
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
CollapsibleChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
CollapsibleChangeReason
Requirement
required

AssistantChainOfThoughtContext

value
DeclarationView source
AssistantChainOfThoughtContextts
export declare const AssistantChainOfThoughtContext: import("react").Context<AssistantChainOfThoughtContextValue | null>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

AssistantChainOfThoughtContextValue

interface
DeclarationView source
AssistantChainOfThoughtContextValuets
interface AssistantChainOfThoughtContextValue {
  readonly connector: AssistantChainOfThoughtApi;
  readonly scope: PartScope;
}
Name
Kind
Type
Requirement
connector
property
AssistantChainOfThoughtApi
required
scope
property
PartScope
required
Name
connector
Kind
property
Type
AssistantChainOfThoughtApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required

AssistantChainOfThoughtRootProps

interface
DeclarationView source
AssistantChainOfThoughtRootPropsts
interface AssistantChainOfThoughtRootProps extends Omit<ComponentPropsWithoutRef<"div">, "open" | "defaultOpen" | "onChange"> {
  readonly asChild?: boolean;
  readonly open?: CollapsibleInput["open"];
  readonly defaultOpen?: CollapsibleInput["defaultOpen"];
  readonly disabled?: CollapsibleInput["disabled"];
  readonly onOpenChange?: (detail: {
    readonly open: boolean;
    readonly reason: string;
  }) => void;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
defaultOpen
property
CollapsibleInput["defaultOpen"]
optional
disabled
property
CollapsibleInput["disabled"]
optional
onOpenChange
property
(detail: { readonly open: boolean; readonly reason: string; }) => void
optional
open
property
CollapsibleInput["open"]
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
defaultOpen
Kind
property
Type
CollapsibleInput["defaultOpen"]
Requirement
optional
Name
disabled
Kind
property
Type
CollapsibleInput["disabled"]
Requirement
optional
Name
onOpenChange
Kind
property
Type
(detail: { readonly open: boolean; readonly reason: string; }) => void
Requirement
optional
Name
open
Kind
property
Type
CollapsibleInput["open"]
Requirement
optional

ChainOfThought

value
DeclarationView source
ChainOfThoughtts
export declare const ChainOfThought: {
  Root: import("react").ForwardRefExoticComponent<AssistantChainOfThoughtRootProps & import("react").RefAttributes<HTMLDivElement>>;
  AccordionTrigger: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
  Trigger: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
  Parts: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
};
Name
Kind
Type
Requirement
AccordionTrigger
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>
required
Parts
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>
required
Root
property
import("react").ForwardRefExoticComponent<AssistantChainOfThoughtRootProps & import("react").RefAttributes<HTMLDivElement>>
required
Trigger
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>
required
Name
AccordionTrigger
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>
Requirement
required
Name
Parts
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Root
Kind
property
Type
import("react").ForwardRefExoticComponent<AssistantChainOfThoughtRootProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Trigger
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>
Requirement
required

Parts

value
DeclarationView source
Partsts
export declare const Parts: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Root

value
DeclarationView source
Rootts
export declare const Root: import("react").ForwardRefExoticComponent<AssistantChainOfThoughtRootProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Trigger

value
DeclarationView source
Triggerts
export declare const Trigger: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

useAssistantChainOfThought

function
DeclarationView source
useAssistantChainOfThoughtts
declare function useAssistantChainOfThought(input: CollapsibleInput, options?: UseAssistantChainOfThoughtOptions): UseAssistantChainOfThoughtResult;
Name
Kind
Type
Requirement
input
parameter
CollapsibleInput
required
options
parameter
UseAssistantChainOfThoughtOptions
optional
return
return value
UseAssistantChainOfThoughtResult
n/a
Name
input
Kind
parameter
Type
CollapsibleInput
Requirement
required
Name
options
Kind
parameter
Type
UseAssistantChainOfThoughtOptions
Requirement
optional
Name
return
Kind
return value
Type
UseAssistantChainOfThoughtResult
Requirement
n/a

useAssistantChainOfThoughtContext

function
DeclarationView source
useAssistantChainOfThoughtContextts
declare function useAssistantChainOfThoughtContext(part: string): AssistantChainOfThoughtContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
AssistantChainOfThoughtContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
AssistantChainOfThoughtContextValue
Requirement
n/a

UseAssistantChainOfThoughtOptions

interface
DeclarationView source
UseAssistantChainOfThoughtOptionsts
interface UseAssistantChainOfThoughtOptions {
  readonly onOpenChange?: (detail: AssistantChainOfThoughtChangeDetail) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: AssistantChainOfThoughtChangeDetail) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: AssistantChainOfThoughtChangeDetail) => void
Requirement
optional

UseAssistantChainOfThoughtResult

interface
DeclarationView source
UseAssistantChainOfThoughtResultts
interface UseAssistantChainOfThoughtResult {
  readonly service: CollapsibleService;
  readonly connector: AssistantChainOfThoughtApi;
  readonly scope: PartScope;
  readonly snapshot: CollapsibleSnapshot;
}
Name
Kind
Type
Requirement
connector
property
AssistantChainOfThoughtApi
required
scope
property
PartScope
required
service
property
CollapsibleService
required
snapshot
property
CollapsibleSnapshot
required
Name
connector
Kind
property
Type
AssistantChainOfThoughtApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
CollapsibleService
Requirement
required
Name
snapshot
Kind
property
Type
CollapsibleSnapshot
Requirement
required

@grassroot/ui-headless-vue/assistant-chain-of-thought

Vue adapter

5 exports
View source packages/ui-headless/vue/src/assistant-chain-of-thought/index.ts

AccordionTrigger

value
DeclarationView source
AccordionTriggerts
export declare const 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>;

AssistantChainOfThought

value
DeclarationView source
AssistantChainOfThoughtts
export declare const AssistantChainOfThought: {
  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>;
};
Name
Kind
Type
Requirement
AccordionTrigger
property
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>
required
Parts
property
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>
required
Root
property
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>
required
Trigger
property
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>
required
Name
AccordionTrigger
Kind
property
Type
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>
Requirement
required
Name
Parts
Kind
property
Type
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>
Requirement
required
Name
Root
Kind
property
Type
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>
Requirement
required
Name
Trigger
Kind
property
Type
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>
Requirement
required

Parts

value
DeclarationView source
Partsts
export declare const 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>;

Root

value
DeclarationView source
Rootts
export declare const 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>;

Trigger

value
DeclarationView source
Triggerts
export declare const 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>;

@grassroot/ui-headless-angular/assistant-chain-of-thought

Angular adapter

4 exports
View source packages/ui-headless/angular/src/assistant-chain-of-thought/index.ts

GrAssistantB3Surface

class
DeclarationView source
GrAssistantB3Surfacets
export declare class GrAssistantB3Surface implements OnDestroy {
    readonly client: import("@angular/core").InputSignal<AssistantClient | undefined>;
    readonly queueEvents: import("@angular/core").WritableSignal<string>;
    readonly quoteText: import("@angular/core").WritableSignal<string>;
    readonly quoteMessageId: import("@angular/core").WritableSignal<string>;
    readonly version: import("@angular/core").WritableSignal<number>;
    private readonly host;
    private state;
    private readonly cleanup;
    constructor();
    private ensureState;
    private syncDom;
    private apply;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
apply
property
any
required
cleanup
property
any
required
client
property
import("@angular/core").InputSignal<AssistantClient | undefined>
required
ensureState
property
any
required
host
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
required
queueEvents
property
import("@angular/core").WritableSignal<string>
required
quoteMessageId
property
import("@angular/core").WritableSignal<string>
required
quoteText
property
import("@angular/core").WritableSignal<string>
required
state
property
any
required
syncDom
property
any
required
version
property
import("@angular/core").WritableSignal<number>
required
Name
apply
Kind
property
Type
any
Requirement
required
Name
cleanup
Kind
property
Type
any
Requirement
required
Name
client
Kind
property
Type
import("@angular/core").InputSignal<AssistantClient | undefined>
Requirement
required
Name
ensureState
Kind
property
Type
any
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
Requirement
required
Name
queueEvents
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteMessageId
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteText
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
state
Kind
property
Type
any
Requirement
required
Name
syncDom
Kind
property
Type
any
Requirement
required
Name
version
Kind
property
Type
import("@angular/core").WritableSignal<number>
Requirement
required

GrAssistantChainOfThoughtParts

class
DeclarationView source
GrAssistantChainOfThoughtPartsts
export declare class GrAssistantB3Surface implements OnDestroy {
    readonly client: import("@angular/core").InputSignal<AssistantClient | undefined>;
    readonly queueEvents: import("@angular/core").WritableSignal<string>;
    readonly quoteText: import("@angular/core").WritableSignal<string>;
    readonly quoteMessageId: import("@angular/core").WritableSignal<string>;
    readonly version: import("@angular/core").WritableSignal<number>;
    private readonly host;
    private state;
    private readonly cleanup;
    constructor();
    private ensureState;
    private syncDom;
    private apply;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
apply
property
any
required
cleanup
property
any
required
client
property
import("@angular/core").InputSignal<AssistantClient | undefined>
required
ensureState
property
any
required
host
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
required
queueEvents
property
import("@angular/core").WritableSignal<string>
required
quoteMessageId
property
import("@angular/core").WritableSignal<string>
required
quoteText
property
import("@angular/core").WritableSignal<string>
required
state
property
any
required
syncDom
property
any
required
version
property
import("@angular/core").WritableSignal<number>
required
Name
apply
Kind
property
Type
any
Requirement
required
Name
cleanup
Kind
property
Type
any
Requirement
required
Name
client
Kind
property
Type
import("@angular/core").InputSignal<AssistantClient | undefined>
Requirement
required
Name
ensureState
Kind
property
Type
any
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
Requirement
required
Name
queueEvents
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteMessageId
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteText
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
state
Kind
property
Type
any
Requirement
required
Name
syncDom
Kind
property
Type
any
Requirement
required
Name
version
Kind
property
Type
import("@angular/core").WritableSignal<number>
Requirement
required

GrAssistantChainOfThoughtRoot

class
DeclarationView source
GrAssistantChainOfThoughtRootts
export declare class GrAssistantB3Surface implements OnDestroy {
    readonly client: import("@angular/core").InputSignal<AssistantClient | undefined>;
    readonly queueEvents: import("@angular/core").WritableSignal<string>;
    readonly quoteText: import("@angular/core").WritableSignal<string>;
    readonly quoteMessageId: import("@angular/core").WritableSignal<string>;
    readonly version: import("@angular/core").WritableSignal<number>;
    private readonly host;
    private state;
    private readonly cleanup;
    constructor();
    private ensureState;
    private syncDom;
    private apply;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
apply
property
any
required
cleanup
property
any
required
client
property
import("@angular/core").InputSignal<AssistantClient | undefined>
required
ensureState
property
any
required
host
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
required
queueEvents
property
import("@angular/core").WritableSignal<string>
required
quoteMessageId
property
import("@angular/core").WritableSignal<string>
required
quoteText
property
import("@angular/core").WritableSignal<string>
required
state
property
any
required
syncDom
property
any
required
version
property
import("@angular/core").WritableSignal<number>
required
Name
apply
Kind
property
Type
any
Requirement
required
Name
cleanup
Kind
property
Type
any
Requirement
required
Name
client
Kind
property
Type
import("@angular/core").InputSignal<AssistantClient | undefined>
Requirement
required
Name
ensureState
Kind
property
Type
any
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
Requirement
required
Name
queueEvents
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteMessageId
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteText
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
state
Kind
property
Type
any
Requirement
required
Name
syncDom
Kind
property
Type
any
Requirement
required
Name
version
Kind
property
Type
import("@angular/core").WritableSignal<number>
Requirement
required

GrAssistantChainOfThoughtTrigger

class
DeclarationView source
GrAssistantChainOfThoughtTriggerts
export declare class GrAssistantB3Surface implements OnDestroy {
    readonly client: import("@angular/core").InputSignal<AssistantClient | undefined>;
    readonly queueEvents: import("@angular/core").WritableSignal<string>;
    readonly quoteText: import("@angular/core").WritableSignal<string>;
    readonly quoteMessageId: import("@angular/core").WritableSignal<string>;
    readonly version: import("@angular/core").WritableSignal<number>;
    private readonly host;
    private state;
    private readonly cleanup;
    constructor();
    private ensureState;
    private syncDom;
    private apply;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
apply
property
any
required
cleanup
property
any
required
client
property
import("@angular/core").InputSignal<AssistantClient | undefined>
required
ensureState
property
any
required
host
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
required
queueEvents
property
import("@angular/core").WritableSignal<string>
required
quoteMessageId
property
import("@angular/core").WritableSignal<string>
required
quoteText
property
import("@angular/core").WritableSignal<string>
required
state
property
any
required
syncDom
property
any
required
version
property
import("@angular/core").WritableSignal<number>
required
Name
apply
Kind
property
Type
any
Requirement
required
Name
cleanup
Kind
property
Type
any
Requirement
required
Name
client
Kind
property
Type
import("@angular/core").InputSignal<AssistantClient | undefined>
Requirement
required
Name
ensureState
Kind
property
Type
any
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrAssistantB3Surface, "gr-assistant-b3-surface", never, { "client": { "alias": "client"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrAssistantB3Surface, never>
Requirement
required
Name
queueEvents
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteMessageId
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
quoteText
Kind
property
Type
import("@angular/core").WritableSignal<string>
Requirement
required
Name
state
Kind
property
Type
any
Requirement
required
Name
syncDom
Kind
property
Type
any
Requirement
required
Name
version
Kind
property
Type
import("@angular/core").WritableSignal<number>
Requirement
required

@grassroot/ui-headless-svelte/assistant-chain-of-thought

Svelte adapter

5 exports
View source packages/ui-headless/svelte/src/assistant-chain-of-thought/index.ts

AccordionTrigger

value
DeclarationView source
AccordionTriggerts
export declare const AccordionTrigger: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

AssistantChainOfThought

value
DeclarationView source
AssistantChainOfThoughtts
export declare const AssistantChainOfThought: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

Parts

value
DeclarationView source
Partsts
export declare const Parts: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

Root

value
DeclarationView source
Rootts
export declare const Root: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

Trigger

value
DeclarationView source
Triggerts
export declare const Trigger: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

@grassroot/ui-headless-solid/assistant-chain-of-thought

Solid adapter

5 exports
View source packages/ui-headless/solid/src/assistant-chain-of-thought/index.ts

AccordionTrigger

function
DeclarationView source
AccordionTriggerts
export declare function AssistantChainOfThoughtAccordionTrigger(props: JSX.ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.ButtonHTMLAttributes<HTMLButtonElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.ButtonHTMLAttributes<HTMLButtonElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

AssistantChainOfThought

value
DeclarationView source
AssistantChainOfThoughtts
export declare const AssistantChainOfThought: {
    Root: typeof AssistantChainOfThoughtRoot;
    AccordionTrigger: typeof AssistantChainOfThoughtAccordionTrigger;
    Trigger: typeof AssistantChainOfThoughtAccordionTrigger;
    Parts: typeof AssistantChainOfThoughtParts;
};
Name
Kind
Type
Requirement
AccordionTrigger
property
typeof AssistantChainOfThoughtAccordionTrigger
required
Parts
property
typeof AssistantChainOfThoughtParts
required
Root
property
typeof AssistantChainOfThoughtRoot
required
Trigger
property
typeof AssistantChainOfThoughtAccordionTrigger
required
Name
AccordionTrigger
Kind
property
Type
typeof AssistantChainOfThoughtAccordionTrigger
Requirement
required
Name
Parts
Kind
property
Type
typeof AssistantChainOfThoughtParts
Requirement
required
Name
Root
Kind
property
Type
typeof AssistantChainOfThoughtRoot
Requirement
required
Name
Trigger
Kind
property
Type
typeof AssistantChainOfThoughtAccordionTrigger
Requirement
required

Parts

function
DeclarationView source
Partsts
export declare function AssistantChainOfThoughtParts(props: JSX.HTMLAttributes<HTMLDivElement>): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLDivElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLDivElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Root

function
DeclarationView source
Rootts
export declare function AssistantChainOfThoughtRoot(props: JSX.HTMLAttributes<HTMLDivElement> & {
    readonly open?: boolean;
    readonly defaultOpen?: boolean;
    readonly disabled?: boolean;
    readonly onOpenChange?: (detail: {
        open: boolean;
        reason: string;
    }) => void;
}): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLDivElement> & { readonly open?: boolean; readonly defaultOpen?: boolean; readonly disabled?: boolean; readonly onOpenChange?: (detail: { open: boolean; reason: string; }) => void; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLDivElement> & { readonly open?: boolean; readonly defaultOpen?: boolean; readonly disabled?: boolean; readonly onOpenChange?: (detail: { open: boolean; reason: string; }) => void; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Trigger

value
DeclarationView source
Triggerts
export declare const Trigger: typeof AssistantChainOfThoughtAccordionTrigger;
Name
Kind
Type
Requirement
props
parameter
JSX.ButtonHTMLAttributes<HTMLButtonElement>
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.ButtonHTMLAttributes<HTMLButtonElement>
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a