@k8slens/ai-tools-contracts 1.0.0

package/dist/src/os-and-shell-specific.d.ts

@@ -0,0 +1,133 @@
+import type { Factory, InjectionToken2 } from "@k8slens/injectable";
+import { type PerShellFamily, type ShellScoped } from "@k8slens/platform-specific-injectables";
+import type { OperatingSystemSpecific } from "./operating-system-specific";
+/**
+ * A value provided separately per shell family. The shell analogue of
+ * {@link OperatingSystemSpecific}.
+ */
+export type ShellSpecific<T> = PerShellFamily<T>;
+/**
+ * A value that is either shell-agnostic (the value itself) or shell specific (a
+ * {@link ShellSpecific} object). The shell analogue of `MaybeOperatingSystemSpecific`.
+ */
+export type MaybeShellSpecific<T> = T | ShellSpecific<T>;
+/** A value provided per operating system, and within each, per shell family. */
+export type OperatingSystemAndShellSpecific<T> = OperatingSystemSpecific<ShellSpecific<T>>;
+/**
+ * A value that may vary along either axis: agnostic, operating-system specific,
+ * shell specific, or both. Used for the AI-tool CLI commands so a tool may differ
+ * its command *content* per OS and/or shell (e.g. launch-by-name vs path, or
+ * per-OS discovery logic).
+ */
+export type MaybeOperatingSystemAndShellSpecific<T> = T | OperatingSystemSpecific<T> | ShellSpecific<T> | OperatingSystemAndShellSpecific<T>;
+/**
+ * Registers a {@link MaybeOperatingSystemAndShellSpecific} value under a single
+ * token so consumers resolve it at runtime with
+ * `resolveForShell(injectMany(token)(), shellFamily)`. The **OS** axis is filtered
+ * synchronously at registration (host-only `*-only` tags, via
+ * `getInjectableForOperatingSystemsAndShells`); the **shell** axis is selected at
+ * runtime, since the configured shell is async. Agnostic and OS-only values are
+ * repeated across the shell families so every token uniformly yields
+ * `ShellScoped<F>`. The shell analogue/superset of `getInjectableForOperatingSystems`.
+ */
+export declare const getOsAndShellAwareInjectable: <F extends Factory>(args: {
+    id: string;
+    injectionToken: InjectionToken2<{
+        singleFactory: () => ShellScoped<F>;
+        manyFactory: any;
+        specificTokenFactory: undefined;
+        cardinality: any;
+    }>;
+    value: MaybeOperatingSystemAndShellSpecific<F>;
+}) => {
+    posix: import("@k8slens/injectable").Injectable2<() => {
+        shellFamily: import("@k8slens/public-utilities").ShellFamily;
+        value: F;
+    }>;
+    fish: import("@k8slens/injectable").Injectable2<() => {
+        shellFamily: import("@k8slens/public-utilities").ShellFamily;
+        value: F;
+    }>;
+    cmd: import("@k8slens/injectable").Injectable2<() => {
+        shellFamily: import("@k8slens/public-utilities").ShellFamily;
+        value: F;
+    }>;
+    powershell: import("@k8slens/injectable").Injectable2<() => {
+        shellFamily: import("@k8slens/public-utilities").ShellFamily;
+        value: F;
+    }>;
+} | {
+    macos: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+    };
+    windows: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+    };
+    linux: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+    };
+    unitTesting: {
+        posix: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        fish: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        cmd: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+        powershell: import("@k8slens/injectable").Injectable2<() => {
+            shellFamily: import("@k8slens/public-utilities").ShellFamily;
+            value: F;
+        }>;
+    };
+};
+//# sourceMappingURL=os-and-shell-specific.d.ts.map

