magick-ui 0.2.1 → 0.2.2

package/dist/schema.cjs

@@ -20,8 +20,94 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
+  accordionContentSchema: () => accordionContentSchema,
+  accordionItemSchema: () => accordionItemSchema,
+  accordionSchema: () => accordionSchema,
+  accordionTriggerSchema: () => accordionTriggerSchema,
+  alertSchema: () => alertSchema,
+  avatarListItemSchema: () => avatarListItemSchema,
+  avatarSchema: () => avatarSchema,
+  badgeSchema: () => badgeSchema,
+  breadcrumbSchema: () => breadcrumbSchema,
+  buttonLinkSchema: () => buttonLinkSchema,
+  buttonSchema: () => buttonSchema,
+  buttonWithTooltipSchema: () => buttonWithTooltipSchema,
+  calendarSchema: () => calendarSchema,
+  cardActionSchema: () => cardActionSchema,
+  cardContentSchema: () => cardContentSchema,
+  cardDescriptionSchema: () => cardDescriptionSchema,
+  cardFooterSchema: () => cardFooterSchema,
+  cardHeaderSchema: () => cardHeaderSchema,
+  cardSchema: () => cardSchema,
+  cardTitleSchema: () => cardTitleSchema,
+  carouselContentSchema: () => carouselContentSchema,
+  carouselItemSchema: () => carouselItemSchema,
+  carouselSchema: () => carouselSchema,
+  checkboxFieldSchema: () => checkboxFieldSchema,
+  chipSchema: () => chipSchema,
+  comboboxFieldSchema: () => comboboxFieldSchema,
   componentSchema: () => componentSchema,
-  getComponentSchemas: () => getComponentSchemas
+  componentSchemas: () => componentSchemas,
+  contextMenuContentSchema: () => contextMenuContentSchema,
+  contextMenuItemSchema: () => contextMenuItemSchema,
+  contextMenuSchema: () => contextMenuSchema,
+  contextMenuSeparatorSchema: () => contextMenuSeparatorSchema,
+  contextMenuTriggerSchema: () => contextMenuTriggerSchema,
+  dateFieldSchema: () => dateFieldSchema,
+  dropdownMenuContentSchema: () => dropdownMenuContentSchema,
+  dropdownMenuItemSchema: () => dropdownMenuItemSchema,
+  dropdownMenuLabelSchema: () => dropdownMenuLabelSchema,
+  dropdownMenuSchema: () => dropdownMenuSchema,
+  dropdownMenuSeparatorSchema: () => dropdownMenuSeparatorSchema,
+  dropdownMenuTriggerSchema: () => dropdownMenuTriggerSchema,
+  fileInputSchema: () => fileInputSchema,
+  fileUploadFieldSchema: () => fileUploadFieldSchema,
+  formSchema: () => formSchema,
+  getComponentSchemas: () => getComponentSchemas,
+  gradientContainerSchema: () => gradientContainerSchema,
+  gridSchema: () => gridSchema,
+  iconButtonSchema: () => iconButtonSchema,
+  iconContainerSchema: () => iconContainerSchema,
+  iconProfileSchema: () => iconProfileSchema,
+  inputFieldSchema: () => inputFieldSchema,
+  labelSchema: () => labelSchema,
+  linkButtonSchema: () => linkButtonSchema,
+  mediaSchema: () => mediaSchema,
+  multiSelectFieldSchema: () => multiSelectFieldSchema,
+  otpFieldSchema: () => otpFieldSchema,
+  passwordFieldSchema: () => passwordFieldSchema,
+  popoverContentSchema: () => popoverContentSchema,
+  popoverSchema: () => popoverSchema,
+  popoverTriggerSchema: () => popoverTriggerSchema,
+  progressIndicatorSchema: () => progressIndicatorSchema,
+  radioFieldSchema: () => radioFieldSchema,
+  searchInputSchema: () => searchInputSchema,
+  selectFieldSchema: () => selectFieldSchema,
+  selectHoverSchema: () => selectHoverSchema,
+  sheetContentSchema: () => sheetContentSchema,
+  sheetDescriptionSchema: () => sheetDescriptionSchema,
+  sheetFooterSchema: () => sheetFooterSchema,
+  sheetHeaderSchema: () => sheetHeaderSchema,
+  sheetSchema: () => sheetSchema,
+  sheetTitleSchema: () => sheetTitleSchema,
+  sheetTriggerSchema: () => sheetTriggerSchema,
+  skeletonSchema: () => skeletonSchema,
+  sliderSchema: () => sliderSchema,
+  switchFieldSchema: () => switchFieldSchema,
+  tableSchema: () => tableSchema,
+  tabsSchema: () => tabsSchema,
+  tagSchema: () => tagSchema,
+  textSchema: () => textSchema,
+  textareaFieldSchema: () => textareaFieldSchema,
+  timeFieldSchema: () => timeFieldSchema,
+  titleSchema: () => titleSchema,
+  toggleDropdownButtonSchema: () => toggleDropdownButtonSchema,
+  toggleSchema: () => toggleSchema,
+  toolButtonSchema: () => toolButtonSchema,
+  toolToggleSchema: () => toolToggleSchema,
+  tooltipSchema: () => tooltipSchema,
+  uiNodeSchema: () => uiNodeSchema,
+  wrapperCardSchema: () => wrapperCardSchema
 });
 module.exports = __toCommonJS(schema_exports);
 
@@ -112,6 +198,88 @@ var component_schema_default = {
       },
       $schema: "http://json-schema.org/draft-07/schema#"
     },
