@copilotkitnext/angular 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

package/dist/lib/components/chat/copilot-chat-view.types.d.ts

@@ -0,0 +1,42 @@
+import { Type, TemplateRef } from "@angular/core";
+import { Message } from "@ag-ui/client";
+/**
+ * Props for CopilotChatView component
+ */
+export interface CopilotChatViewProps {
+    messages?: Message[];
+    autoScroll?: boolean;
+    messageViewComponent?: Type<any>;
+    messageViewTemplate?: TemplateRef<any>;
+    messageViewClass?: string;
+    scrollViewComponent?: Type<any>;
+    scrollViewTemplate?: TemplateRef<any>;
+    scrollViewClass?: string;
+    scrollToBottomButtonComponent?: Type<any>;
+    scrollToBottomButtonTemplate?: TemplateRef<any>;
+    scrollToBottomButtonClass?: string;
+    inputComponent?: Type<any>;
+    inputTemplate?: TemplateRef<any>;
+    inputContainerComponent?: Type<any>;
+    inputContainerTemplate?: TemplateRef<any>;
+    inputContainerClass?: string;
+    featherComponent?: Type<any>;
+    featherTemplate?: TemplateRef<any>;
+    featherClass?: string;
+    disclaimerComponent?: Type<any>;
+    disclaimerTemplate?: TemplateRef<any>;
+    disclaimerClass?: string;
+    disclaimerText?: string;
+}
+/**
+ * Context for custom layout template
+ */
+export interface CopilotChatViewLayoutContext {
+    messageView: any;
+    input: any;
+    scrollView: any;
+    scrollToBottomButton: any;
+    feather: any;
+    inputContainer: any;
+    disclaimer: any;
+}

package/dist/lib/components/chat/copilot-chat.d.ts