package/dist/src/os-and-shell-specific.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os-and-shell-specific.d.ts","sourceRoot":"","sources":["../../src/os-and-shell-specific.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,WAAW,EACjB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAE3E;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;AAEzD,gFAAgF;AAChF,MAAM,MAAM,+BAA+B,CAAC,CAAC,IAAI,uBAAuB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3F;;;;;GAKG;AACH,MAAM,MAAM,oCAAoC,CAAC,CAAC,IAC9C,CAAC,GACD,uBAAuB,CAAC,CAAC,CAAC,GAC1B,aAAa,CAAC,CAAC,CAAC,GAChB,+BAA+B,CAAC,CAAC,CAAC,CAAC;AAsBvC;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,OAAO,QAAQ;IACpE,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,eAAe,CAAC;QAC9B,aAAa,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC;QACpC,WAAW,EAAE,GAAG,CAAC;QACjB,oBAAoB,EAAE,SAAS,CAAC;QAChC,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC,CAAC;IACH,KAAK,EAAE,oCAAoC,CAAC,CAAC,CAAC,CAAC;CAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBA,CAAC"}

package/dist/src/resolve-llm-command.d.ts

@@ -0,0 +1,16 @@
+export interface ResolveLlmCommandOptions {
+    /** Seeded initial user message, substituted into `{prompt}`. */
+    prompt?: string;
+    /** Working directory the command runs in, substituted (shell-escaped) into `{dir}`. */
+    dir?: string;
+}
+/**
+ * Resolve a free-text LLM command template by substituting the `{prompt}` and
+ * `{dir}` placeholders with shell-escaped values. Unfilled placeholders (and one
+ * leading whitespace run) are stripped. A value with no matching placeholder is
+ * simply omitted — in particular, a seeded prompt is NOT appended to a template
+ * that omits `{prompt}` (a command such as `open -a iTerm {dir}` must not receive
+ * the prompt as a stray argument).
+ */
+export declare const resolveLlmCommand: (template: string, { prompt, dir }?: ResolveLlmCommandOptions) => string;
+//# sourceMappingURL=resolve-llm-command.d.ts.map

package/dist/src/resolve-llm-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-llm-command.d.ts","sourceRoot":"","sources":["../../src/resolve-llm-command.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,wBAAwB;IACvC,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,aAAc,MAAM,oBAAmB,wBAAwB,KAAQ,MAMpG,CAAC"}

package/dist/src/selected-ai-tool-injection-tokens.d.ts

