@ktbsh/ui 0.1.0

package/dist/react/modal.d.ts

@@ -0,0 +1,18 @@
+
+import * as React from 'react';
+
+export interface KitbashModalProps extends React.HTMLAttributes<HTMLElement> {
+  'open'?: boolean;
+  'title'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-modal': KitbashModalProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashModal: React.ForwardRefExoticComponent<KitbashModalProps & React.RefAttributes<HTMLElement>>;

package/dist/react/modal.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/modal.js';
+
+export const KitbashModal = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-modal', { ref: setRefs, ...props }, children);
+});

package/dist/react/nav.d.ts

@@ -0,0 +1,17 @@
+
+import * as React from 'react';
+
+export interface KitbashNavProps extends React.HTMLAttributes<HTMLElement> {
+  'label'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-nav': KitbashNavProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashNav: React.ForwardRefExoticComponent<KitbashNavProps & React.RefAttributes<HTMLElement>>;

package/dist/react/nav.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/nav.js';
+
+export const KitbashNav = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-nav', { ref: setRefs, ...props }, children);
+});

package/dist/react/pagination.d.ts

@@ -0,0 +1,19 @@
+
+import * as React from 'react';
+
+export interface KitbashPaginationProps extends React.HTMLAttributes<HTMLElement> {
+  'page'?: number;
+  'total'?: number;
+  'label'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-pagination': KitbashPaginationProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashPagination: React.ForwardRefExoticComponent<KitbashPaginationProps & React.RefAttributes<HTMLElement>>;

package/dist/react/pagination.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/pagination.js';
+
+export const KitbashPagination = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-pagination', { ref: setRefs, ...props }, children);
+});

package/dist/react/progress.d.ts

@@ -0,0 +1,19 @@
+
+import * as React from 'react';
+
+export interface KitbashProgressProps extends React.HTMLAttributes<HTMLElement> {
+  'value'?: number;
+  'max'?: number;
+  'label'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-progress': KitbashProgressProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashProgress: React.ForwardRefExoticComponent<KitbashProgressProps & React.RefAttributes<HTMLElement>>;

package/dist/react/progress.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/progress.js';
+
+export const KitbashProgress = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-progress', { ref: setRefs, ...props }, children);
+});

package/dist/react/radio.d.ts

@@ -0,0 +1,22 @@
+
+import * as React from 'react';
+
+export interface KitbashRadioProps extends React.HTMLAttributes<HTMLElement> {
+  'name'?: string;
+  'value'?: string;
+  'checked'?: boolean;
+  'disabled'?: boolean;
+  'required'?: boolean;
+  'invalid'?: boolean;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-radio': KitbashRadioProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashRadio: React.ForwardRefExoticComponent<KitbashRadioProps & React.RefAttributes<HTMLElement>>;

package/dist/react/radio.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/radio.js';
+
+export const KitbashRadio = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-radio', { ref: setRefs, ...props }, children);
+});

package/dist/react/select.d.ts

@@ -0,0 +1,22 @@
+
+import * as React from 'react';
+
+export interface KitbashSelectProps extends React.HTMLAttributes<HTMLElement> {
+  'name'?: string;
+  'value'?: string;
+  'disabled'?: boolean;
+  'required'?: boolean;
+  'invalid'?: boolean;
+  'size'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-select': KitbashSelectProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashSelect: React.ForwardRefExoticComponent<KitbashSelectProps & React.RefAttributes<HTMLElement>>;

package/dist/react/select.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/select.js';
+
+export const KitbashSelect = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-select', { ref: setRefs, ...props }, children);
+});

package/dist/react/skeleton.d.ts

@@ -0,0 +1,19 @@
+
+import * as React from 'react';
+
+export interface KitbashSkeletonProps extends React.HTMLAttributes<HTMLElement> {
+  'variant'?: string;
+  'width'?: string;
+  'height'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-skeleton': KitbashSkeletonProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashSkeleton: React.ForwardRefExoticComponent<KitbashSkeletonProps & React.RefAttributes<HTMLElement>>;

package/dist/react/skeleton.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/skeleton.js';
+
+export const KitbashSkeleton = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-skeleton', { ref: setRefs, ...props }, children);
+});

package/dist/react/spinner.d.ts