@@ -0,0 +1,82 @@
+import { ChangeDetectorRef, Injector, Type } from "@angular/core";
+import { ChatState } from "../../chat-state";
+import * as i0 from "@angular/core";
+/**
+ * CopilotChat component - Angular equivalent of React's <CopilotChat>
+ * Provides a complete chat interface that wires an agent to the chat view
+ *
+ * @example
+ * ```html
+ * <copilot-chat [agentId]="'default'" [threadId]="'abc123'"></copilot-chat>
+ * ```
+ */
+export declare class CopilotChat implements ChatState {
+    readonly inputValue: import("@angular/core").WritableSignal<string>;
+    readonly agentId: import("@angular/core").InputSignal<string>;
+    readonly threadId: import("@angular/core").InputSignal<string>;
+    readonly inputComponent: import("@angular/core").InputSignal<Type<any>>;
+    private readonly resolvedAgentId;
+    readonly agentStore: import("@angular/core").Signal<import("../../agent").AgentStore>;
+    readonly cdr: ChangeDetectorRef;
+    readonly injector: Injector;
+    protected messages: import("@angular/core").Signal<({
+        id: string;
+        role: "developer";
+        content: string;
+        name?: string;
+    } | {
+        id: string;
+        role: "system";
+        content: string;
+        name?: string;
+    } | {
+        id: string;
+        role: "assistant";
+        name?: string;
+        content?: string;
+        toolCalls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[];
+    } | {
+        id: string;
+        role: "user";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "binary";
+            mimeType: string;
+            id?: string;
+            url?: string;
+            data?: string;
+            filename?: string;
+        })[];
+        name?: string;
+    } | {
+        id: string;
+        role: "tool";
+        content: string;
+        toolCallId: string;
+        error?: string;
+    } | {
+        id: string;
+        role: "activity";
+        content: Record<string, any>;
+        activityType: string;
+    })[]>;
+    protected isRunning: import("@angular/core").Signal<boolean>;
+    protected showCursor: import("@angular/core").WritableSignal<boolean>;
+    private generatedThreadId;
+    private hasConnectedOnce;
+    constructor();
+    private connectToAgent;
+    submitInput(value: string): Promise<void>;
+    changeInput(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotChat, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CopilotChat, "copilot-chat", never, { "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "threadId": { "alias": "threadId"; "required": false; "isSignal": true; }; "inputComponent": { "alias": "inputComponent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken, Provider } from "@angular/core";
+import { AbstractAgent } from "@ag-ui/client";
+import { ClientTool, FrontendToolConfig, HumanInTheLoopConfig, RenderToolCallConfig } from "./tools";
+export interface CopilotKitConfig {
+    runtimeUrl?: string;
+    headers?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    agents?: Record<string, AbstractAgent>;
+    tools?: ClientTool[];
+    renderToolCalls?: RenderToolCallConfig[];
+    frontendTools?: FrontendToolConfig[];
+    humanInTheLoop?: HumanInTheLoopConfig[];
+}
+export declare const COPILOT_KIT_CONFIG: InjectionToken<CopilotKitConfig>;
+export declare function injectCopilotKitConfig(): CopilotKitConfig;
+export declare function provideCopilotKit(config: CopilotKitConfig): Provider;

package/dist/lib/copilotkit.d.ts

@@ -0,0 +1,29 @@
+import { AbstractAgent } from "@ag-ui/client";
+import { CopilotKitCore } from "@copilotkitnext/core";
+import { Injector, Signal } from "@angular/core";
+import { FrontendToolConfig, HumanInTheLoopConfig, RenderToolCallConfig } from "./tools";
+import * as i0 from "@angular/core";
+export declare class CopilotKit {
+    #private;
+    readonly agents: Signal<Record<string, AbstractAgent>>;
+    readonly core: CopilotKitCore;
+    readonly toolCallRenderConfigs: Signal<RenderToolCallConfig[]>;
+    readonly clientToolCallRenderConfigs: Signal<FrontendToolConfig[]>;
+    readonly humanInTheLoopToolRenderConfigs: Signal<HumanInTheLoopConfig[]>;
+    constructor();
+    addFrontendTool(clientToolWithInjector: FrontendToolConfig & {
+        injector: Injector;
+    }): void;
+    addRenderToolCall(renderConfig: RenderToolCallConfig): void;
+    addHumanInTheLoop(humanInTheLoopTool: HumanInTheLoopConfig): void;
+    removeTool(toolName: string, agentId?: string): void;
+    getAgent(agentId: string): AbstractAgent | undefined;
+    updateRuntime(options: {
+        runtimeUrl?: string;
+        headers?: Record<string, string>;
+        properties?: Record<string, unknown>;
+        agents?: Record<string, AbstractAgent>;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKit, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CopilotKit>;
+}

package/dist/lib/directives/copilotkit-agent-context.d.ts

@@ -0,0 +1,68 @@
+import { OnInit, OnChanges, OnDestroy, SimpleChanges } from "@angular/core";
+import { CopilotKit } from "../copilotkit";
+import type { Context } from "@ag-ui/client";
+import * as i0 from "@angular/core";
+/**
+ * Directive to manage agent context in CopilotKit.
+ * Automatically adds context on init, updates on changes, and removes on destroy.
+ *
+ * @example
+ * ```html
+ * <!-- With separate inputs -->
+ * <div copilotkitAgentContext
+ *      [description]="'User preferences'"
+ *      [value]="userSettings">
+ * </div>
+ *
+ * <!-- With context object -->
+ * <div [copilotkitAgentContext]="contextObject">
+ * </div>
+ *
+ * <!-- With dynamic values -->
+ * <div copilotkitAgentContext
+ *      description="Form state"
+ *      [value]="formData$ | async">
+ * </div>
+ * ```
+ */
+export declare class CopilotKitAgentContext implements OnInit, OnChanges, OnDestroy {
+    private readonly copilotkit;
+    private contextId?;
+    constructor(copilotkit: CopilotKit);
+    /**
+     * Context object containing both description and value.
+     * If provided, this takes precedence over individual inputs.
+     */
+    context?: Context;
+    /**
+     * Description of the context.
+     * Used when context object is not provided.
+     */
+    description?: string;
+    /**
+     * Value of the context.
+     * Used when context object is not provided.
+     */
+    value?: any;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Adds the context to CopilotKit
+     */
+    private addContext;
+    /**
+     * Updates the context by removing the old one and adding a new one
+     */
+    private updateContext;
+    /**
+     * Removes the current context from CopilotKit
+     */
+    private removeContext;
+    /**
+     * Gets the context object from inputs
+     */
+    private getContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotKitAgentContext, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotKitAgentContext, "[copilotkitAgentContext]", never, { "context": { "alias": "copilotkitAgentContext"; "required": false; }; "description": { "alias": "description"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/lib/directives/stick-to-bottom.d.ts

@@ -0,0 +1,62 @@
+import { OnInit, OnDestroy, AfterViewInit } from "@angular/core";
+import * as i0 from "@angular/core";
+export type ScrollBehavior = "smooth" | "instant" | "auto";
+/**
+ * Directive for implementing stick-to-bottom scroll behavior
+ * Similar to the React use-stick-to-bottom library
+ *
+ * @example
+ * ```html
+ * <div copilotStickToBottom
+ *      [enabled]="true"
+ *      [threshold]="10"
+ *      [initialBehavior]="'smooth'"
+ *      [resizeBehavior]="'smooth'"
+ *      (isAtBottomChange)="onBottomChange($event)">
+ *   <!-- Content -->
+ * </div>
+ * ```
+ */
+export declare class StickToBottom implements OnInit, AfterViewInit, OnDestroy {
+    enabled: import("@angular/core").InputSignal<boolean>;
+    threshold: import("@angular/core").InputSignal<number>;
+    initialBehavior: import("@angular/core").InputSignal<ScrollBehavior>;
+    resizeBehavior: import("@angular/core").InputSignal<ScrollBehavior>;
+    debounceMs: import("@angular/core").InputSignal<number>;
+    isAtBottomChange: import("@angular/core").OutputEmitterRef<boolean>;
+    scrollToBottomRequested: import("@angular/core").OutputEmitterRef<void>;
+    private elementRef;
+    private scrollService;
+    private resizeService;
+    private destroy$;
+    private contentElement?;
+    private wasAtBottom;
+    private hasInitialized;
+    private userHasScrolled;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private setupScrollMonitoring;
+    private setupResizeMonitoring;
+    private setupContentMutationObserver;
+    /**
+     * Public method to scroll to bottom
+     * Can be called from parent component
+     */
+    scrollToBottom(behavior?: ScrollBehavior): void;
+    /**
+     * Check if currently at bottom
+     */
+    isAtBottom(): boolean;
+    /**
+     * Get current scroll state
+     */
+    getScrollState(): {
+        scrollTop: any;
+        scrollHeight: any;
+        clientHeight: any;
+        isAtBottom: boolean;
+    };
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickToBottom, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StickToBottom, "[copilotStickToBottom]", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "initialBehavior": { "alias": "initialBehavior"; "required": false; "isSignal": true; }; "resizeBehavior": { "alias": "resizeBehavior"; "required": false; "isSignal": true; }; "debounceMs": { "alias": "debounceMs"; "required": false; "isSignal": true; }; }, { "isAtBottomChange": "isAtBottomChange"; "scrollToBottomRequested": "scrollToBottomRequested"; }, never, never, true, never>;
+}

package/dist/lib/directives/tooltip.d.ts

@@ -0,0 +1,33 @@
+import { OnDestroy } from "@angular/core";
+import { ChangeDetectorRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class TooltipContent {
+    private cdr;
+    text: string;
+    private _position;
+    get position(): "above" | "below" | "left" | "right";
+    set position(value: "above" | "below" | "left" | "right");
+    constructor(cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipContent, "copilot-tooltip-content", never, {}, {}, never, never, true, never>;
+}
+export declare class CopilotTooltip implements OnDestroy {
+    tooltipText: string;
+    tooltipPosition: "above" | "below" | "left" | "right";
+    tooltipDelay: number;
+    private overlay;
+    private overlayPositionBuilder;
+    private elementRef;
+    private viewContainerRef;
+    private overlayRef?;
+    private tooltipTimeout?;
+    private originalTitle?;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    private show;
+    private hide;
+    private getPositions;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopilotTooltip, "[copilotTooltip]", never, { "tooltipText": { "alias": "copilotTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; }; }, {}, never, never, true, never>;
+}

package/dist/lib/human-in-the-loop.d.ts

@@ -0,0 +1,13 @@
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class HumanInTheLoop {
+    results: Subject<{
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    }>;
+    addResult(toolCallId: string, toolName: string, result: unknown): void;
+    onResult(toolCallId: string, toolName: string): Promise<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HumanInTheLoop, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HumanInTheLoop>;
+}

package/dist/lib/render-tool-calls.d.ts

@@ -0,0 +1,90 @@
+import { ToolCall } from "@ag-ui/client";
+import { FrontendToolConfig, HumanInTheLoopToolCall, HumanInTheLoopConfig, AngularToolCall, RenderToolCallConfig } from "./tools";
+import * as i0 from "@angular/core";
+type RendererToolCallHandler = {
+    type: "renderer";
+    config: RenderToolCallConfig;
+};
+type ClientToolCallHandler = {
+    type: "clientTool";
+    config: FrontendToolConfig;
+};
+type HumanInTheLoopToolCallHandler = {
+    type: "humanInTheLoopTool";
+    config: HumanInTheLoopConfig;
+};
+type ToolCallHandler = RendererToolCallHandler | ClientToolCallHandler | HumanInTheLoopToolCallHandler;
+export declare class RenderToolCalls {
+    #private;
+    readonly message: import("@angular/core").InputSignal<{
+        id: string;
+        role: "assistant";
+        name?: string;
+        content?: string;
+        toolCalls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[];
+    }>;
+    readonly messages: import("@angular/core").InputSignal<({
+        id: string;
+        role: "developer";
+        content: string;
+        name?: string;
+    } | {
+        id: string;
+        role: "system";
+        content: string;
+        name?: string;
+    } | {
+        id: string;
+        role: "assistant";
+        name?: string;
+        content?: string;
+        toolCalls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[];
+    } | {
+        id: string;
+        role: "user";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "binary";
+            mimeType: string;
+            id?: string;
+            url?: string;
+            data?: string;
+            filename?: string;
+        })[];
+        name?: string;
+    } | {
+        id: string;
+        role: "tool";
+        content: string;
+        toolCallId: string;
+        error?: string;
+    } | {
+        id: string;
+        role: "activity";
+        content: Record<string, any>;
+        activityType: string;
+    })[]>;
+    readonly isLoading: import("@angular/core").InputSignal<boolean>;
+    protected pickRenderer(name: string): ToolCallHandler | undefined;
+    protected buildToolCall<Args extends Record<string, unknown>>(toolCall: ToolCall): AngularToolCall<Args>;
+    protected buildHumanInTheLoopToolCall<Args extends Record<string, unknown>>(toolCall: ToolCall): HumanInTheLoopToolCall<Args>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderToolCalls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RenderToolCalls, "copilot-render-tool-calls", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/dist/lib/resize-observer.d.ts

@@ -0,0 +1,44 @@
+import { ElementRef, NgZone, OnDestroy } from "@angular/core";
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export interface ResizeState {
+    width: number;
+    height: number;
+    isResizing: boolean;
+}
+export declare class ResizeObserverService implements OnDestroy {
+    private ngZone;
+    private destroy$;
+    private observers;
+    private resizeStates;
+    private resizeTimeouts;
+    constructor(ngZone: NgZone);
+    /**
+     * Observe element resize with debouncing and resizing state
+     * @param element Element to observe
+     * @param debounceMs Debounce time (default 250ms)
+     * @param resizingDurationMs How long to show "isResizing" state (default 250ms)
+     */
+    observeElement(element: ElementRef<HTMLElement> | HTMLElement, debounceMs?: number, resizingDurationMs?: number): Observable<ResizeState>;
+    /**
+     * Stop observing an element
+     * @param element Element to stop observing
+     */
+    unobserve(element: ElementRef<HTMLElement> | HTMLElement): void;
+    /**
+     * Get current size of element
+     * @param element Element to measure
+     */
+    getCurrentSize(element: ElementRef<HTMLElement> | HTMLElement): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get current resize state of element
+     * @param element Element to check
+     */
+    getCurrentState(element: ElementRef<HTMLElement> | HTMLElement): ResizeState | null;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
+}

package/dist/lib/scroll-position.d.ts

@@ -0,0 +1,50 @@
+import { ElementRef, NgZone, OnDestroy } from "@angular/core";
+import { ScrollDispatcher, ViewportRuler } from "@angular/cdk/scrolling";
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export interface ScrollState {
+    isAtBottom: boolean;
+    scrollTop: number;
+    scrollHeight: number;
+    clientHeight: number;
+}
+export declare class ScrollPosition implements OnDestroy {
+    private scrollDispatcher;
+    private viewportRuler;
+    private ngZone;
+    private destroy$;
+    private scrollStateSubject;
+    scrollState$: Observable<ScrollState>;
+    constructor(scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler, ngZone: NgZone);
+    /**
+     * Monitor scroll position of an element
+     * @param element The element to monitor
+     * @param threshold Pixels from bottom to consider "at bottom" (default 10)
+     */
+    monitorScrollPosition(element: ElementRef<HTMLElement> | HTMLElement, threshold?: number): Observable<ScrollState>;
+    /**
+     * Scroll element to bottom with smooth animation
+     * @param element The element to scroll
+     * @param smooth Whether to use smooth scrolling
+     */
+    scrollToBottom(element: ElementRef<HTMLElement> | HTMLElement, smooth?: boolean): void;
+    /**
+     * Check if element is at bottom
+     * @param element The element to check
+     * @param threshold Pixels from bottom to consider "at bottom"
+     */
+    isAtBottom(element: ElementRef<HTMLElement> | HTMLElement, threshold?: number): boolean;
+    /**
+     * Get current scroll state of element
+     */
+    getScrollState(element: HTMLElement, threshold: number): ScrollState;
+    /**
+     * Create a ResizeObserver for element size changes
+     * @param element The element to observe
+     * @param debounceMs Debounce time in milliseconds
+     */
+    observeResize(element: ElementRef<HTMLElement> | HTMLElement, debounceMs?: number): Observable<ResizeObserverEntry>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollPosition, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollPosition>;
+}

package/dist/lib/slots/copilot-slot.d.ts

@@ -0,0 +1,34 @@
+import { TemplateRef, ViewContainerRef, OnInit, OnChanges, SimpleChanges, ChangeDetectorRef } from "@angular/core";
+import { Type } from "@angular/core";
+import * as i0 from "@angular/core";
+/**
+ * @internal - This component is for internal use only.
+ * Simple slot component for rendering custom content or defaults.
+ * Supports templates and components only.
+ *
+ * @example
+ * ```html
+ * <!-- With template -->
+ * <copilot-slot [slot]="sendButtonTemplate" [context]="buttonContext">
+ *   <button class="default-btn">Default</button>
+ * </copilot-slot>
+ * ```
+ */
+export declare class CopilotSlot implements OnInit, OnChanges {
+    private viewContainer;
+    private cdr;
+    slot: import("@angular/core").InputSignal<Type<any> | TemplateRef<any>>;
+    context: import("@angular/core").InputSignal<any>;
+    defaultComponent: import("@angular/core").InputSignal<Type<any>>;
+    outputs: import("@angular/core").InputSignal<Record<string, (event: any) => void>>;
+    private slotContainer;
+    private componentRef?;
+    constructor(viewContainer: ViewContainerRef, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    isTemplate(value: any): value is TemplateRef<any>;
+    private renderSlot;
+    private updateComponentProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopilotSlot, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CopilotSlot, "copilot-slot", never, { "slot": { "alias": "slot"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "defaultComponent": { "alias": "defaultComponent"; "required": false; "isSignal": true; }; "outputs": { "alias": "outputs"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/dist/lib/slots/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./slot.types";
+export * from "./slot.utils";
+export { CopilotSlot } from "./copilot-slot";

package/dist/lib/slots/slot.types.d.ts

@@ -0,0 +1,55 @@
+import { Type, TemplateRef, InjectionToken } from "@angular/core";
+/**
+ * Represents a value that can be used as a slot override.
+ * Can be a component type or template reference only.
+ * @internal - This type is for internal use only
+ */
+export type SlotValue<T = any> = Type<T> | TemplateRef<T>;
+/**
+ * Configuration for a slot
+ * @internal - This interface is for internal use only
+ */
+export interface SlotConfig<T = any> {
+    value?: SlotValue<T>;
+    default?: Type<T>;
+}
+/**
+ * Context passed to slot templates
+ */
+export interface SlotContext<T = any> {
+    $implicit: T;
+    props?: Partial<T>;
+    [key: string]: any;
+}
+/**
+ * Slot registry entry
+ * @internal - This interface is for internal use only
+ */
+export interface SlotRegistryEntry<T = any> {
+    component?: Type<T>;
+    template?: TemplateRef<T>;
+}
+/**
+ * Options for rendering a slot
+ */
+export interface RenderSlotOptions<T = any> {
+    slot?: SlotValue<T>;
+    defaultComponent: Type<T>;
+    props?: Partial<T>;
+    injector?: any;
+    outputs?: Record<string, (event: any) => void>;
+}
+/**
+ * Injection token for slot configuration
+ */
+export declare const SLOT_CONFIG: InjectionToken<ReadonlyMap<string, SlotRegistryEntry<any>>>;
+/**
+ * Type for components with slots
+ */
+export type WithSlots<S extends Record<string, Type<any>>, Rest = object> = {
+    [K in keyof S as `${string & K}Component`]?: Type<any>;
+} & {
+    [K in keyof S as `${string & K}Template`]?: TemplateRef<any>;
+} & {
+    [K in keyof S as `${string & K}Class`]?: string;
+} & Rest;