@@ -0,0 +1,363 @@
+import type { IComputedValue, IObservableValue } from "mobx";
+import type React from "react";
+import type { SvgProps } from "@k8slens/element-components";
+import type { AiToolKind, GetCliCommand, GetOpenToolInExternalTerminalCliCommand } from "./ai-tool";
+/** Resolves the persisted raw selection: a tool kind, `customAiToolKind`, `noAiToolKind`, or `undefined` (unset). */
+export type SelectedAiToolKind = () => Promise<IObservableValue<AiToolKind | undefined>>;
+/**
+ * The user's persisted AI tool selection. Holds a contributed tool kind, the
+ * `customAiToolKind` sentinel, the `noAiToolKind` opt-out, or `undefined` when never
+ * set. Read/write — the preferences selector binds to it.
+ */
+export declare const selectedAiToolKindInjectionToken: import("@k8slens/injectable").InjectionToken2Base<SelectedAiToolKind, () => Promise<IObservableValue<string | undefined>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IObservableValue<string | undefined>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IObservableValue<string | undefined>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective selection: the raw selection if installed, else `noAiToolKind`. */
+export type EffectiveAiToolKind = () => Promise<IComputedValue<AiToolKind>>;
+/**
+ * The effective AI tool kind: the raw selection when it is an installed kind (a
+ * real tool or `customAiToolKind`), otherwise `noAiToolKind`. So an unset
+ * selection, an explicit "No AI tool", and a selected-but-uninstalled tool all
+ * resolve to `noAiToolKind` — the default and the fallback.
+ */
+export declare const effectiveAiToolKindInjectionToken: import("@k8slens/injectable").InjectionToken2Base<EffectiveAiToolKind, () => Promise<IComputedValue<string>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<string>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<string>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective command builder, or `undefined` when Custom or "No AI tool" is effective. */
+export type SelectedAiToolCommand = () => Promise<IComputedValue<GetCliCommand | undefined>>;
+/**
+ * The command builder for the effective selection, or `undefined` when the
+ * effective selection is `customAiToolKind` (the consumer then uses its own
+ * free-text command) or `noAiToolKind` (nothing to launch). Consumed when
+ * launching an AI tool.
+ */
+export declare const selectedAiToolCommandInjectionToken: import("@k8slens/injectable").InjectionToken2Base<SelectedAiToolCommand, () => Promise<IComputedValue<GetCliCommand | undefined>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<GetCliCommand | undefined>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<GetCliCommand | undefined>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective tool's resume command builder, or `undefined` when it has no resume invocation. */
+export type SelectedAiToolResumeCommand = () => Promise<IComputedValue<GetCliCommand | undefined>>;
+/**
+ * The command builder that *resumes* the effective selection (e.g. building
+ * `claude --continue || claude`), or `undefined` when the effective tool declares no
+ * resume invocation. Consumed when re-establishing an AI tool's session — a
+ * terminal tab runs this instead of the launch command after a restart.
+ */
+export declare const selectedAiToolResumeCommandInjectionToken: import("@k8slens/injectable").InjectionToken2Base<SelectedAiToolResumeCommand, () => Promise<IComputedValue<GetCliCommand | undefined>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<GetCliCommand | undefined>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<GetCliCommand | undefined>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective tool's "open in external terminal" command builder for the host OS. */
+export type SelectedAiToolOpenInExternalTerminalCommand = () => Promise<IComputedValue<GetOpenToolInExternalTerminalCliCommand | undefined>>;
+/**
+ * The command builder that opens the effective selected tool in a fresh external
+ * terminal window, for the host operating system. Consumed when the global "open
+ * AI tools in an external terminal" toggle is on — the consumer calls it with
+ * `{ prompt, dir, env }` and spawns the result detached. Resolves the tool's
+ * host-OS variant (macOS Terminal, Windows Terminal, or a Linux fallback chain) via
+ * the per-kind `getOpenToolInExternalTerminalForTool` token.
+ */
+export declare const selectedAiToolOpenInExternalTerminalCommandInjectionToken: import("@k8slens/injectable").InjectionToken2Base<SelectedAiToolOpenInExternalTerminalCommand, () => Promise<IComputedValue<GetOpenToolInExternalTerminalCliCommand | undefined>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<GetOpenToolInExternalTerminalCliCommand | undefined>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<GetOpenToolInExternalTerminalCliCommand | undefined>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective tool's display-name React component. */
+export type EffectiveAiToolName = () => Promise<IComputedValue<React.ComponentType>>;
+/**
+ * The effective selected tool's display-name component (e.g. renders "Claude
+ * Code"). Drives the React surfaces that name the AI tool — "Ask <name>"
+ * buttons and the top-bar label.
+ */
+export declare const effectiveAiToolNameInjectionToken: import("@k8slens/injectable").InjectionToken2Base<EffectiveAiToolName, () => Promise<IComputedValue<React.ComponentType<{}>>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<React.ComponentType<{}>>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<React.ComponentType<{}>>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective tool's plain-text display name. */
+export type EffectiveAiToolDisplayName = () => Promise<IComputedValue<string>>;
+/**
+ * The effective selected tool's plain-text name, for string-only slots that
+ * cannot render the React name component (e.g. the command-palette entry title).
+ */
+export declare const effectiveAiToolDisplayNameInjectionToken: import("@k8slens/injectable").InjectionToken2Base<EffectiveAiToolDisplayName, () => Promise<IComputedValue<string>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<string>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<string>>>[]> & {
+    readonly __abstract?: never;
+};
+/** Resolves the effective tool's icon component. */
+export type EffectiveAiToolIcon = () => Promise<IComputedValue<React.ComponentType<SvgProps>>>;
+/**
+ * The effective selected tool's icon component, shown wherever the tool is offered
+ * (the "Ask <name>" buttons and the top-bar button) in place of a fixed brand
+ * icon.
+ */
+export declare const effectiveAiToolIconInjectionToken: import("@k8slens/injectable").InjectionToken2Base<EffectiveAiToolIcon, () => Promise<IComputedValue<React.ComponentType<{
+    $className?: import("@k8slens/public-utilities").IClassName;
+    className?: string;
+    $block?: boolean | "inline";
+    $cursor?: import("@k8slens/element-components").$CursorProps;
+    readonly $color?: import("@k8slens/element-components").TextColor | import("@k8slens/element-components").$ColorProps;
+    $backgroundColor?: import("@k8slens/element-components").BackgroundColor | import("@k8slens/element-components").$BackgroundColorProps;
+    $border?: import("@k8slens/element-components").$BorderProps;
+    $padding?: boolean | import("@k8slens/element-components").DirectionalPadding | import("@k8slens/element-components").TShirtSize;
+    $margin?: boolean | import("@k8slens/element-components").DirectionalMargin | import("@k8slens/element-components").TShirtSize | "auto";
+    $overflow?: import("@k8slens/element-components").Overflow | {
+        x?: import("@k8slens/element-components").Overflow;
+        y?: import("@k8slens/element-components").Overflow;
+        hideScrollbar?: boolean;
+    };
+    readonly $anchor?: boolean;
+    readonly $anchoredAt?: import("@k8slens/element-components").AnchoredAt;
+    readonly children?: React.ReactNode;
+    readonly $onOutsideClick?: (event: PointerEvent) => void;
+    $textAlign?: "left" | "center" | "right";
+    $ref?: import("@k8slens/element-components").$RefProp<HTMLElement>;
+    ref?: import("@k8slens/element-components").RefLike<HTMLElement>;
+    $focusable?: {
+        context: import("@k8slens/element-components").AnyFocusableContext<any>;
+        item: any;
+        orderNumber?: number;
+    } | undefined;
+    onFocus?: React.FocusEventHandler<HTMLElement> | undefined;
+    onBlur?: React.FocusEventHandler<HTMLElement> | undefined;
+    onKeyDown?: React.KeyboardEventHandler<HTMLElement> | undefined;
+    tabIndex?: HTMLElement["tabIndex"];
+    $grayscale?: boolean;
+    $style?: React.CSSProperties;
+    style?: React.CSSProperties;
+    $tint?: string;
+    $faded?: boolean;
+    $outline?: {
+        focusVisible?: import("@k8slens/element-components").$OutlineProps;
+    };
+    readonly $floating?: import("@k8slens/element-components").$FloatingProps;
+    $boxShadow?: boolean | "elevated" | "subtle";
+    readonly $hoverable?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableProps>;
+    onMouseEnter?: React.MouseEventHandler<HTMLElement> | undefined;
+    onMouseLeave?: React.MouseEventHandler<HTMLElement> | undefined;
+    $hoverableByDragging?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableByDraggingProps<any>> | undefined;
+    $absolute?: import("@k8slens/element-components").AbsolutePosition | boolean;
+    $hidden?: boolean;
+    $noPointerEvents?: boolean;
+    $offset?: {
+        direction: import("@k8slens/element-components").Direction;
+        size: import("@k8slens/element-components").TShirtSize;
+    };
+    $offsetChildren?: {
+        direction: import("@k8slens/element-components").Direction;
+        size: import("@k8slens/element-components").TShirtSize;
+    };
+    $relative?: boolean;
+    $fixed?: boolean;
+    $transition?: boolean;
+    $visuallyHidden?: boolean;
+    $displayContents?: boolean;
+    $draggable?: {
+        context: import("@k8slens/element-components").DraggableContext<any>;
+        item: any;
+    } | undefined;
+    $droppable?: {
+        context: import("@k8slens/element-components").DraggableContext<any>;
+        onDrop: (item: any) => void;
+    } | undefined;
+    $font?: boolean | {
+        size?: import("@k8slens/element-components").FontSize;
+        italic?: boolean;
+        bold?: boolean | "600";
+        lineHeight?: import("@k8slens/element-components").FontLineHeight;
+        forceWrap?: boolean;
+        noWrap?: boolean;
+        uppercase?: boolean;
+        underline?: boolean;
+        textOverflow?: "clip" | "ellipsis" | "default";
+    };
+    $tooltip?: string | import("@k8slens/element-components").$TooltipProps<any> | null;
+    $width?: import("@k8slens/element-components").TShirtSize | "full" | "stretch" | import("@k8slens/element-components").$WidthProps;
+    $height?: import("@k8slens/element-components").TShirtSize | "full" | "auto" | "stretch" | import("@k8slens/element-components").$HeightProps;
+    $size?: import("@k8slens/element-components").TShirtSize | "full" | import("@k8slens/element-components").$SizeProps;
+    $grid?: import("@k8slens/element-components").GridProps;
+    $flex?: import("@k8slens/element-components").SimpleFlexProp | import("@k8slens/element-components").MaximalFlexProps;
+    $gradient?: boolean;
+    $flexChild?: boolean | number | "shrinkable" | "fixed";
+    $area?: boolean;
+    $areaContent?: boolean;
+    $invisibleBackdrop?: boolean;
+} & React.SVGProps<SVGSVGElement>>>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<React.ComponentType<{
+    $className?: import("@k8slens/public-utilities").IClassName;
+    className?: string;
+    $block?: boolean | "inline";
+    $cursor?: import("@k8slens/element-components").$CursorProps;
+    readonly $color?: import("@k8slens/element-components").TextColor | import("@k8slens/element-components").$ColorProps;
+    $backgroundColor?: import("@k8slens/element-components").BackgroundColor | import("@k8slens/element-components").$BackgroundColorProps;
+    $border?: import("@k8slens/element-components").$BorderProps;
+    $padding?: boolean | import("@k8slens/element-components").DirectionalPadding | import("@k8slens/element-components").TShirtSize;
+    $margin?: boolean | import("@k8slens/element-components").DirectionalMargin | import("@k8slens/element-components").TShirtSize | "auto";
+    $overflow?: import("@k8slens/element-components").Overflow | {
+        x?: import("@k8slens/element-components").Overflow;
+        y?: import("@k8slens/element-components").Overflow;
+        hideScrollbar?: boolean;
+    };
+    readonly $anchor?: boolean;
+    readonly $anchoredAt?: import("@k8slens/element-components").AnchoredAt;
+    readonly children?: React.ReactNode;
+    readonly $onOutsideClick?: (event: PointerEvent) => void;
+    $textAlign?: "left" | "center" | "right";
+    $ref?: import("@k8slens/element-components").$RefProp<HTMLElement>;
+    ref?: import("@k8slens/element-components").RefLike<HTMLElement>;
+    $focusable?: {
+        context: import("@k8slens/element-components").AnyFocusableContext<any>;
+        item: any;
+        orderNumber?: number;
+    } | undefined;
+    onFocus?: React.FocusEventHandler<HTMLElement> | undefined;
+    onBlur?: React.FocusEventHandler<HTMLElement> | undefined;
+    onKeyDown?: React.KeyboardEventHandler<HTMLElement> | undefined;
+    tabIndex?: HTMLElement["tabIndex"];
+    $grayscale?: boolean;
+    $style?: React.CSSProperties;
+    style?: React.CSSProperties;
+    $tint?: string;
+    $faded?: boolean;
+    $outline?: {
+        focusVisible?: import("@k8slens/element-components").$OutlineProps;
+    };
+    readonly $floating?: import("@k8slens/element-components").$FloatingProps;
+    $boxShadow?: boolean | "elevated" | "subtle";
+    readonly $hoverable?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableProps>;
+    onMouseEnter?: React.MouseEventHandler<HTMLElement> | undefined;
+    onMouseLeave?: React.MouseEventHandler<HTMLElement> | undefined;
+    $hoverableByDragging?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableByDraggingProps<any>> | undefined;
+    $absolute?: import("@k8slens/element-components").AbsolutePosition | boolean;
+    $hidden?: boolean;
+    $noPointerEvents?: boolean;
+    $offset?: {
+        direction: import("@k8slens/element-components").Direction;
+        size: import("@k8slens/element-components").TShirtSize;
+    };
+    $offsetChildren?: {
+        direction: import("@k8slens/element-components").Direction;
+        size: import("@k8slens/element-components").TShirtSize;
+    };
+    $relative?: boolean;
+    $fixed?: boolean;
+    $transition?: boolean;
+    $visuallyHidden?: boolean;
+    $displayContents?: boolean;
+    $draggable?: {
+        context: import("@k8slens/element-components").DraggableContext<any>;
+        item: any;
+    } | undefined;
+    $droppable?: {
+        context: import("@k8slens/element-components").DraggableContext<any>;
+        onDrop: (item: any) => void;
+    } | undefined;
+    $font?: boolean | {
+        size?: import("@k8slens/element-components").FontSize;
+        italic?: boolean;
+        bold?: boolean | "600";
+        lineHeight?: import("@k8slens/element-components").FontLineHeight;
+        forceWrap?: boolean;
+        noWrap?: boolean;
+        uppercase?: boolean;
+        underline?: boolean;
+        textOverflow?: "clip" | "ellipsis" | "default";
+    };
+    $tooltip?: string | import("@k8slens/element-components").$TooltipProps<any> | null;
+    $width?: import("@k8slens/element-components").TShirtSize | "full" | "stretch" | import("@k8slens/element-components").$WidthProps;
+    $height?: import("@k8slens/element-components").TShirtSize | "full" | "auto" | "stretch" | import("@k8slens/element-components").$HeightProps;
+    $size?: import("@k8slens/element-components").TShirtSize | "full" | import("@k8slens/element-components").$SizeProps;
+    $grid?: import("@k8slens/element-components").GridProps;
+    $flex?: import("@k8slens/element-components").SimpleFlexProp | import("@k8slens/element-components").MaximalFlexProps;
+    $gradient?: boolean;
+    $flexChild?: boolean | number | "shrinkable" | "fixed";
+    $area?: boolean;
+    $areaContent?: boolean;
+    $invisibleBackdrop?: boolean;
+} & React.SVGProps<SVGSVGElement>>>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<Promise<IComputedValue<React.ComponentType<{
+    $className?: import("@k8slens/public-utilities").IClassName;
+    className?: string;
+    $block?: boolean | "inline";
+    $cursor?: import("@k8slens/element-components").$CursorProps;
+    readonly $color?: import("@k8slens/element-components").TextColor | import("@k8slens/element-components").$ColorProps;
+    $backgroundColor?: import("@k8slens/element-components").BackgroundColor | import("@k8slens/element-components").$BackgroundColorProps;
+    $border?: import("@k8slens/element-components").$BorderProps;
+    $padding?: boolean | import("@k8slens/element-components").DirectionalPadding | import("@k8slens/element-components").TShirtSize;
+    $margin?: boolean | import("@k8slens/element-components").DirectionalMargin | import("@k8slens/element-components").TShirtSize | "auto";
+    $overflow?: import("@k8slens/element-components").Overflow | {
+        x?: import("@k8slens/element-components").Overflow;
+        y?: import("@k8slens/element-components").Overflow;
+        hideScrollbar?: boolean;
+    };
+    readonly $anchor?: boolean;
+    readonly $anchoredAt?: import("@k8slens/element-components").AnchoredAt;
+    readonly children?: React.ReactNode;
+    readonly $onOutsideClick?: (event: PointerEvent) => void;
+    $textAlign?: "left" | "center" | "right";
+    $ref?: import("@k8slens/element-components").$RefProp<HTMLElement>;
+    ref?: import("@k8slens/element-components").RefLike<HTMLElement>;
+    $focusable?: {
+        context: import("@k8slens/element-components").AnyFocusableContext<any>;
+        item: any;
+        orderNumber?: number;
+    } | undefined;
+    onFocus?: React.FocusEventHandler<HTMLElement> | undefined;
+    onBlur?: React.FocusEventHandler<HTMLElement> | undefined;
+    onKeyDown?: React.KeyboardEventHandler<HTMLElement> | undefined;
+    tabIndex?: HTMLElement["tabIndex"];
+    $grayscale?: boolean;
+    $style?: React.CSSProperties;
+    style?: React.CSSProperties;
+    $tint?: string;
+    $faded?: boolean;
+    $outline?: {
+        focusVisible?: import("@k8slens/element-components").$OutlineProps;
+    };
+    readonly $floating?: import("@k8slens/element-components").$FloatingProps;
+    $boxShadow?: boolean | "elevated" | "subtle";
+    readonly $hoverable?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableProps>;
+    onMouseEnter?: React.MouseEventHandler<HTMLElement> | undefined;
+    onMouseLeave?: React.MouseEventHandler<HTMLElement> | undefined;
+    $hoverableByDragging?: import("@k8slens/public-utilities").SingleOrMany<import("@k8slens/element-components").$HoverableByDraggingProps<any>> | undefined;
+    $absolute?: import("@k8slens/element-components").AbsolutePosition | boolean;
+    $hidden?: boolean;
+    $noPointerEvents?: boolean;
+    $offset?: {
+        direction: import("@k8slens/element-components").Direction;
+        size: import("@k8slens/element-components").TShirtSize;
+    };
+    $offsetChildren?: {
+        direction: import("@k8slens/element-components").Direction;
+        size: import("@k8slens/element-components").TShirtSize;
+    };
+    $relative?: boolean;
+    $fixed?: boolean;
+    $transition?: boolean;
+    $visuallyHidden?: boolean;
+    $displayContents?: boolean;
+    $draggable?: {
+        context: import("@k8slens/element-components").DraggableContext<any>;
+        item: any;
+    } | undefined;
+    $droppable?: {
+        context: import("@k8slens/element-components").DraggableContext<any>;
+        onDrop: (item: any) => void;
+    } | undefined;
+    $font?: boolean | {
+        size?: import("@k8slens/element-components").FontSize;
+        italic?: boolean;
+        bold?: boolean | "600";
+        lineHeight?: import("@k8slens/element-components").FontLineHeight;
+        forceWrap?: boolean;
+        noWrap?: boolean;
+        uppercase?: boolean;
+        underline?: boolean;
+        textOverflow?: "clip" | "ellipsis" | "default";
+    };
+    $tooltip?: string | import("@k8slens/element-components").$TooltipProps<any> | null;
+    $width?: import("@k8slens/element-components").TShirtSize | "full" | "stretch" | import("@k8slens/element-components").$WidthProps;
+    $height?: import("@k8slens/element-components").TShirtSize | "full" | "auto" | "stretch" | import("@k8slens/element-components").$HeightProps;
+    $size?: import("@k8slens/element-components").TShirtSize | "full" | import("@k8slens/element-components").$SizeProps;
+    $grid?: import("@k8slens/element-components").GridProps;
+    $flex?: import("@k8slens/element-components").SimpleFlexProp | import("@k8slens/element-components").MaximalFlexProps;
+    $gradient?: boolean;
+    $flexChild?: boolean | number | "shrinkable" | "fixed";
+    $area?: boolean;
+    $areaContent?: boolean;
+    $invisibleBackdrop?: boolean;
+} & React.SVGProps<SVGSVGElement>>>>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=selected-ai-tool-injection-tokens.d.ts.map