+    "tool-button": {
+      $ref: "#/definitions/tool-button",
+      definitions: {
+        "tool-button": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "tool-button"
+            },
+            props: {
+              type: "object",
+              properties: {
+                variant: {
+                  type: "string",
+                  enum: [
+                    "primary",
+                    "outline",
+                    "destructive"
+                  ],
+                  description: "Button style. Defaults to 'primary'"
+                },
+                size: {
+                  type: "string",
+                  enum: [
+                    "md",
+                    "lg"
+                  ],
+                  description: "Button size. Defaults to 'md'"
+                },
+                state: {
+                  type: "string",
+                  enum: [
+                    "loading",
+                    "default"
+                  ],
+                  description: "Button state. Defaults to 'default'"
+                },
+                onlyIcon: {
+                  type: "boolean",
+                  description: "Icon-only mode with square padding"
+                },
+                disabled: {
+                  type: "boolean"
+                }
+              },
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "Button content"
+            }
+          },
+          required: [
+            "type"
+          ],
+          additionalProperties: false,
+          description: "A toolbar action button with loading state"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
     card: {
       $ref: "#/definitions/card",
       definitions: {
@@ -414,6 +582,55 @@ var component_schema_default = {
       },
       $schema: "http://json-schema.org/draft-07/schema#"
     },
+    "card-action": {
+      $ref: "#/definitions/card-action",
+      definitions: {
+        "card-action": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "card-action"
+            },
+            props: {
+              type: "object",
+              properties: {},
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "Action elements (buttons, links) placed at the top-right of a card header"
+            }
+          },
+          required: [
+            "type"
+          ],
+          additionalProperties: false,
+          description: "An action area positioned at the top-right of a card"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
     form: {
       $ref: "#/definitions/form",
       definitions: {
@@ -3117,169 +3334,604 @@ var component_schema_default = {
       },
       $schema: "http://json-schema.org/draft-07/schema#"
     },
-    sheet: {
-      $ref: "#/definitions/sheet",
+    calendar: {
+      $ref: "#/definitions/calendar",
       definitions: {
-        sheet: {
+        calendar: {
           type: "object",
           properties: {
             type: {
               type: "string",
-              const: "sheet"
+              const: "calendar"
             },
             props: {
               type: "object",
-              properties: {},
-              additionalProperties: false
-            },
-            children: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  type: {
-                    type: "string"
-                  },
-                  props: {
-                    type: "object",
-                    additionalProperties: {}
-                  },
-                  children: {
-                    type: "array",
-                    items: {}
-                  }
+              properties: {
+                showOutsideDays: {
+                  type: "boolean",
+                  description: "Show days from adjacent months. Defaults to true"
                 },
-                required: [
-                  "type"
-                ],
-                additionalProperties: false
+                captionLayout: {
+                  type: "string",
+                  enum: [
+                    "label",
+                    "dropdown",
+                    "dropdown-months",
+                    "dropdown-years"
+                  ],
+                  description: "Caption display mode. Defaults to 'label'"
+                },
+                buttonVariant: {
+                  type: "string",
+                  enum: [
+                    "primary",
+                    "secondary",
+                    "outline",
+                    "destructive",
+                    "ghost",
+                    "soft"
+                  ],
+                  description: "Navigation button style. Defaults to 'ghost'"
+                },
+                mode: {
+                  type: "string",
+                  enum: [
+                    "single",
+                    "multiple",
+                    "range"
+                  ],
+                  description: "Selection mode"
+                },
+                numberOfMonths: {
+                  type: "number",
+                  description: "Number of months to display"
+                },
+                disabled: {
+                  type: "boolean"
+                }
               },
-              description: "Compose with sheet-trigger and sheet-content"
+              additionalProperties: false
             }
           },
           required: [
             "type"
           ],
           additionalProperties: false,
-          description: "A slide-out panel overlay"
+          description: "A date calendar for picking dates or date ranges"
         }
       },
       $schema: "http://json-schema.org/draft-07/schema#"
     },
-    "sheet-trigger": {
-      $ref: "#/definitions/sheet-trigger",
+    "file-input": {
+      $ref: "#/definitions/file-input",
       definitions: {
-        "sheet-trigger": {
+        "file-input": {
           type: "object",
           properties: {
             type: {
               type: "string",
-              const: "sheet-trigger"
+              const: "file-input"
             },
             props: {
               type: "object",
-              properties: {},
-              additionalProperties: false
-            },
-            children: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  type: {
-                    type: "string"
-                  },
-                  props: {
-                    type: "object",
-                    additionalProperties: {}
-                  },
-                  children: {
-                    type: "array",
-                    items: {}
-                  }
+              properties: {
+                label: {
+                  type: "string",
+                  description: "Label text above the input"
                 },
-                required: [
-                  "type"
-                ],
-                additionalProperties: false
+                helperText: {
+                  type: "string",
+                  description: "Helper text below the input"
+                },
+                error: {
+                  type: "boolean",
+                  description: "Show error styling. Defaults to false"
+                },
+                accept: {
+                  type: "string",
+                  description: "Accepted file types, e.g. 'image/*,.pdf'"
+                },
+                multiple: {
+                  type: "boolean",
+                  description: "Allow multiple files. Defaults to false"
+                },
+                disabled: {
+                  type: "boolean"
+                }
               },
-              description: "The element that opens the sheet"
+              additionalProperties: false
             }
           },
           required: [
             "type"
           ],
           additionalProperties: false,
-          description: "Trigger element that opens a sheet"
+          description: "A file input with choose-file button and upload progress"
         }
       },
       $schema: "http://json-schema.org/draft-07/schema#"
     },
-    "sheet-content": {
-      $ref: "#/definitions/sheet-content",
+    "tool-toggle": {
+      $ref: "#/definitions/tool-toggle",
       definitions: {
-        "sheet-content": {
+        "tool-toggle": {
           type: "object",
           properties: {
             type: {
               type: "string",
-              const: "sheet-content"
+              const: "tool-toggle"
             },
             props: {
               type: "object",
               properties: {
-                side: {
+                icon: {
                   type: "string",
-                  enum: [
-                    "top",
-                    "right",
-                    "bottom",
-                    "left"
-                  ],
-                  description: "Slide-in direction. Defaults to 'right'"
+                  description: "Icon name (resolved by the renderer)"
                 },
-                showCloseButton: {
+                dropdown: {
                   type: "boolean",
-                  description: "Show close button. Defaults to true"
+                  description: "Show dropdown chevron"
                 }
               },
               additionalProperties: false
-            },
-            children: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  type: {
-                    type: "string"
-                  },
-                  props: {
-                    type: "object",
-                    additionalProperties: {}
-                  },
-                  children: {
-                    type: "array",
-                    items: {}
-                  }
-                },
-                required: [
-                  "type"
-                ],
-                additionalProperties: false
-              },
-              description: "Sheet body content"
             }
           },
           required: [
             "type"
           ],
           additionalProperties: false,
-          description: "Content panel of a sheet"
+          description: "A round toggle button used in toolbars, optionally with a dropdown"
         }
       },
       $schema: "http://json-schema.org/draft-07/schema#"
     },
-    "sheet-header": {
+    "toggle-dropdown-button": {
+      $ref: "#/definitions/toggle-dropdown-button",
+      definitions: {
+        "toggle-dropdown-button": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "toggle-dropdown-button"
+            },
+            props: {
+              type: "object",
+              properties: {
+                type: {
+                  type: "string",
+                  enum: [
+                    "text",
+                    "icon"
+                  ],
+                  description: "Button content type"
+                },
+                selected: {
+                  type: "boolean",
+                  description: "Whether the button is selected"
+                },
+                variant: {
+                  type: "string",
+                  enum: [
+                    "primary",
+                    "secondary",
+                    "destructive"
+                  ],
+                  description: "Button color variant"
+                }
+              },
+              required: [
+                "type",
+                "selected",
+                "variant"
+              ],
+              additionalProperties: false
+            }
+          },
+          required: [
+            "type",
+            "props"
+          ],
+          additionalProperties: false,
+          description: "A split toggle button with an attached dropdown trigger"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    "icon-container": {
+      $ref: "#/definitions/icon-container",
+      definitions: {
+        "icon-container": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "icon-container"
+            },
+            props: {
+              type: "object",
+              properties: {
+                icon: {
+                  type: "string",
+                  description: "Icon name (resolved by the renderer)"
+                },
+                size: {
+                  type: "string",
+                  enum: [
+                    "xs",
+                    "sm",
+                    "md",
+                    "lg",
+                    "xl",
+                    "2xl",
+                    "3xl",
+                    "4xl",
+                    "5xl",
+                    "6xl",
+                    "auto"
+                  ],
+                  description: "Icon size. Defaults to 'sm'"
+                },
+                colorInFill: {
+                  type: "boolean",
+                  description: "Apply fill colors to SVG paths. Defaults to true"
+                },
+                disableTheme: {
+                  type: "boolean",
+                  description: "Disable theme-aware coloring. Defaults to false"
+                }
+              },
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "Icon element"
+            }
+          },
+          required: [
+            "type"
+          ],
+          additionalProperties: false,
+          description: "A sized container for static icons with theme-aware coloring"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    "icon-profile": {
+      $ref: "#/definitions/icon-profile",
+      definitions: {
+        "icon-profile": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "icon-profile"
+            },
+            props: {
+              type: "object",
+              properties: {
+                icon: {
+                  type: "string",
+                  description: "Icon name (resolved by the renderer)"
+                },
+                color: {
+                  type: "string",
+                  enum: [
+                    "red",
+                    "orange",
+                    "amber",
+                    "yellow",
+                    "lime",
+                    "green",
+                    "emerald",
+                    "teal",
+                    "cyan",
+                    "sky",
+                    "blue",
+                    "indigo",
+                    "violet",
+                    "purple",
+                    "fuchsia",
+                    "pink",
+                    "rose",
+                    "slate"
+                  ],
+                  description: "Background glow and icon color. Defaults to 'red'"
+                },
+                size: {
+                  type: "string",
+                  enum: [
+                    "26",
+                    "32",
+                    "40",
+                    "48",
+                    "56",
+                    "64"
+                  ],
+                  description: "Size in pixels. Defaults to '64'"
+                },
+                externalIcon: {
+                  type: "boolean",
+                  description: "Whether the icon is external"
+                }
+              },
+              required: [
+                "icon"
+              ],
+              additionalProperties: false
+            }
+          },
+          required: [
+            "type",
+            "props"
+          ],
+          additionalProperties: false,
+          description: "An icon with a colored radial glow background"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    "button-with-tooltip": {
+      $ref: "#/definitions/button-with-tooltip",
+      definitions: {
+        "button-with-tooltip": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "button-with-tooltip"
+            },
+            props: {
+              type: "object",
+              properties: {
+                content: {
+                  type: "string",
+                  description: "Tooltip text"
+                },
+                position: {
+                  type: "string",
+                  enum: [
+                    "top",
+                    "top-center",
+                    "top-left",
+                    "top-right",
+                    "bottom",
+                    "bottom-left",
+                    "bottom-center",
+                    "bottom-right",
+                    "left",
+                    "right"
+                  ],
+                  description: "Tooltip placement"
+                },
+                withArrow: {
+                  type: "boolean",
+                  description: "Show an arrow pointer"
+                }
+              },
+              required: [
+                "content"
+              ],
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "The button element to wrap with a tooltip"
+            }
+          },
+          required: [
+            "type",
+            "props"
+          ],
+          additionalProperties: false,
+          description: "A button wrapped with a tooltip that appears on hover"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    sheet: {
+      $ref: "#/definitions/sheet",
+      definitions: {
+        sheet: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "sheet"
+            },
+            props: {
+              type: "object",
+              properties: {},
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "Compose with sheet-trigger and sheet-content"
+            }
+          },
+          required: [
+            "type"
+          ],
+          additionalProperties: false,
+          description: "A slide-out panel overlay"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    "sheet-trigger": {
+      $ref: "#/definitions/sheet-trigger",
+      definitions: {
+        "sheet-trigger": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "sheet-trigger"
+            },
+            props: {
+              type: "object",
+              properties: {},
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "The element that opens the sheet"
+            }
+          },
+          required: [
+            "type"
+          ],
+          additionalProperties: false,
+          description: "Trigger element that opens a sheet"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    "sheet-content": {
+      $ref: "#/definitions/sheet-content",
+      definitions: {
+        "sheet-content": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "sheet-content"
+            },
+            props: {
+              type: "object",
+              properties: {
+                side: {
+                  type: "string",
+                  enum: [
+                    "top",
+                    "right",
+                    "bottom",
+                    "left"
+                  ],
+                  description: "Slide-in direction. Defaults to 'right'"
+                },
+                showCloseButton: {
+                  type: "boolean",
+                  description: "Show close button. Defaults to true"
+                }
+              },
+              additionalProperties: false
+            },
+            children: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string"
+                  },
+                  props: {
+                    type: "object",
+                    additionalProperties: {}
+                  },
+                  children: {
+                    type: "array",
+                    items: {}
+                  }
+                },
+                required: [
+                  "type"
+                ],
+                additionalProperties: false
+              },
+              description: "Sheet body content"
+            }
+          },
+          required: [
+            "type"
+          ],
+          additionalProperties: false,
+          description: "Content panel of a sheet"
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    },
+    "sheet-header": {
       $ref: "#/definitions/sheet-header",
       definitions: {
         "sheet-header": {
@@ -4188,14 +4840,1109 @@ var component_schema_default = {
   }
 };
 
+// src/types.ts
+var import_zod = require("zod");
+var uiNodeSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.string(),
+    props: import_zod.z.record(import_zod.z.unknown()).optional(),
+    children: import_zod.z.array(uiNodeSchema).optional()
+  })
+);
+
+// src/ui/Button/schema.ts
+var import_zod2 = require("zod");
+var buttonSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("button"),
+  props: import_zod2.z.object({
+    label: import_zod2.z.string().optional().describe("Button text"),
+    variant: import_zod2.z.enum(["primary", "secondary", "outline", "destructive", "ghost", "soft"]).optional().describe("Button style. Defaults to 'primary'"),
+    size: import_zod2.z.enum(["sm", "md", "lg"]).optional().describe("Button size. Defaults to 'md'"),
+    url: import_zod2.z.string().optional().describe("URL to open when clicked"),
+    disabled: import_zod2.z.boolean().optional().describe("Whether the button is disabled")
+  }).optional(),
+  children: import_zod2.z.array(uiNodeSchema).optional()
+}).describe("An action button");
+var toolButtonSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("tool-button"),
+  props: import_zod2.z.object({
+    variant: import_zod2.z.enum(["primary", "outline", "destructive"]).optional().describe("Button style. Defaults to 'primary'"),
+    size: import_zod2.z.enum(["md", "lg"]).optional().describe("Button size. Defaults to 'md'"),
+    state: import_zod2.z.enum(["loading", "default"]).optional().describe("Button state. Defaults to 'default'"),
+    onlyIcon: import_zod2.z.boolean().optional().describe("Icon-only mode with square padding"),
+    disabled: import_zod2.z.boolean().optional()
+  }).optional(),
+  children: import_zod2.z.array(uiNodeSchema).optional().describe("Button content")
+}).describe("A toolbar action button with loading state");
+
+// src/ui/Card/schema.ts
+var import_zod3 = require("zod");
+var cardSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card"),
+  props: import_zod3.z.object({}).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional().describe("Compose with card-header, card-content, card-footer")
+}).describe("Container card");
+var cardHeaderSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card-header"),
+  props: import_zod3.z.object({}).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional().describe("Place card-title and card-description inside")
+}).describe("Header section of a card");
+var cardTitleSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card-title"),
+  props: import_zod3.z.object({
+    children: import_zod3.z.string().optional().describe("Title text")
+  }).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional()
+}).describe("Title inside a card-header");
+var cardDescriptionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card-description"),
+  props: import_zod3.z.object({
+    children: import_zod3.z.string().optional().describe("Description text")
+  }).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional()
+}).describe("Description text inside a card-header");
+var cardContentSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card-content"),
+  props: import_zod3.z.object({}).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional().describe("Main content area")
+}).describe("Main content area of a card");
+var cardFooterSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card-footer"),
+  props: import_zod3.z.object({}).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional().describe("Footer area, typically for actions")
+}).describe("Footer section of a card");
+var cardActionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("card-action"),
+  props: import_zod3.z.object({}).optional(),
+  children: import_zod3.z.array(uiNodeSchema).optional().describe("Action elements (buttons, links) placed at the top-right of a card header")
+}).describe("An action area positioned at the top-right of a card");
+
+// src/ui/form/schema.ts
+var import_zod4 = require("zod");
+var formSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("form"),
+  props: import_zod4.z.object({
+    id: import_zod4.z.string().describe("Unique form ID")
+  }),
+  children: import_zod4.z.array(uiNodeSchema).optional().describe("Form field components")
+}).describe("A form container. Wrap form fields inside.");
+
+// src/ui/Input/schema.ts
+var import_zod5 = require("zod");
+var inputFieldSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("input-field"),
+  props: import_zod5.z.object({
+    name: import_zod5.z.string().describe("Field name (maps to form data key)"),
+    label: import_zod5.z.string().optional().describe("Label text above the input"),
+    placeholder: import_zod5.z.string().optional().describe("Placeholder text"),
+    type: import_zod5.z.enum(["text", "email", "number", "url", "search", "tel"]).optional().describe("Input type. Defaults to 'text'"),
+    required: import_zod5.z.boolean().optional().describe("Whether the field is required"),
+    disabled: import_zod5.z.boolean().optional()
+  })
+}).describe("A text input field inside a form");
+
+// src/ui/PasswordInput/schema.ts
+var import_zod6 = require("zod");
+var passwordFieldSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("password-field"),
+  props: import_zod6.z.object({
+    name: import_zod6.z.string().describe("Field name"),
+    label: import_zod6.z.string().optional().describe("Label text"),
+    placeholder: import_zod6.z.string().optional()
+  })
+}).describe("A password input field with show/hide toggle");
+
+// src/ui/TextAreaInput/schema.ts
+var import_zod7 = require("zod");
+var textareaFieldSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("textarea-field"),
+  props: import_zod7.z.object({
+    name: import_zod7.z.string().describe("Field name"),
+    label: import_zod7.z.string().optional().describe("Label text"),
+    placeholder: import_zod7.z.string().optional(),
+    rows: import_zod7.z.number().optional().describe("Number of visible rows")
+  })
+}).describe("A multi-line text input field");
+
+// src/ui/SelectInput/schema.ts
+var import_zod8 = require("zod");
+var selectFieldSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("select-field"),
+  props: import_zod8.z.object({
+    name: import_zod8.z.string().describe("Field name"),
+    label: import_zod8.z.string().optional().describe("Label text"),
+    placeholder: import_zod8.z.string().optional(),
+    options: import_zod8.z.array(import_zod8.z.object({
+      label: import_zod8.z.string().describe("Display text"),
+      value: import_zod8.z.string().describe("Option value")
+    })).describe("Array of selectable options"),
+    required: import_zod8.z.boolean().optional()
+  })
+}).describe("A dropdown select field");
+
+// src/ui/Checkbox/schema.ts
+var import_zod9 = require("zod");
+var checkboxFieldSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("checkbox-field"),
+  props: import_zod9.z.object({
+    name: import_zod9.z.string().describe("Field name"),
+    label: import_zod9.z.string().optional().describe("Checkbox label text")
+  })
+}).describe("A checkbox field");
+
+// src/ui/Radio/schema.ts
+var import_zod10 = require("zod");
+var radioFieldSchema = import_zod10.z.object({
+  type: import_zod10.z.literal("radio-field"),
+  props: import_zod10.z.object({
+    name: import_zod10.z.string().describe("Field name"),
+    label: import_zod10.z.string().optional().describe("Group label"),
+    options: import_zod10.z.array(import_zod10.z.object({
+      label: import_zod10.z.string().describe("Option label"),
+      value: import_zod10.z.string().describe("Option value")
+    })).describe("Array of radio options")
+  })
+}).describe("A radio button group field");
+
+// src/ui/Switch/schema.ts
+var import_zod11 = require("zod");
+var switchFieldSchema = import_zod11.z.object({
+  type: import_zod11.z.literal("switch-field"),
+  props: import_zod11.z.object({
+    name: import_zod11.z.string().describe("Field name"),
+    label: import_zod11.z.string().optional().describe("Switch label")
+  })
+}).describe("A toggle switch field");
+
+// src/ui/DatePickerInput/schema.ts
+var import_zod12 = require("zod");
+var dateFieldSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("date-field"),
+  props: import_zod12.z.object({
+    name: import_zod12.z.string().describe("Field name"),
+    label: import_zod12.z.string().optional().describe("Label text"),
+    placeholder: import_zod12.z.string().optional(),
+    disablePast: import_zod12.z.boolean().optional().describe("Disable past dates"),
+    required: import_zod12.z.boolean().optional()
+  })
+}).describe("A date picker field");
+
+// src/ui/TimePicker/schema.ts
+var import_zod13 = require("zod");
+var timeFieldSchema = import_zod13.z.object({
+  type: import_zod13.z.literal("time-field"),
+  props: import_zod13.z.object({
+    name: import_zod13.z.string().describe("Field name"),
+    label: import_zod13.z.string().optional().describe("Label text")
+  })
+}).describe("A time picker field");
+
+// src/ui/Combobox/schema.ts
+var import_zod14 = require("zod");
+var comboboxFieldSchema = import_zod14.z.object({
+  type: import_zod14.z.literal("combobox-field"),
+  props: import_zod14.z.object({
+    name: import_zod14.z.string().describe("Field name"),
+    label: import_zod14.z.string().optional().describe("Label text"),
+    placeholder: import_zod14.z.string().optional(),
+    options: import_zod14.z.array(import_zod14.z.object({
+      label: import_zod14.z.string().describe("Display text"),
+      value: import_zod14.z.string().describe("Option value")
+    })).describe("Array of searchable options")
+  })
+}).describe("A searchable combobox/autocomplete field");
+
+// src/ui/MultiSelect/schema.ts
+var import_zod15 = require("zod");
+var multiSelectFieldSchema = import_zod15.z.object({
+  type: import_zod15.z.literal("multi-select-field"),
+  props: import_zod15.z.object({
+    name: import_zod15.z.string().describe("Field name"),
+    label: import_zod15.z.string().optional().describe("Label text"),
+    placeholder: import_zod15.z.string().optional(),
+    options: import_zod15.z.array(import_zod15.z.object({
+      label: import_zod15.z.string().describe("Display text"),
+      value: import_zod15.z.string().describe("Option value")
+    })).describe("Array of options for multi-selection")
+  })
+}).describe("A multi-select dropdown field");
+
+// src/ui/OTPInput/schema.ts
+var import_zod16 = require("zod");
+var otpFieldSchema = import_zod16.z.object({
+  type: import_zod16.z.literal("otp-field"),
+  props: import_zod16.z.object({
+    name: import_zod16.z.string().describe("Field name"),
+    maxLength: import_zod16.z.number().optional().describe("Number of OTP digits. Defaults to 6")
+  })
+}).describe("An OTP (one-time password) input field");
+
+// src/ui/FileUpload/schema.ts
+var import_zod17 = require("zod");
+var fileUploadFieldSchema = import_zod17.z.object({
+  type: import_zod17.z.literal("file-upload-field"),
+  props: import_zod17.z.object({
+    name: import_zod17.z.string().describe("Field name"),
+    label: import_zod17.z.string().optional().describe("Label text"),
+    isMultiple: import_zod17.z.boolean().optional().describe("Allow multiple files"),
+    maxFiles: import_zod17.z.number().optional().describe("Maximum number of files")
+  })
+}).describe("A file upload field with drag-and-drop");
+
+// src/ui/Text/schema.ts
+var import_zod18 = require("zod");
+var textSchema = import_zod18.z.object({
+  type: import_zod18.z.literal("text"),
+  props: import_zod18.z.object({
+    children: import_zod18.z.string().optional().describe("Text content")
+  }).optional(),
+  children: import_zod18.z.array(uiNodeSchema).optional()
+}).describe("A paragraph of text");
+
+// src/ui/Title/schema.ts
+var import_zod19 = require("zod");
+var titleSchema = import_zod19.z.object({
+  type: import_zod19.z.literal("title"),
+  props: import_zod19.z.object({
+    children: import_zod19.z.string().optional().describe("Heading text")
+  }).optional(),
+  children: import_zod19.z.array(uiNodeSchema).optional()
+}).describe("A heading / title element");
+
+// src/ui/Label/schema.ts
+var import_zod20 = require("zod");
+var labelSchema = import_zod20.z.object({
+  type: import_zod20.z.literal("label"),
+  props: import_zod20.z.object({
+    children: import_zod20.z.string().optional().describe("Label text"),
+    htmlFor: import_zod20.z.string().optional().describe("ID of the form element this label is for")
+  }).optional(),
+  children: import_zod20.z.array(uiNodeSchema).optional()
+}).describe("A form label element");
+
+// src/ui/Badge/schema.ts
+var import_zod21 = require("zod");
+var badgeSchema = import_zod21.z.object({
+  type: import_zod21.z.literal("badge"),
+  props: import_zod21.z.object({
+    children: import_zod21.z.string().optional().describe("Badge text"),
+    type: import_zod21.z.enum([
+      "primary-hard",
+      "primary-soft",
+      "destructive-hard",
+      "destructive-soft",
+      "secondary-hard",
+      "secondary-soft"
+    ]).optional().describe("Badge style. Defaults to 'primary-hard'"),
+    size: import_zod21.z.enum(["sm", "md"]).optional().describe("Badge size. Defaults to 'sm'"),
+    rounded: import_zod21.z.boolean().optional().describe("Fully rounded pill shape")
+  }).optional(),
+  children: import_zod21.z.array(uiNodeSchema).optional()
+}).describe("A small status badge / label");
+
+// src/ui/Tag/schema.ts
+var import_zod22 = require("zod");
+var tagSchema = import_zod22.z.object({
+  type: import_zod22.z.literal("tag"),
+  props: import_zod22.z.object({
+    label: import_zod22.z.string().describe("Tag text"),
+    variant: import_zod22.z.enum(["primary", "secondary", "destructive"]).optional().describe("Tag color variant. Defaults to 'primary'")
+  })
+}).describe("A colored tag / pill");
+
+// src/ui/Chip/schema.ts
+var import_zod23 = require("zod");
+var chipSchema = import_zod23.z.object({
+  type: import_zod23.z.literal("chip"),
+  props: import_zod23.z.object({
+    label: import_zod23.z.string().describe("Chip text"),
+    type: import_zod23.z.enum(["rounded", "rectangle"]).optional().describe("Chip shape. Defaults to 'rounded'"),
+    color: import_zod23.z.enum([
+      "slate",
+      "red",
+      "orange",
+      "amber",
+      "yellow",
+      "lime",
+      "green",
+      "emerald",
+      "teal",
+      "cyan",
+      "sky",
+      "blue",
+      "indigo",
+      "violet",
+      "purple",
+      "fuchsia",
+      "pink",
+      "rose"
+    ]).optional().describe("Chip color. Defaults to 'slate'"),
+    dot: import_zod23.z.boolean().optional().describe("Show a colored dot indicator"),
+    avatar: import_zod23.z.string().optional().describe("Avatar image URL shown inside the chip")
+  })
+}).describe("A compact chip element with optional color dot or avatar");
+
+// src/ui/Alert/schema.ts
+var import_zod24 = require("zod");
+var alertSchema = import_zod24.z.object({
+  type: import_zod24.z.literal("alert"),
+  props: import_zod24.z.object({
+    variant: import_zod24.z.enum(["default", "secondary", "destructive"]).optional().describe("Alert style. Defaults to 'default'"),
+    title: import_zod24.z.string().optional().describe("Alert heading"),
+    description: import_zod24.z.string().optional().describe("Alert body text")
+  }).optional(),
+  children: import_zod24.z.array(uiNodeSchema).optional()
+}).describe("An alert / notice banner");
+
+// src/ui/Skeleton/schema.ts
+var import_zod25 = require("zod");
+var skeletonSchema = import_zod25.z.object({
+  type: import_zod25.z.literal("skeleton"),
+  props: import_zod25.z.object({
+    className: import_zod25.z.string().optional().describe("Tailwind classes to control width/height, e.g. 'h-4 w-[250px]'")
+  }).optional()
+}).describe("A loading placeholder skeleton");
+
+// src/ui/ProgressIndicator/schema.ts
+var import_zod26 = require("zod");
+var progressIndicatorSchema = import_zod26.z.object({
+  type: import_zod26.z.literal("progress-indicator"),
+  props: import_zod26.z.object({
+    value: import_zod26.z.number().describe("Current progress value"),
+    max: import_zod26.z.number().optional().describe("Maximum value. Defaults to 100"),
+    showPercentage: import_zod26.z.boolean().optional().describe("Show percentage text. Defaults to true"),
+    variant: import_zod26.z.enum(["bar", "circle"]).optional().describe("Display style. Defaults to 'bar'")
+  })
+}).describe("A progress bar or circular progress indicator");
+
+// src/ui/Avatar/schema.ts
+var import_zod27 = require("zod");
+var avatarSchema = import_zod27.z.object({
+  type: import_zod27.z.literal("avatar"),
+  props: import_zod27.z.object({
+    variant: import_zod27.z.enum(["image", "text", "placeholder"]).describe("Avatar display mode"),
+    fallback: import_zod27.z.string().describe("Fallback text (initials) when image is unavailable"),
+    imgsrc: import_zod27.z.string().optional().describe("Image URL (required when variant is 'image')"),
+    size: import_zod27.z.enum(["xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl"]).optional().describe("Avatar size. Defaults to 'md'"),
+    status: import_zod27.z.enum(["active", "inactive"]).optional().describe("Online status indicator")
+  })
+}).describe("A user avatar displaying an image, initials, or placeholder");
+
+// src/ui/AvatarListItem/schema.ts
+var import_zod28 = require("zod");
+var avatarListItemSchema = import_zod28.z.object({
+  type: import_zod28.z.literal("avatar-list-item"),
+  props: import_zod28.z.object({
+    avatar: import_zod28.z.string().describe("Avatar image URL"),
+    name: import_zod28.z.string().describe("Display name"),
+    email: import_zod28.z.string().describe("Email address"),
+    isMe: import_zod28.z.boolean().optional().describe("Highlight as current user")
+  })
+}).describe("An avatar with name and email, typically used in lists");
+
+// src/ui/Media/schema.ts
+var import_zod29 = require("zod");
+var mediaSchema = import_zod29.z.object({
+  type: import_zod29.z.literal("media"),
+  props: import_zod29.z.object({
+    src: import_zod29.z.string().describe("Media source URL"),
+    alt: import_zod29.z.string().optional().describe("Alt text for images"),
+    type: import_zod29.z.enum(["image", "video"]).optional().describe("Media type. Defaults to 'image'"),
+    aspectRatio: import_zod29.z.enum(["1:1", "16:9", "9:16", "4:3", "3:4"]).optional().describe("Fixed aspect ratio"),
+    objectFit: import_zod29.z.enum(["cover", "contain", "fill", "scale-down", "none"]).optional().describe("How the media fills its container. Defaults to 'cover'"),
+    rounded: import_zod29.z.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]).optional().describe("Border radius"),
+    loading: import_zod29.z.enum(["lazy", "eager"]).optional().describe("Loading strategy. Defaults to 'lazy'")
+  })
+}).describe("An image or video media element");
+
+// src/ui/Grid/schema.ts
+var import_zod30 = require("zod");
+var gridSchema = import_zod30.z.object({
+  type: import_zod30.z.literal("grid"),
+  props: import_zod30.z.object({
+    className: import_zod30.z.string().optional().describe("Tailwind grid classes, e.g. 'grid-cols-2 gap-4'")
+  }).optional(),
+  children: import_zod30.z.array(uiNodeSchema).optional().describe("Grid items")
+}).describe("A CSS grid layout container");
+
+// src/ui/Accordion/schema.ts
+var import_zod31 = require("zod");
+var accordionSchema = import_zod31.z.object({
+  type: import_zod31.z.literal("accordion"),
+  props: import_zod31.z.object({
+    type: import_zod31.z.enum(["single", "multiple"]).optional().describe("Allow one or multiple items open. Defaults to 'single'"),
+    collapsible: import_zod31.z.boolean().optional().describe("Allow collapsing all items"),
+    defaultValue: import_zod31.z.union([import_zod31.z.string(), import_zod31.z.array(import_zod31.z.string())]).optional().describe("Initially open item value(s)")
+  }).optional(),
+  children: import_zod31.z.array(uiNodeSchema).optional().describe("Compose with accordion-item children")
+}).describe("A collapsible accordion container");
+var accordionItemSchema = import_zod31.z.object({
+  type: import_zod31.z.literal("accordion-item"),
+  props: import_zod31.z.object({
+    value: import_zod31.z.string().describe("Unique item identifier")
+  }),
+  children: import_zod31.z.array(uiNodeSchema).optional().describe("Place accordion-trigger and accordion-content inside")
+}).describe("A single accordion section");
+var accordionTriggerSchema = import_zod31.z.object({
+  type: import_zod31.z.literal("accordion-trigger"),
+  props: import_zod31.z.object({
+    children: import_zod31.z.string().optional().describe("Trigger label text")
+  }).optional(),
+  children: import_zod31.z.array(uiNodeSchema).optional()
+}).describe("Clickable header that toggles an accordion-item");
+var accordionContentSchema = import_zod31.z.object({
+  type: import_zod31.z.literal("accordion-content"),
+  props: import_zod31.z.object({}).optional(),
+  children: import_zod31.z.array(uiNodeSchema).optional().describe("Content revealed when the item is open")
+}).describe("Collapsible content area of an accordion-item");
+
+// src/ui/Tabs/schema.ts
+var import_zod32 = require("zod");
+var tabsSchema = import_zod32.z.object({
+  type: import_zod32.z.literal("tabs"),
+  props: import_zod32.z.object({
+    defaultActiveTab: import_zod32.z.string().describe("Value of the initially active tab"),
+    tabs: import_zod32.z.array(
+      import_zod32.z.object({
+        value: import_zod32.z.string().describe("Unique tab identifier"),
+        label: import_zod32.z.string().describe("Tab label text"),
+        count: import_zod32.z.number().optional().describe("Badge count on the tab"),
+        notification: import_zod32.z.boolean().optional().describe("Show notification dot")
+      })
+    ).describe("Tab definitions"),
+    tabSmall: import_zod32.z.boolean().optional().describe("Use compact tab styling"),
+    showContent: import_zod32.z.boolean().optional().describe("Show tab content panels. Defaults to true")
+  }),
+  children: import_zod32.z.array(uiNodeSchema).optional().describe("Tab content panels (one per tab, in order)")
+}).describe("A tabbed interface with switchable content panels");
+
+// src/ui/WrapperCard/schema.ts
+var import_zod33 = require("zod");
+var wrapperCardSchema = import_zod33.z.object({
+  type: import_zod33.z.literal("wrapper-card"),
+  props: import_zod33.z.object({}).optional(),
+  children: import_zod33.z.array(uiNodeSchema).optional().describe("Card body content")
+}).describe("A simple card wrapper with default padding and border");
+
+// src/ui/GradientContainer/schema.ts
+var import_zod34 = require("zod");
+var gradientContainerSchema = import_zod34.z.object({
+  type: import_zod34.z.literal("gradient-container"),
+  props: import_zod34.z.object({}).optional(),
+  children: import_zod34.z.array(uiNodeSchema).optional().describe("Content inside the gradient container")
+}).describe("A container with a gradient background");
+
+// src/ui/Carousel/schema.ts
+var import_zod35 = require("zod");
+var carouselSchema = import_zod35.z.object({
+  type: import_zod35.z.literal("carousel"),
+  props: import_zod35.z.object({
+    orientation: import_zod35.z.enum(["horizontal", "vertical"]).optional().describe("Scroll direction. Defaults to 'horizontal'")
+  }).optional(),
+  children: import_zod35.z.array(uiNodeSchema).optional().describe("Place a carousel-content inside")
+}).describe("A scrollable carousel container");
+var carouselContentSchema = import_zod35.z.object({
+  type: import_zod35.z.literal("carousel-content"),
+  props: import_zod35.z.object({}).optional(),
+  children: import_zod35.z.array(uiNodeSchema).optional().describe("Compose with carousel-item children")
+}).describe("Content track of a carousel");
+var carouselItemSchema = import_zod35.z.object({
+  type: import_zod35.z.literal("carousel-item"),
+  props: import_zod35.z.object({}).optional(),
+  children: import_zod35.z.array(uiNodeSchema).optional().describe("Content for this slide")
+}).describe("A single slide inside a carousel");
+
+// src/ui/Toggle/schema.ts
+var import_zod36 = require("zod");
+var toggleSchema = import_zod36.z.object({
+  type: import_zod36.z.literal("toggle"),
+  props: import_zod36.z.object({
+    active: import_zod36.z.boolean().optional().describe("Whether the toggle is pressed"),
+    shape: import_zod36.z.enum(["rectangle", "rounded"]).optional().describe("Toggle shape. Defaults to 'rectangle'"),
+    style: import_zod36.z.enum(["ghost", "outline", "soft"]).optional().describe("Visual style. Defaults to 'soft'"),
+    size: import_zod36.z.enum(["sm", "md", "lg"]).optional().describe("Toggle size. Defaults to 'sm'"),
+    disabled: import_zod36.z.boolean().optional()
+  }).optional(),
+  children: import_zod36.z.array(uiNodeSchema).optional().describe("Toggle label / content")
+}).describe("A pressable toggle button");
+
+// src/ui/Slider/schema.ts
+var import_zod37 = require("zod");
+var sliderSchema = import_zod37.z.object({
+  type: import_zod37.z.literal("slider"),
+  props: import_zod37.z.object({
+    defaultValue: import_zod37.z.union([import_zod37.z.number(), import_zod37.z.array(import_zod37.z.number())]).optional().describe("Initial value or range [min, max]"),
+    min: import_zod37.z.number().optional().describe("Minimum value. Defaults to 0"),
+    max: import_zod37.z.number().optional().describe("Maximum value. Defaults to 100"),
+    step: import_zod37.z.number().optional().describe("Step increment"),
+    disabled: import_zod37.z.boolean().optional()
+  }).optional()
+}).describe("A range slider input");
+
+// src/ui/SearchInput/schema.ts
+var import_zod38 = require("zod");
+var searchInputSchema = import_zod38.z.object({
+  type: import_zod38.z.literal("search-input"),
+  props: import_zod38.z.object({
+    searchKey: import_zod38.z.string().describe("URL query param key for the search value"),
+    placeholder: import_zod38.z.string().optional().describe("Placeholder text. Defaults to 'Search by...'"),
+    debounceDelay: import_zod38.z.number().optional().describe("Debounce delay in ms. Defaults to 500"),
+    variant: import_zod38.z.enum(["ghost", "outline"]).optional().describe("Input style variant"),
+    disabled: import_zod38.z.boolean().optional()
+  })
+}).describe("A search input with debounced query param binding");
+
+// src/ui/IconButton/schema.ts
+var import_zod39 = require("zod");
+var iconButtonSchema = import_zod39.z.object({
+  type: import_zod39.z.literal("icon-button"),
+  props: import_zod39.z.object({
+    icon: import_zod39.z.string().describe("Icon name (resolved by the renderer)"),
+    variant: import_zod39.z.enum([
+      "primary",
+      "secondary",
+      "destructive",
+      "outline",
+      "ghost",
+      "soft",
+      "ai-filled",
+      "ai-outline",
+      "glass"
+    ]).optional().describe("Button style. Defaults to 'primary'"),
+    size: import_zod39.z.enum(["xs", "sm", "md", "lg"]).optional().describe("Button size. Defaults to 'sm'"),
+    active: import_zod39.z.boolean().optional().describe("Active / pressed state"),
+    rounded: import_zod39.z.boolean().optional().describe("Fully round button"),
+    disabled: import_zod39.z.boolean().optional()
+  })
+}).describe("An icon-only action button");
+
+// src/ui/LinkButton/schema.ts
+var import_zod40 = require("zod");
+var linkButtonSchema = import_zod40.z.object({
+  type: import_zod40.z.literal("link-button"),
+  props: import_zod40.z.object({
+    href: import_zod40.z.string().describe("Link URL"),
+    children: import_zod40.z.string().optional().describe("Link text")
+  }),
+  children: import_zod40.z.array(uiNodeSchema).optional()
+}).describe("A button styled as a navigation link");
+
+// src/ui/ButtonLink/schema.ts
+var import_zod41 = require("zod");
+var buttonLinkSchema = import_zod41.z.object({
+  type: import_zod41.z.literal("button-link"),
+  props: import_zod41.z.object({
+    children: import_zod41.z.string().optional().describe("Link text"),
+    variant: import_zod41.z.enum(["link", "text-link", "error"]).optional().describe("Link style. Defaults to 'link'"),
+    href: import_zod41.z.string().optional().describe("Link URL"),
+    disabled: import_zod41.z.boolean().optional()
+  }).optional(),
+  children: import_zod41.z.array(uiNodeSchema).optional()
+}).describe("An inline text link styled as a button");
+
+// src/ui/SelectHover/schema.ts
+var import_zod42 = require("zod");
+var selectHoverSchema = import_zod42.z.object({
+  type: import_zod42.z.literal("select-hover"),
+  props: import_zod42.z.object({
+    options: import_zod42.z.array(
+      import_zod42.z.object({
+        label: import_zod42.z.string().describe("Display text"),
+        value: import_zod42.z.string().describe("Option value")
+      })
+    ).describe("Array of selectable options"),
+    placeholder: import_zod42.z.string().optional().describe("Placeholder text. Defaults to 'Select an option'"),
+    value: import_zod42.z.string().optional().describe("Currently selected value")
+  })
+}).describe("A hover-activated select dropdown");
+
+// src/ui/Breadcrumb/schema.ts
+var import_zod43 = require("zod");
+var breadcrumbSchema = import_zod43.z.object({
+  type: import_zod43.z.literal("breadcrumb"),
+  props: import_zod43.z.object({
+    items: import_zod43.z.array(
+      import_zod43.z.object({
+        label: import_zod43.z.string().describe("Breadcrumb text"),
+        href: import_zod43.z.string().optional().describe("Navigation URL"),
+        disabled: import_zod43.z.boolean().optional()
+      })
+    ).describe("Ordered list of breadcrumb segments")
+  })
+}).describe("A breadcrumb navigation trail");
+
+// src/ui/Tooltip/schema.ts
+var import_zod44 = require("zod");
+var tooltipSchema = import_zod44.z.object({
+  type: import_zod44.z.literal("tooltip"),
+  props: import_zod44.z.object({
+    content: import_zod44.z.string().describe("Tooltip text"),
+    position: import_zod44.z.enum([
+      "top",
+      "top-center",
+      "top-left",
+      "top-right",
+      "bottom",
+      "bottom-left",
+      "bottom-center",
+      "bottom-right",
+      "left",
+      "right"
+    ]).optional().describe("Tooltip placement"),
+    withArrow: import_zod44.z.boolean().optional().describe("Show an arrow pointer")
+  }),
+  children: import_zod44.z.array(uiNodeSchema).optional().describe("The trigger element the tooltip wraps")
+}).describe("A tooltip that appears on hover over its child element");
+
+// src/ui/Table/schema.ts
+var import_zod45 = require("zod");
+var tableSchema = import_zod45.z.object({
+  type: import_zod45.z.literal("table"),
+  props: import_zod45.z.object({
+    columns: import_zod45.z.array(
+      import_zod45.z.object({
+        accessorKey: import_zod45.z.string().describe("Key in the row data object"),
+        header: import_zod45.z.string().describe("Column header text")
+      })
+    ).describe("Column definitions"),
+    tableData: import_zod45.z.array(import_zod45.z.record(import_zod45.z.unknown())).describe("Array of row data objects")
+  })
+}).describe("A data table with columns and rows");
+
+// src/ui/Calendar/schema.ts
+var import_zod46 = require("zod");
+var calendarSchema = import_zod46.z.object({
+  type: import_zod46.z.literal("calendar"),
+  props: import_zod46.z.object({
+    showOutsideDays: import_zod46.z.boolean().optional().describe("Show days from adjacent months. Defaults to true"),
+    captionLayout: import_zod46.z.enum(["label", "dropdown", "dropdown-months", "dropdown-years"]).optional().describe("Caption display mode. Defaults to 'label'"),
+    buttonVariant: import_zod46.z.enum(["primary", "secondary", "outline", "destructive", "ghost", "soft"]).optional().describe("Navigation button style. Defaults to 'ghost'"),
+    mode: import_zod46.z.enum(["single", "multiple", "range"]).optional().describe("Selection mode"),
+    numberOfMonths: import_zod46.z.number().optional().describe("Number of months to display"),
+    disabled: import_zod46.z.boolean().optional()
+  }).optional()
+}).describe("A date calendar for picking dates or date ranges");
+
+// src/ui/FileInput/schema.ts
+var import_zod47 = require("zod");
+var fileInputSchema = import_zod47.z.object({
+  type: import_zod47.z.literal("file-input"),
+  props: import_zod47.z.object({
+    label: import_zod47.z.string().optional().describe("Label text above the input"),
+    helperText: import_zod47.z.string().optional().describe("Helper text below the input"),
+    error: import_zod47.z.boolean().optional().describe("Show error styling. Defaults to false"),
+    accept: import_zod47.z.string().optional().describe("Accepted file types, e.g. 'image/*,.pdf'"),
+    multiple: import_zod47.z.boolean().optional().describe("Allow multiple files. Defaults to false"),
+    disabled: import_zod47.z.boolean().optional()
+  }).optional()
+}).describe("A file input with choose-file button and upload progress");
+
+// src/ui/ToolToggle/schema.ts
+var import_zod48 = require("zod");
+var toolToggleSchema = import_zod48.z.object({
+  type: import_zod48.z.literal("tool-toggle"),
+  props: import_zod48.z.object({
+    icon: import_zod48.z.string().optional().describe("Icon name (resolved by the renderer)"),
+    dropdown: import_zod48.z.boolean().optional().describe("Show dropdown chevron")
+  }).optional()
+}).describe("A round toggle button used in toolbars, optionally with a dropdown");
+
+// src/ui/ToggleDropdownButton/schema.ts
+var import_zod49 = require("zod");
+var toggleDropdownButtonSchema = import_zod49.z.object({
+  type: import_zod49.z.literal("toggle-dropdown-button"),
+  props: import_zod49.z.object({
+    type: import_zod49.z.enum(["text", "icon"]).describe("Button content type"),
+    selected: import_zod49.z.boolean().describe("Whether the button is selected"),
+    variant: import_zod49.z.enum(["primary", "secondary", "destructive"]).describe("Button color variant")
+  })
+}).describe("A split toggle button with an attached dropdown trigger");
+
+// src/ui/IconContainer/schema.ts
+var import_zod50 = require("zod");
+var iconContainerSchema = import_zod50.z.object({
+  type: import_zod50.z.literal("icon-container"),
+  props: import_zod50.z.object({
+    icon: import_zod50.z.string().optional().describe("Icon name (resolved by the renderer)"),
+    size: import_zod50.z.enum(["xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "auto"]).optional().describe("Icon size. Defaults to 'sm'"),
+    colorInFill: import_zod50.z.boolean().optional().describe("Apply fill colors to SVG paths. Defaults to true"),
+    disableTheme: import_zod50.z.boolean().optional().describe("Disable theme-aware coloring. Defaults to false")
+  }).optional(),
+  children: import_zod50.z.array(uiNodeSchema).optional().describe("Icon element")
+}).describe("A sized container for static icons with theme-aware coloring");
+
+// src/ui/IconProfile/schema.ts
+var import_zod51 = require("zod");
+var iconProfileSchema = import_zod51.z.object({
+  type: import_zod51.z.literal("icon-profile"),
+  props: import_zod51.z.object({
+    icon: import_zod51.z.string().describe("Icon name (resolved by the renderer)"),
+    color: import_zod51.z.enum([
+      "red",
+      "orange",
+      "amber",
+      "yellow",
+      "lime",
+      "green",
+      "emerald",
+      "teal",
+      "cyan",
+      "sky",
+      "blue",
+      "indigo",
+      "violet",
+      "purple",
+      "fuchsia",
+      "pink",
+      "rose",
+      "slate"
+    ]).optional().describe("Background glow and icon color. Defaults to 'red'"),
+    size: import_zod51.z.enum(["26", "32", "40", "48", "56", "64"]).optional().describe("Size in pixels. Defaults to '64'"),
+    externalIcon: import_zod51.z.boolean().optional().describe("Whether the icon is external")
+  })
+}).describe("An icon with a colored radial glow background");
+
+// src/ui/ButtonWithTooltip/schema.ts
+var import_zod52 = require("zod");
+var buttonWithTooltipSchema = import_zod52.z.object({
+  type: import_zod52.z.literal("button-with-tooltip"),
+  props: import_zod52.z.object({
+    content: import_zod52.z.string().describe("Tooltip text"),
+    position: import_zod52.z.enum([
+      "top",
+      "top-center",
+      "top-left",
+      "top-right",
+      "bottom",
+      "bottom-left",
+      "bottom-center",
+      "bottom-right",
+      "left",
+      "right"
+    ]).optional().describe("Tooltip placement"),
+    withArrow: import_zod52.z.boolean().optional().describe("Show an arrow pointer")
+  }),
+  children: import_zod52.z.array(uiNodeSchema).optional().describe("The button element to wrap with a tooltip")
+}).describe("A button wrapped with a tooltip that appears on hover");
+
+// src/ui/Sheet/schema.ts
+var import_zod53 = require("zod");
+var sheetSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet"),
+  props: import_zod53.z.object({}).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional().describe("Compose with sheet-trigger and sheet-content")
+}).describe("A slide-out panel overlay");
+var sheetTriggerSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet-trigger"),
+  props: import_zod53.z.object({}).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional().describe("The element that opens the sheet")
+}).describe("Trigger element that opens a sheet");
+var sheetContentSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet-content"),
+  props: import_zod53.z.object({
+    side: import_zod53.z.enum(["top", "right", "bottom", "left"]).optional().describe("Slide-in direction. Defaults to 'right'"),
+    showCloseButton: import_zod53.z.boolean().optional().describe("Show close button. Defaults to true")
+  }).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional().describe("Sheet body content")
+}).describe("Content panel of a sheet");
+var sheetHeaderSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet-header"),
+  props: import_zod53.z.object({}).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional()
+}).describe("Header section of a sheet");
+var sheetFooterSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet-footer"),
+  props: import_zod53.z.object({}).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional()
+}).describe("Footer section of a sheet");
+var sheetTitleSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet-title"),
+  props: import_zod53.z.object({
+    children: import_zod53.z.string().optional().describe("Title text")
+  }).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional()
+}).describe("Title inside a sheet-header");
+var sheetDescriptionSchema = import_zod53.z.object({
+  type: import_zod53.z.literal("sheet-description"),
+  props: import_zod53.z.object({
+    children: import_zod53.z.string().optional().describe("Description text")
+  }).optional(),
+  children: import_zod53.z.array(uiNodeSchema).optional()
+}).describe("Description text inside a sheet-header");
+
+// src/ui/Dropdown/schema.ts
+var import_zod54 = require("zod");
+var dropdownMenuSchema = import_zod54.z.object({
+  type: import_zod54.z.literal("dropdown-menu"),
+  props: import_zod54.z.object({}).optional(),
+  children: import_zod54.z.array(uiNodeSchema).optional().describe("Compose with dropdown-menu-trigger and dropdown-menu-content")
+}).describe("A dropdown menu container");
+var dropdownMenuTriggerSchema = import_zod54.z.object({
+  type: import_zod54.z.literal("dropdown-menu-trigger"),
+  props: import_zod54.z.object({}).optional(),
+  children: import_zod54.z.array(uiNodeSchema).optional().describe("The element that opens the dropdown")
+}).describe("Trigger element that opens a dropdown menu");
+var dropdownMenuContentSchema = import_zod54.z.object({
+  type: import_zod54.z.literal("dropdown-menu-content"),
+  props: import_zod54.z.object({
+    side: import_zod54.z.enum(["top", "right", "bottom", "left"]).optional(),
+    align: import_zod54.z.enum(["start", "center", "end"]).optional()
+  }).optional(),
+  children: import_zod54.z.array(uiNodeSchema).optional().describe("Menu items")
+}).describe("Content panel of a dropdown menu");
+var dropdownMenuItemSchema = import_zod54.z.object({
+  type: import_zod54.z.literal("dropdown-menu-item"),
+  props: import_zod54.z.object({
+    children: import_zod54.z.string().optional().describe("Menu item text"),
+    variant: import_zod54.z.enum(["default", "destructive"]).optional().describe("Item style. Defaults to 'default'"),
+    disabled: import_zod54.z.boolean().optional()
+  }).optional(),
+  children: import_zod54.z.array(uiNodeSchema).optional()
+}).describe("A single item inside a dropdown menu");
+var dropdownMenuSeparatorSchema = import_zod54.z.object({
+  type: import_zod54.z.literal("dropdown-menu-separator"),
+  props: import_zod54.z.object({}).optional()
+}).describe("A visual separator between dropdown menu items");
+var dropdownMenuLabelSchema = import_zod54.z.object({
+  type: import_zod54.z.literal("dropdown-menu-label"),
+  props: import_zod54.z.object({
+    children: import_zod54.z.string().optional().describe("Label text")
+  }).optional(),
+  children: import_zod54.z.array(uiNodeSchema).optional()
+}).describe("A non-interactive label inside a dropdown menu");
+
+// src/ui/Popover/schema.ts
+var import_zod55 = require("zod");
+var popoverSchema = import_zod55.z.object({
+  type: import_zod55.z.literal("popover"),
+  props: import_zod55.z.object({}).optional(),
+  children: import_zod55.z.array(uiNodeSchema).optional().describe("Compose with popover-trigger and popover-content")
+}).describe("A popover overlay container");
+var popoverTriggerSchema = import_zod55.z.object({
+  type: import_zod55.z.literal("popover-trigger"),
+  props: import_zod55.z.object({}).optional(),
+  children: import_zod55.z.array(uiNodeSchema).optional().describe("The element that opens the popover")
+}).describe("Trigger element that opens a popover");
+var popoverContentSchema = import_zod55.z.object({
+  type: import_zod55.z.literal("popover-content"),
+  props: import_zod55.z.object({
+    align: import_zod55.z.enum(["start", "center", "end"]).optional().describe("Alignment relative to trigger. Defaults to 'center'"),
+    sideOffset: import_zod55.z.number().optional().describe("Offset from trigger in px. Defaults to 4")
+  }).optional(),
+  children: import_zod55.z.array(uiNodeSchema).optional().describe("Popover body content")
+}).describe("Content panel of a popover");
+
+// src/ui/ContextMenu/schema.ts
+var import_zod56 = require("zod");
+var contextMenuSchema = import_zod56.z.object({
+  type: import_zod56.z.literal("context-menu"),
+  props: import_zod56.z.object({}).optional(),
+  children: import_zod56.z.array(uiNodeSchema).optional().describe("Compose with context-menu-trigger and context-menu-content")
+}).describe("A right-click context menu container");
+var contextMenuTriggerSchema = import_zod56.z.object({
+  type: import_zod56.z.literal("context-menu-trigger"),
+  props: import_zod56.z.object({}).optional(),
+  children: import_zod56.z.array(uiNodeSchema).optional().describe("The element that triggers the context menu on right-click")
+}).describe("Trigger area for a context menu");
+var contextMenuContentSchema = import_zod56.z.object({
+  type: import_zod56.z.literal("context-menu-content"),
+  props: import_zod56.z.object({}).optional(),
+  children: import_zod56.z.array(uiNodeSchema).optional().describe("Menu items")
+}).describe("Content panel of a context menu");
+var contextMenuItemSchema = import_zod56.z.object({
+  type: import_zod56.z.literal("context-menu-item"),
+  props: import_zod56.z.object({
+    children: import_zod56.z.string().optional().describe("Menu item text"),
+    variant: import_zod56.z.enum(["default", "destructive"]).optional().describe("Item style. Defaults to 'default'"),
+    disabled: import_zod56.z.boolean().optional()
+  }).optional(),
+  children: import_zod56.z.array(uiNodeSchema).optional()
+}).describe("A single item inside a context menu");
+var contextMenuSeparatorSchema = import_zod56.z.object({
+  type: import_zod56.z.literal("context-menu-separator"),
+  props: import_zod56.z.object({}).optional()
+}).describe("A visual separator between context menu items");
+
 // src/schema.ts
 var componentSchema = component_schema_default;
 function getComponentSchemas() {
   return componentSchema.components;
 }
