@uipath/apollo-wind 2.45.1 → 2.47.0

package/dist/components/ui/prompt-editor/utils/rich-serialization.cjs

@@ -0,0 +1,186 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RICH_EDITOR_EXTRA_NODES: ()=>RICH_EDITOR_EXTRA_NODES,
+    $getRichEditorTokensInternal: ()=>$getRichEditorTokensInternal,
+    PROMPT_EDITOR_RICH_TRANSFORMERS: ()=>PROMPT_EDITOR_RICH_TRANSFORMERS,
+    $setRichEditorTokensInternal: ()=>$setRichEditorTokensInternal,
+    normalizeRichTextTokens: ()=>normalizeRichTextTokens
+});
+const list_namespaceObject = require("@lexical/list");
+const markdown_namespaceObject = require("@lexical/markdown");
+const external_lexical_namespaceObject = require("lexical");
+const index_cjs_namespaceObject = require("../nodes/index.cjs");
+const token_nodes_cjs_namespaceObject = require("../plugins/shared/token-nodes.cjs");
+const external_insert_token_cjs_namespaceObject = require("./insert-token.cjs");
+const external_serialization_cjs_namespaceObject = require("./serialization.cjs");
+const PROMPT_EDITOR_RICH_TRANSFORMERS = [
+    markdown_namespaceObject.ORDERED_LIST,
+    markdown_namespaceObject.UNORDERED_LIST,
+    markdown_namespaceObject.BOLD_ITALIC_STAR,
+    markdown_namespaceObject.BOLD_ITALIC_UNDERSCORE,
+    markdown_namespaceObject.BOLD_STAR,
+    markdown_namespaceObject.BOLD_UNDERSCORE,
+    markdown_namespaceObject.ITALIC_STAR,
+    markdown_namespaceObject.ITALIC_UNDERSCORE,
+    markdown_namespaceObject.STRIKETHROUGH
+];
+const RICH_EDITOR_EXTRA_NODES = [
+    list_namespaceObject.ListNode,
+    list_namespaceObject.ListItemNode
+];
+const PILL_SENTINEL_START = '\uE000';
+const PILL_SENTINEL_END = '\uE001';
+const PILL_SENTINEL_IMPORT = /\uE000(\d+)\uE001/;
+const PILL_SENTINEL_SPLIT = /(\uE000\d+\uE001)/;
+const PILL_SENTINEL_ANY = /[\uE000\uE001]/g;
+function createPillImportTransformer(pills) {
+    return {
+        dependencies: [
+            index_cjs_namespaceObject.InputTokenNode,
+            index_cjs_namespaceObject.OutputTokenNode,
+            index_cjs_namespaceObject.StateTokenNode,
+            index_cjs_namespaceObject.ResourceTokenNode
+        ],
+        importRegExp: PILL_SENTINEL_IMPORT,
+        regExp: PILL_SENTINEL_IMPORT,
+        replace: (node, match)=>{
+            const pill = pills[Number(match[1])];
+            if (!pill) return void node.setTextContent('');
+            node.replace((0, external_insert_token_cjs_namespaceObject.createTokenNodeForOption)(pill));
+        },
+        type: 'text-match'
+    };
+}
+function createPillExportTransformer(pills) {
+    return {
+        dependencies: [
+            index_cjs_namespaceObject.InputTokenNode,
+            index_cjs_namespaceObject.OutputTokenNode,
+            index_cjs_namespaceObject.StateTokenNode,
+            index_cjs_namespaceObject.ResourceTokenNode
+        ],
+        regExp: PILL_SENTINEL_IMPORT,
+        export: (node)=>{
+            if (!(0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(node)) return null;
+            const type = token_nodes_cjs_namespaceObject.NODE_TYPE_TO_TOKEN_TYPE[node.getType()];
+            if (!type) return null;
+            const index = pills.length;
+            pills.push({
+                type,
+                value: node.getValue()
+            });
+            return `${PILL_SENTINEL_START}${index}${PILL_SENTINEL_END}`;
+        },
+        type: 'text-match'
+    };
+}
+const unescapeMarkdownLiterals = (markdown)=>markdown.replace(/\\([*_`~\\])/g, '$1');
+function $getRichEditorTokensInternal() {
+    const pills = [];
+    const markdown = (0, markdown_namespaceObject.$convertToMarkdownString)([
+        ...PROMPT_EDITOR_RICH_TRANSFORMERS,
+        createPillExportTransformer(pills)
+    ], void 0, true);
+    const tokens = [];
+    for (const part of unescapeMarkdownLiterals(markdown).split(PILL_SENTINEL_SPLIT)){
+        if ('' === part) continue;
+        const pillMatch = PILL_SENTINEL_IMPORT.exec(part);
+        if (pillMatch && pillMatch[0] === part) {
+            const pill = pills[Number(pillMatch[1])];
+            if (pill) tokens.push({
+                ...pill
+            });
+            continue;
+        }
+        const text = part.split(external_serialization_cjs_namespaceObject.WORD_JOINER).join('');
+        if ('' === text) continue;
+        const last = tokens[tokens.length - 1];
+        if (last && 'text' === last.type) last.value += text;
+        else tokens.push({
+            type: 'text',
+            value: text
+        });
+    }
+    return tokens;
+}
+function $setRichEditorTokensInternal(tokens) {
+    const pills = [];
+    let markdown = '';
+    for (const token of tokens)if ('text' === token.type) markdown += token.value.replace(PILL_SENTINEL_ANY, '');
+    else {
+        const index = pills.length;
+        pills.push({
+            type: token.type,
+            value: token.value
+        });
+        markdown += `${PILL_SENTINEL_START}${index}${PILL_SENTINEL_END}`;
+    }
+    const root = (0, external_lexical_namespaceObject.$getRoot)();
+    root.clear();
+    (0, markdown_namespaceObject.$convertFromMarkdownString)(markdown, [
+        ...PROMPT_EDITOR_RICH_TRANSFORMERS,
+        createPillImportTransformer(pills)
+    ], root, true);
+}
+function normalizeRichTextTokens(tokens) {
+    const editor = (0, external_lexical_namespaceObject.createEditor)({
+        namespace: 'PromptEditorRichNormalize',
+        nodes: [
+            index_cjs_namespaceObject.InputTokenNode,
+            index_cjs_namespaceObject.OutputTokenNode,
+            index_cjs_namespaceObject.StateTokenNode,
+            index_cjs_namespaceObject.ResourceTokenNode,
+            ...RICH_EDITOR_EXTRA_NODES
+        ],
+        onError: (error)=>{
+            throw error;
+        }
+    });
+    editor.update(()=>$setRichEditorTokensInternal(tokens), {
+        discrete: true
+    });
+    let result = [];
+    editor.read(()=>{
+        result = $getRichEditorTokensInternal();
+    });
+    return result;
+}
+exports.$getRichEditorTokensInternal = __webpack_exports__.$getRichEditorTokensInternal;
+exports.$setRichEditorTokensInternal = __webpack_exports__.$setRichEditorTokensInternal;
+exports.PROMPT_EDITOR_RICH_TRANSFORMERS = __webpack_exports__.PROMPT_EDITOR_RICH_TRANSFORMERS;
+exports.RICH_EDITOR_EXTRA_NODES = __webpack_exports__.RICH_EDITOR_EXTRA_NODES;
+exports.normalizeRichTextTokens = __webpack_exports__.normalizeRichTextTokens;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "$getRichEditorTokensInternal",
+    "$setRichEditorTokensInternal",
+    "PROMPT_EDITOR_RICH_TRANSFORMERS",
+    "RICH_EDITOR_EXTRA_NODES",
+    "normalizeRichTextTokens"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/utils/rich-serialization.d.ts

@@ -0,0 +1,38 @@
+import { ListItemNode, ListNode } from '@lexical/list';
+import { type Transformer } from '@lexical/markdown';
+import type { PromptEditorToken } from '../types';
+/**
+ * Rich (WYSIWYG) serialization for the prompt editor: the `PromptEditorToken[]` contract is
+ * unchanged — text tokens carry markdown — but in rich mode the editor state holds real formatted
+ * nodes, converted through `@lexical/markdown` on the way in and out.
+ *
+ * Two invariants drive everything here:
+ *
+ * 1. **`\n` is a visible line break** (the plain editor's convention; previews render with
+ *    `breaks: true`). Both conversions run with `shouldPreserveNewLines: true` so `a\nb` and
+ *    `a\n\nb` each round-trip byte-identically instead of being rewritten into paragraph spacing.
+ * 2. **Unknown markdown stays literal.** The transformer set is exactly the toolbar's feature set
+ *    (bold/italic/strikethrough + ordered/bulleted lists). Headings, quotes, code, links, tables
+ *    pass through as plain text, which is the round-trip-safe behavior.
+ */
+/** The toolbar's feature set. Underscore emphasis variants import legacy content; export emits star forms. */
+export declare const PROMPT_EDITOR_RICH_TRANSFORMERS: Transformer[];
+/** Lexical node classes rich mode registers beyond the plain editor's token nodes. */
+export declare const RICH_EDITOR_EXTRA_NODES: (typeof ListNode | typeof ListItemNode)[];
+/**
+ * Editor state → tokens. Must be called inside `editor.read()`/`editor.update()`.
+ * Formatted content serializes to markdown text tokens; pills come out as typed tokens.
+ */
+export declare function $getRichEditorTokensInternal(): PromptEditorToken[];
+/**
+ * Tokens → editor state. Must be called inside `editor.update()`. Clears the root and parses the
+ * text tokens' markdown into formatted nodes, splicing pills back in as decorator nodes.
+ */
+export declare function $setRichEditorTokensInternal(tokens: PromptEditorToken[]): void;
+/**
+ * Pure "what will the rich editor re-emit for this seed" — an import→export round-trip through a
+ * headless editor. Consumers use it to tell a genuine edit apart from mere markdown normalization
+ * (`_em_` → `*em*`, `* item` → `- item`, …) so an untouched open/blur never rewrites a stored
+ * value. Deterministic and side-effect free.
+ */
+export declare function normalizeRichTextTokens(tokens: PromptEditorToken[]): PromptEditorToken[];

package/dist/components/ui/prompt-editor/utils/rich-serialization.js

@@ -0,0 +1,140 @@
+import { ListItemNode, ListNode } from "@lexical/list";
+import { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, ITALIC_STAR, ITALIC_UNDERSCORE, ORDERED_LIST, STRIKETHROUGH, UNORDERED_LIST } from "@lexical/markdown";
+import { $getRoot, createEditor } from "lexical";
+import { InputTokenNode, OutputTokenNode, ResourceTokenNode, StateTokenNode } from "../nodes/index.js";
+import { NODE_TYPE_TO_TOKEN_TYPE, isPromptTokenNode } from "../plugins/shared/token-nodes.js";
+import { createTokenNodeForOption } from "./insert-token.js";
+import { WORD_JOINER } from "./serialization.js";
+const PROMPT_EDITOR_RICH_TRANSFORMERS = [
+    ORDERED_LIST,
+    UNORDERED_LIST,
+    BOLD_ITALIC_STAR,
+    BOLD_ITALIC_UNDERSCORE,
+    BOLD_STAR,
+    BOLD_UNDERSCORE,
+    ITALIC_STAR,
+    ITALIC_UNDERSCORE,
+    STRIKETHROUGH
+];
+const RICH_EDITOR_EXTRA_NODES = [
+    ListNode,
+    ListItemNode
+];
+const PILL_SENTINEL_START = '\uE000';
+const PILL_SENTINEL_END = '\uE001';
+const PILL_SENTINEL_IMPORT = /\uE000(\d+)\uE001/;
+const PILL_SENTINEL_SPLIT = /(\uE000\d+\uE001)/;
+const PILL_SENTINEL_ANY = /[\uE000\uE001]/g;
+function createPillImportTransformer(pills) {
+    return {
+        dependencies: [
+            InputTokenNode,
+            OutputTokenNode,
+            StateTokenNode,
+            ResourceTokenNode
+        ],
+        importRegExp: PILL_SENTINEL_IMPORT,
+        regExp: PILL_SENTINEL_IMPORT,
+        replace: (node, match)=>{
+            const pill = pills[Number(match[1])];
+            if (!pill) return void node.setTextContent('');
+            node.replace(createTokenNodeForOption(pill));
+        },
+        type: 'text-match'
+    };
+}
+function createPillExportTransformer(pills) {
+    return {
+        dependencies: [
+            InputTokenNode,
+            OutputTokenNode,
+            StateTokenNode,
+            ResourceTokenNode
+        ],
+        regExp: PILL_SENTINEL_IMPORT,
+        export: (node)=>{
+            if (!isPromptTokenNode(node)) return null;
+            const type = NODE_TYPE_TO_TOKEN_TYPE[node.getType()];
+            if (!type) return null;
+            const index = pills.length;
+            pills.push({
+                type,
+                value: node.getValue()
+            });
+            return `${PILL_SENTINEL_START}${index}${PILL_SENTINEL_END}`;
+        },
+        type: 'text-match'
+    };
+}
+const unescapeMarkdownLiterals = (markdown)=>markdown.replace(/\\([*_`~\\])/g, '$1');
+function $getRichEditorTokensInternal() {
+    const pills = [];
+    const markdown = $convertToMarkdownString([
+        ...PROMPT_EDITOR_RICH_TRANSFORMERS,
+        createPillExportTransformer(pills)
+    ], void 0, true);
+    const tokens = [];
+    for (const part of unescapeMarkdownLiterals(markdown).split(PILL_SENTINEL_SPLIT)){
+        if ('' === part) continue;
+        const pillMatch = PILL_SENTINEL_IMPORT.exec(part);
+        if (pillMatch && pillMatch[0] === part) {
+            const pill = pills[Number(pillMatch[1])];
+            if (pill) tokens.push({
+                ...pill
+            });
+            continue;
+        }
+        const text = part.split(WORD_JOINER).join('');
+        if ('' === text) continue;
+        const last = tokens[tokens.length - 1];
+        if (last && 'text' === last.type) last.value += text;
+        else tokens.push({
+            type: 'text',
+            value: text
+        });
+    }
+    return tokens;
+}
+function $setRichEditorTokensInternal(tokens) {
+    const pills = [];
+    let markdown = '';
+    for (const token of tokens)if ('text' === token.type) markdown += token.value.replace(PILL_SENTINEL_ANY, '');
+    else {
+        const index = pills.length;
+        pills.push({
+            type: token.type,
+            value: token.value
+        });
+        markdown += `${PILL_SENTINEL_START}${index}${PILL_SENTINEL_END}`;
+    }
+    const root = $getRoot();
+    root.clear();
+    $convertFromMarkdownString(markdown, [
+        ...PROMPT_EDITOR_RICH_TRANSFORMERS,
+        createPillImportTransformer(pills)
+    ], root, true);
+}
+function normalizeRichTextTokens(tokens) {
+    const editor = createEditor({
+        namespace: 'PromptEditorRichNormalize',
+        nodes: [
+            InputTokenNode,
+            OutputTokenNode,
+            StateTokenNode,
+            ResourceTokenNode,
+            ...RICH_EDITOR_EXTRA_NODES
+        ],
+        onError: (error)=>{
+            throw error;
+        }
+    });
+    editor.update(()=>$setRichEditorTokensInternal(tokens), {
+        discrete: true
+    });
+    let result = [];
+    editor.read(()=>{
+        result = $getRichEditorTokensInternal();
+    });
+    return result;
+}
+export { $getRichEditorTokensInternal, $setRichEditorTokensInternal, PROMPT_EDITOR_RICH_TRANSFORMERS, RICH_EDITOR_EXTRA_NODES, normalizeRichTextTokens };

package/dist/components/ui/prompt-editor/utils/serialization.cjs

@@ -191,14 +191,22 @@ const getEditorTokensFromSelection = (selection)=>{
     if (0 === nodesToProcess.length) return [];
     const firstSelectedNode = nodesToProcess[0];
     const isForward = 1 === nodesToProcess.length ? anchorOffset <= focusOffset : firstSelectedNode.getKey() === anchorKey || firstSelectedNode.getParent()?.getKey() === anchorKey;
-    let prevNodeParagraph = null;
+    const blockOf = (node)=>{
+        let current = node;
+        while(current){
+            if ((0, external_lexical_namespaceObject.$isElementNode)(current) && !current.isInline()) return current;
+            current = current.getParent();
+        }
+        return null;
+    };
+    let prevNodeBlock = null;
     for (const node of nodesToProcess){
         const nodeKey = node.getKey();
         const nodeType = node.getType();
-        const nodeParagraph = (0, external_lexical_namespaceObject.$isParagraphNode)(node) ? node : node.getParent();
-        if (prevNodeParagraph && nodeParagraph && prevNodeParagraph !== nodeParagraph) addText('\n');
-        prevNodeParagraph = nodeParagraph;
-        if (!(0, external_lexical_namespaceObject.$isParagraphNode)(node)) {
+        const nodeBlock = blockOf(node);
+        if (prevNodeBlock && nodeBlock && prevNodeBlock !== nodeBlock) addText('\n');
+        prevNodeBlock = nodeBlock;
+        if (!(0, external_lexical_namespaceObject.$isElementNode)(node)) {
             if ('input-token' === nodeType) tokens.push({
                 type: 'input',
                 value: node.getValue()

package/dist/components/ui/prompt-editor/utils/serialization.js

@@ -1,4 +1,4 @@
-import { $createLineBreakNode, $createParagraphNode, $createTextNode, $getRoot, $isLineBreakNode, $isParagraphNode, $isRangeSelection, $isTextNode } from "lexical";
+import { $createLineBreakNode, $createParagraphNode, $createTextNode, $getRoot, $isElementNode, $isLineBreakNode, $isParagraphNode, $isRangeSelection, $isTextNode } from "lexical";
 import { createInputTokenNode, createOutputTokenNode, createResourceTokenNode, createStateTokenNode, isInputTokenNode, isOutputTokenNode, isResourceTokenNode, isStateTokenNode } from "../nodes/index.js";
 const WORD_JOINER = '\u2060';
 const appendTextToken = (tokens, raw)=>{
@@ -156,14 +156,22 @@ const getEditorTokensFromSelection = (selection)=>{
     if (0 === nodesToProcess.length) return [];
     const firstSelectedNode = nodesToProcess[0];
     const isForward = 1 === nodesToProcess.length ? anchorOffset <= focusOffset : firstSelectedNode.getKey() === anchorKey || firstSelectedNode.getParent()?.getKey() === anchorKey;
-    let prevNodeParagraph = null;
+    const blockOf = (node)=>{
+        let current = node;
+        while(current){
+            if ($isElementNode(current) && !current.isInline()) return current;
+            current = current.getParent();
+        }
+        return null;
+    };
+    let prevNodeBlock = null;
     for (const node of nodesToProcess){
         const nodeKey = node.getKey();
         const nodeType = node.getType();
-        const nodeParagraph = $isParagraphNode(node) ? node : node.getParent();
-        if (prevNodeParagraph && nodeParagraph && prevNodeParagraph !== nodeParagraph) addText('\n');
-        prevNodeParagraph = nodeParagraph;
-        if (!$isParagraphNode(node)) {
+        const nodeBlock = blockOf(node);
+        if (prevNodeBlock && nodeBlock && prevNodeBlock !== nodeBlock) addText('\n');
+        prevNodeBlock = nodeBlock;
+        if (!$isElementNode(node)) {
             if ('input-token' === nodeType) tokens.push({
                 type: 'input',
                 value: node.getValue()

package/dist/components/ui/sheet.d.ts

@@ -14,7 +14,7 @@ declare const SheetPortal: {
 };
 declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const sheetVariants: (props?: ({
-    side?: "left" | "right" | "bottom" | "top" | null | undefined;
+    side?: "left" | "right" | "top" | "bottom" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
     container?: PortalContainerOverride;

package/dist/components/ui/spinner.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const spinnerVariants: (props?: ({
-    size?: "default" | "lg" | "sm" | "xl" | null | undefined;
+    size?: "sm" | "lg" | "xl" | "default" | null | undefined;
     variant?: "default" | "primary" | "foreground" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof spinnerVariants> {

package/dist/components/ui/switch.d.ts

@@ -2,9 +2,9 @@ import * as SwitchPrimitives from '@radix-ui/react-switch';
 import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const switchVariants: (props?: ({
-    size?: "default" | "sm" | null | undefined;
+    size?: "sm" | "default" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
-    size?: "default" | "sm" | null | undefined;
+    size?: "sm" | "default" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
 export { Switch, switchVariants };

package/dist/components/ui/toggle-group.d.ts

@@ -3,12 +3,12 @@ import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "lg" | "sm" | "xs" | null | undefined;
+    size?: "sm" | "lg" | "default" | "xs" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
     spacing?: number;
 }) & React.RefAttributes<HTMLDivElement>>;
 declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "lg" | "sm" | "xs" | null | undefined;
+    size?: "sm" | "lg" | "default" | "xs" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
 export { ToggleGroup, ToggleGroupItem };

package/dist/components/ui/toggle.d.ts

@@ -3,10 +3,10 @@ import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const toggleVariants: (props?: ({
     variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "lg" | "sm" | "xs" | null | undefined;
+    size?: "sm" | "lg" | "default" | "xs" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "lg" | "sm" | "xs" | null | undefined;
+    size?: "sm" | "lg" | "default" | "xs" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
 export { Toggle, toggleVariants };