package/dist/src/selected-ai-tool-injection-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selected-ai-tool-injection-tokens.d.ts","sourceRoot":"","sources":["../../src/selected-ai-tool-injection-tokens.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AAC7D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,uCAAuC,EAAE,MAAM,WAAW,CAAC;AAEpG,qHAAqH;AACrH,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,CAAC,gBAAgB,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;AAEzF;;;;GAIG;AACH,eAAO,MAAM,gCAAgC;;CAGzC,CAAC;AAEL,6FAA6F;AAC7F,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;CAG1C,CAAC;AAEL,uGAAuG;AACvG,MAAM,MAAM,qBAAqB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC,CAAC;AAE7F;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC;;CAG5C,CAAC;AAEL,6GAA6G;AAC7G,MAAM,MAAM,2BAA2B,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC,CAAC;AAEnG;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC;;CAKlD,CAAC;AAEL,iGAAiG;AACjG,MAAM,MAAM,2CAA2C,GAAG,MAAM,OAAO,CACrE,cAAc,CAAC,uCAAuC,GAAG,SAAS,CAAC,CACpE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yDAAyD;;CAKlE,CAAC;AAEL,kEAAkE;AAClE,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;AAErF;;;;GAIG;AACH,eAAO,MAAM,iCAAiC;;CAG1C,CAAC;AAEL,6DAA6D;AAC7D,MAAM,MAAM,0BAA0B,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,wCAAwC;;CAKjD,CAAC;AAEL,oDAAoD;AACpD,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE/F;;;;GAIG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG1C,CAAC"}