@@ -0,0 +1,18 @@
+
+import * as React from 'react';
+
+export interface KitbashSpinnerProps extends React.HTMLAttributes<HTMLElement> {
+  'size'?: string;
+  'label'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-spinner': KitbashSpinnerProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashSpinner: React.ForwardRefExoticComponent<KitbashSpinnerProps & React.RefAttributes<HTMLElement>>;

package/dist/react/spinner.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/spinner.js';
+
+export const KitbashSpinner = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-spinner', { ref: setRefs, ...props }, children);
+});

package/dist/react/stack.d.ts

@@ -0,0 +1,21 @@
+
+import * as React from 'react';
+
+export interface KitbashStackProps extends React.HTMLAttributes<HTMLElement> {
+  'direction'?: string;
+  'gap'?: string;
+  'align'?: string;
+  'justify'?: string;
+  'wrap'?: boolean;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-stack': KitbashStackProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashStack: React.ForwardRefExoticComponent<KitbashStackProps & React.RefAttributes<HTMLElement>>;

package/dist/react/stack.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/stack.js';
+
+export const KitbashStack = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-stack', { ref: setRefs, ...props }, children);
+});

package/dist/react/switch.d.ts

@@ -0,0 +1,21 @@
+
+import * as React from 'react';
+
+export interface KitbashSwitchProps extends React.HTMLAttributes<HTMLElement> {
+  'name'?: string;
+  'value'?: string;
+  'checked'?: boolean;
+  'disabled'?: boolean;
+  'invalid'?: boolean;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-switch': KitbashSwitchProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashSwitch: React.ForwardRefExoticComponent<KitbashSwitchProps & React.RefAttributes<HTMLElement>>;

package/dist/react/switch.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/switch.js';
+
+export const KitbashSwitch = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-switch', { ref: setRefs, ...props }, children);
+});

package/dist/react/tab-panel.d.ts

@@ -0,0 +1,18 @@
+
+import * as React from 'react';
+
+export interface KitbashTabPanelProps extends React.HTMLAttributes<HTMLElement> {
+  'value'?: string;
+  'open'?: boolean;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-tab-panel': KitbashTabPanelProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashTabPanel: React.ForwardRefExoticComponent<KitbashTabPanelProps & React.RefAttributes<HTMLElement>>;

package/dist/react/tab-panel.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/tab-panel.js';
+
+export const KitbashTabPanel = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-tab-panel', { ref: setRefs, ...props }, children);
+});

package/dist/react/tab.d.ts

@@ -0,0 +1,19 @@
+
+import * as React from 'react';
+
+export interface KitbashTabProps extends React.HTMLAttributes<HTMLElement> {
+  'value'?: string;
+  'selected'?: boolean;
+  'disabled'?: boolean;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-tab': KitbashTabProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashTab: React.ForwardRefExoticComponent<KitbashTabProps & React.RefAttributes<HTMLElement>>;

package/dist/react/tab.js

@@ -0,0 +1,30 @@
+
+import * as React from 'react';
+import '../vanilla/tab.js';
+
+export const KitbashTab = React.forwardRef(({ children, onKitbashChange, ...props }, ref) => {
+  const innerRef = React.useRef(null);
+
+  // kitbash-change is a CustomEvent — bridge manually. Native events (onClick, etc.)
+  // stay on ...props so React 19 binds them once (no double-fire).
+  React.useEffect(() => {
+    const el = innerRef.current;
+    if (!el || !onKitbashChange) return;
+
+    const handleCustomChange = (e) => onKitbashChange(e);
+    el.addEventListener('kitbash-change', handleCustomChange);
+    return () => el.removeEventListener('kitbash-change', handleCustomChange);
+  }, [onKitbashChange]);
+
+  // Callback ref: assign + clear on unmount / ref change (object + function refs).
+  const setRefs = React.useCallback((node) => {
+    innerRef.current = node;
+    if (typeof ref === 'function') {
+      ref(node);
+    } else if (ref && typeof ref === 'object') {
+      ref.current = node;
+    }
+  }, [ref]);
+
+  return React.createElement('kitbash-tab', { ref: setRefs, ...props }, children);
+});

package/dist/react/tabs.d.ts

@@ -0,0 +1,17 @@
+
+import * as React from 'react';
+
+export interface KitbashTabsProps extends React.HTMLAttributes<HTMLElement> {
+  'label'?: string;
+  onKitbashChange?: (event: CustomEvent<{ props: Record<string, unknown>; state: Record<string, unknown> }>) => void;
+}
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'kitbash-tabs': KitbashTabsProps & React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    }
+  }
+}
+
+export declare const KitbashTabs: React.ForwardRefExoticComponent<KitbashTabsProps & React.RefAttributes<HTMLElement>>;