+var componentSchemas = {
+  button: buttonSchema,
+  "tool-button": toolButtonSchema,
+  card: cardSchema,
+  "card-header": cardHeaderSchema,
+  "card-title": cardTitleSchema,
+  "card-description": cardDescriptionSchema,
+  "card-content": cardContentSchema,
+  "card-footer": cardFooterSchema,
+  "card-action": cardActionSchema,
+  form: formSchema,
+  "input-field": inputFieldSchema,
+  "password-field": passwordFieldSchema,
+  "textarea-field": textareaFieldSchema,
+  "select-field": selectFieldSchema,
+  "checkbox-field": checkboxFieldSchema,
+  "radio-field": radioFieldSchema,
+  "switch-field": switchFieldSchema,
+  "date-field": dateFieldSchema,
+  "time-field": timeFieldSchema,
+  "combobox-field": comboboxFieldSchema,
+  "multi-select-field": multiSelectFieldSchema,
+  "otp-field": otpFieldSchema,
+  "file-upload-field": fileUploadFieldSchema,
+  text: textSchema,
+  title: titleSchema,
+  label: labelSchema,
+  badge: badgeSchema,
+  tag: tagSchema,
+  chip: chipSchema,
+  alert: alertSchema,
+  skeleton: skeletonSchema,
+  "progress-indicator": progressIndicatorSchema,
+  avatar: avatarSchema,
+  "avatar-list-item": avatarListItemSchema,
+  media: mediaSchema,
+  grid: gridSchema,
+  accordion: accordionSchema,
+  "accordion-item": accordionItemSchema,
+  "accordion-trigger": accordionTriggerSchema,
+  "accordion-content": accordionContentSchema,
+  tabs: tabsSchema,
+  "wrapper-card": wrapperCardSchema,
+  "gradient-container": gradientContainerSchema,
+  carousel: carouselSchema,
+  "carousel-content": carouselContentSchema,
+  "carousel-item": carouselItemSchema,
+  toggle: toggleSchema,
+  slider: sliderSchema,
+  "search-input": searchInputSchema,
+  "icon-button": iconButtonSchema,
+  "link-button": linkButtonSchema,
+  "button-link": buttonLinkSchema,
+  "select-hover": selectHoverSchema,
+  breadcrumb: breadcrumbSchema,
+  tooltip: tooltipSchema,
+  table: tableSchema,
+  calendar: calendarSchema,
+  "file-input": fileInputSchema,
+  "tool-toggle": toolToggleSchema,
+  "toggle-dropdown-button": toggleDropdownButtonSchema,
+  "icon-container": iconContainerSchema,
+  "icon-profile": iconProfileSchema,
+  "button-with-tooltip": buttonWithTooltipSchema,
+  sheet: sheetSchema,
+  "sheet-trigger": sheetTriggerSchema,
+  "sheet-content": sheetContentSchema,
+  "sheet-header": sheetHeaderSchema,
+  "sheet-footer": sheetFooterSchema,
+  "sheet-title": sheetTitleSchema,
+  "sheet-description": sheetDescriptionSchema,
+  "dropdown-menu": dropdownMenuSchema,
+  "dropdown-menu-trigger": dropdownMenuTriggerSchema,
+  "dropdown-menu-content": dropdownMenuContentSchema,
+  "dropdown-menu-item": dropdownMenuItemSchema,
+  "dropdown-menu-separator": dropdownMenuSeparatorSchema,
+  "dropdown-menu-label": dropdownMenuLabelSchema,
+  popover: popoverSchema,
+  "popover-trigger": popoverTriggerSchema,
+  "popover-content": popoverContentSchema,
+  "context-menu": contextMenuSchema,
+  "context-menu-trigger": contextMenuTriggerSchema,
+  "context-menu-content": contextMenuContentSchema,
+  "context-menu-item": contextMenuItemSchema,
+  "context-menu-separator": contextMenuSeparatorSchema
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  accordionContentSchema,
+  accordionItemSchema,
+  accordionSchema,
+  accordionTriggerSchema,
+  alertSchema,
+  avatarListItemSchema,
+  avatarSchema,
+  badgeSchema,
+  breadcrumbSchema,
+  buttonLinkSchema,
+  buttonSchema,
+  buttonWithTooltipSchema,
+  calendarSchema,
+  cardActionSchema,
+  cardContentSchema,
+  cardDescriptionSchema,
+  cardFooterSchema,
+  cardHeaderSchema,
+  cardSchema,
+  cardTitleSchema,
+  carouselContentSchema,
+  carouselItemSchema,
+  carouselSchema,
+  checkboxFieldSchema,
+  chipSchema,
+  comboboxFieldSchema,
   componentSchema,
-  getComponentSchemas
+  componentSchemas,
+  contextMenuContentSchema,
+  contextMenuItemSchema,
+  contextMenuSchema,
+  contextMenuSeparatorSchema,
+  contextMenuTriggerSchema,
+  dateFieldSchema,
+  dropdownMenuContentSchema,
+  dropdownMenuItemSchema,
+  dropdownMenuLabelSchema,
+  dropdownMenuSchema,
+  dropdownMenuSeparatorSchema,
+  dropdownMenuTriggerSchema,
+  fileInputSchema,
+  fileUploadFieldSchema,
+  formSchema,
+  getComponentSchemas,
+  gradientContainerSchema,
+  gridSchema,
+  iconButtonSchema,
+  iconContainerSchema,
+  iconProfileSchema,
+  inputFieldSchema,
+  labelSchema,
+  linkButtonSchema,
+  mediaSchema,
+  multiSelectFieldSchema,
+  otpFieldSchema,
+  passwordFieldSchema,
+  popoverContentSchema,
+  popoverSchema,
+  popoverTriggerSchema,
+  progressIndicatorSchema,
+  radioFieldSchema,
+  searchInputSchema,
+  selectFieldSchema,
+  selectHoverSchema,
+  sheetContentSchema,
+  sheetDescriptionSchema,
+  sheetFooterSchema,
+  sheetHeaderSchema,
+  sheetSchema,
+  sheetTitleSchema,
+  sheetTriggerSchema,
+  skeletonSchema,
+  sliderSchema,
+  switchFieldSchema,
+  tableSchema,
+  tabsSchema,
+  tagSchema,
+  textSchema,
+  textareaFieldSchema,
+  timeFieldSchema,
+  titleSchema,
+  toggleDropdownButtonSchema,
+  toggleSchema,
+  toolButtonSchema,
+  toolToggleSchema,
+  tooltipSchema,
+  uiNodeSchema,
+  wrapperCardSchema
 });
 //# sourceMappingURL=schema.cjs.map