kosmio 0.1.0

package/types/ui.d.ts

@@ -0,0 +1,875 @@
+import type {
+  ButtonHTMLAttributes,
+  CSSProperties,
+  ElementType,
+  HTMLAttributes,
+  ImgHTMLAttributes,
+  InputHTMLAttributes,
+  LabelHTMLAttributes,
+  MouseEventHandler,
+  ReactNode,
+  Ref,
+} from "react";
+
+export type ButtonVariant = "plain" | "primary" | string;
+export type TextSize = "xxxl" | "xxl" | "xl" | "lg" | "md" | "sm" | "xs" | "xxs" | `text-${string}`;
+export type TextColor = string;
+export type TextFont = "default" | "main" | "mono" | `text-font-${string}`;
+export type TextWeight = "regular" | "medium" | "semibold" | "bold" | `text-weight-${string}`;
+export type TextLineHeight = "none" | "tight" | "normal" | "relaxed" | `text-leading-${string}`;
+export type TextAlignment =
+  | "start"
+  | "center"
+  | "end"
+  | "left"
+  | "right"
+  | "justify"
+  | `kosmio-text-align-${string}`;
+export type SelectOptionValue = string | number;
+
+export interface BorderStyleDefinition {
+  color: string;
+  size: string;
+}
+
+export interface TypoStyleDefinition {
+  font?: TextFont | string;
+  fontSize: TextSize | string;
+  fontColor: TextColor;
+  weight: TextWeight | string;
+  lineHeight: TextLineHeight | string;
+  as?: ElementType;
+}
+
+export interface ContainerStyleDefinition {
+  borderStyle: BorderStyleDefinition;
+  typoStyle: TypoStyleDefinition;
+  backgroundColor: string;
+  padding: string;
+  radii: string;
+}
+
+export function BorderStyle(color: string, size: string): BorderStyleDefinition;
+export function TypoStyle(
+  fontSize: TextSize | string,
+  fontColor: TextColor,
+  weight: TextWeight | string,
+  lineHeight: TextLineHeight | string,
+  as?: ElementType
+): TypoStyleDefinition;
+export function ContainerStyle(
+  borderStyle: BorderStyleDefinition,
+  typoStyle: TypoStyleDefinition,
+  backgroundColor: string,
+  padding: string,
+  radii: string
+): ContainerStyleDefinition;
+
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  as?: ElementType;
+  variant?: ButtonVariant;
+  danger?: boolean;
+  active?: boolean;
+  showTooltip?: boolean;
+  tooltipText?: string;
+  tooltipDirection?: "left" | "right";
+}
+
+export const BUTTON_VARIANTS: Record<string, string>;
+export const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLElement>>;
+export default Button;
+
+export interface ActionButtonProps extends Omit<ButtonProps, "children"> {
+  text?: ReactNode;
+  icon?: ReactNode;
+  iconPosition?: "start" | "end";
+}
+
+export function ActionButton(props: ActionButtonProps): import("react").JSX.Element;
+
+export interface FloatingActionButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  icon?: ReactNode;
+  label: string;
+  compact?: boolean;
+}
+
+export const FloatingActionButton: import("react").ForwardRefExoticComponent<
+  FloatingActionButtonProps & import("react").RefAttributes<HTMLButtonElement>
+>;
+
+export interface SelectionButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "title"> {
+  icon?: ReactNode;
+  title?: ReactNode;
+  subtitle?: ReactNode;
+  selectedLabel?: ReactNode;
+  isSelectable?: boolean;
+  isSelected?: boolean;
+}
+
+export const SelectionButton: import("react").ForwardRefExoticComponent<
+  SelectionButtonProps & import("react").RefAttributes<HTMLButtonElement>
+>;
+
+export type IconVariant = "default" | "static" | "reversed" | "reversedDynamic" | "accent" | "invalid" | string;
+export type IconSize = "xxs" | "xs" | "sm" | "md" | "xmd" | "lg" | "xl" | "xxl" | "xxxl" | string;
+
+export interface IconProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "size"> {
+  src: string;
+  variant?: IconVariant;
+  size?: IconSize;
+  decorative?: boolean;
+}
+
+export const Icon: import("react").ForwardRefExoticComponent<IconProps & import("react").RefAttributes<HTMLElement>>;
+
+export interface IconChevronProps extends HTMLAttributes<HTMLSpanElement> {
+  colored?: boolean;
+  size?: IconSize;
+  isOpen?: boolean;
+}
+
+export function IconChevron(props: IconChevronProps): import("react").JSX.Element;
+
+export interface IconDefinition {
+  src: string;
+  alt?: string;
+  altKey?: string;
+  size?: IconSize;
+  variant?: IconVariant;
+}
+
+export interface IconComponentProps extends Omit<IconProps, "src"> {
+  name: string;
+  translateAlt?: (key: string) => string;
+}
+
+export function createIconComponent(
+  icons: Record<string, IconDefinition>,
+  defaultVariant?: IconVariant
+): (props: IconComponentProps) => import("react").JSX.Element | null;
+
+export interface TextProps extends Omit<HTMLAttributes<HTMLElement>, "color"> {
+  as?: ElementType;
+  color?: TextColor;
+  dynamic?: boolean;
+  size?: TextSize;
+  font?: TextFont;
+  weight?: TextWeight;
+  lineHeight?: TextLineHeight;
+  align?: TextAlignment;
+  left?: boolean;
+  center?: boolean;
+  right?: boolean;
+  inline?: boolean;
+  ellipsis?: boolean;
+  elipsis?: boolean;
+}
+
+export const TEXT_ALIGNMENTS: Record<string, string>;
+export const TEXT_FONTS: Record<string, string>;
+export const TEXT_LINE_HEIGHTS: Record<string, string>;
+export const TEXT_SIZES: Record<string, string>;
+export const TEXT_WEIGHTS: Record<string, string>;
+export function createTextStyle(
+  font?: TextFont,
+  weight?: TextWeight,
+  size?: TextSize,
+  lineHeight?: TextLineHeight
+): string;
+export function createTypo(
+  typoStyle?: TypoStyleDefinition,
+  as?: ElementType,
+  color?: TextColor,
+  defaultClassName?: string
+): import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<HTMLElement>> & {
+  defaultPropsConfig?: {
+    typoStyle?: TypoStyleDefinition;
+    as?: ElementType;
+    color?: TextColor;
+    className?: string;
+  };
+};
+export type TypoDefinition =
+  | TypoStyleDefinition
+  | [
+  typoStyle?: TypoStyleDefinition,
+  color?: TextColor,
+  defaultClassName?: string
+];
+export function createTypos(
+  typoDefinitions?: TypoDefinition[]
+): Array<import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<HTMLElement>>>;
+export const Text: import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<HTMLElement>>;
+
+export interface TagProps extends HTMLAttributes<HTMLSpanElement> {
+  text?: ReactNode;
+  color?: string;
+}
+
+export function Tag(props: TagProps): import("react").JSX.Element;
+export function ColorTag(props: TagProps): import("react").JSX.Element;
+
+export interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+  variant?: "plain" | string;
+  format?: RegExp | string;
+  isValid?: (value: string, event: import("react").ChangeEvent<HTMLInputElement>) => boolean;
+  invalid?: boolean;
+  onValueChange?: (value: string, event: import("react").ChangeEvent<HTMLInputElement>) => void;
+}
+
+export const INPUT_VARIANTS: Record<string, string>;
+export const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+
+export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+  variant?: "plain" | "custom" | string;
+  containerClassName?: string;
+  labelClassName?: string;
+  markClassName?: string;
+  textClassName?: string;
+  label?: ReactNode;
+  onCheckedChange?: (checked: boolean, event: import("react").ChangeEvent<HTMLInputElement>) => void;
+}
+
+export const CHECKBOX_VARIANTS: Record<string, string>;
+export const Checkbox: import("react").ForwardRefExoticComponent<
+  CheckboxProps & import("react").RefAttributes<HTMLInputElement>
+>;
+
+export interface SearchbarProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+  variant?: "plain" | "full" | string;
+  onValueChange?: (value: string, event: import("react").ChangeEvent<HTMLInputElement>) => void;
+  onSearch?: (value: string) => void;
+  searchButtonType?: "button" | "submit" | "reset";
+  searchButtonLabel?: string;
+  searchIcon?: ReactNode;
+  inputRef?: Ref<HTMLInputElement>;
+}
+
+export const SEARCHBAR_VARIANTS: Record<string, string>;
+export const Searchbar: import("react").ForwardRefExoticComponent<
+  SearchbarProps & import("react").RefAttributes<HTMLDivElement>
+>;
+
+export interface SelectOption {
+  value: SelectOptionValue;
+  label?: ReactNode;
+  disabled?: boolean;
+  className?: string;
+}
+
+export interface SelectChangeEvent {
+  target: {
+    name?: string;
+    value: SelectOptionValue;
+  };
+  currentTarget: {
+    name?: string;
+    value: SelectOptionValue;
+  };
+}
+
+export interface SelectProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+  variant?: "plain" | string;
+  options?: Array<SelectOption | SelectOptionValue>;
+  searchable?: boolean;
+  placeholder?: string;
+  searchPlaceholder?: string;
+  searchIcon?: ReactNode;
+  searchLabel?: ReactNode;
+  emptyLabel?: ReactNode;
+  closeLabel?: string;
+  selectOptionLabel?: string;
+  value?: SelectOptionValue;
+  defaultValue?: SelectOptionValue;
+  disabled?: boolean;
+  required?: boolean;
+  name?: string;
+  onChange?: (event: SelectChangeEvent) => void;
+  onValueChange?: (value: SelectOptionValue, event: SelectChangeEvent) => void;
+}
+
+export const SELECT_VARIANTS: Record<string, string>;
+export const Select: import("react").ForwardRefExoticComponent<
+  SelectProps & import("react").RefAttributes<HTMLButtonElement>
+>;
+
+export interface FormInputProps extends Omit<InputProps, "onChange" | "onValueChange"> {
+  label?: ReactNode;
+  validations?: Record<string, unknown>;
+  labelClassName?: string;
+  fieldClassName?: string;
+  invalid?: boolean;
+  invalidLabel?: ReactNode;
+  requiredLabel?: ReactNode;
+  onChange?: (value: string, event: import("react").ChangeEvent<HTMLInputElement>) => void;
+}
+
+export const FormInput: import("react").ForwardRefExoticComponent<
+  FormInputProps & import("react").RefAttributes<HTMLInputElement>
+>;
+
+export interface FormSelectProps extends Omit<SelectProps, "onChange" | "onValueChange"> {
+  label?: ReactNode;
+  labelClassName?: string;
+  fieldClassName?: string;
+  requiredLabel?: ReactNode;
+  selectOptionLabel?: string;
+  onChange?: (value: SelectOptionValue, event: SelectChangeEvent) => void;
+}
+
+export function FormSelect(props: FormSelectProps): import("react").JSX.Element;
+
+export interface FormCheckboxProps extends Omit<CheckboxProps, "onChange"> {
+  label?: ReactNode;
+  labelClassName?: string;
+  fieldClassName?: string;
+  requiredLabel?: ReactNode;
+  onChange?: (checked: boolean, event: import("react").ChangeEvent<HTMLInputElement>) => void;
+}
+
+export function FormCheckbox(props: FormCheckboxProps): import("react").JSX.Element;
+
+export type GeneratorInputComponent =
+  | ReactNode
+  | ((text: string, index: number) => ReactNode);
+
+export interface GeneratorInputChangePayload {
+  texts: string[];
+  components: ReactNode[];
+}
+
+export interface GeneratorInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange"> {
+  label?: ReactNode;
+  value?: string[];
+  defaultValue?: string[];
+  onChange?: (value: string[]) => void;
+  onGeneratedChange?: (payload: GeneratorInputChangePayload) => void;
+  component?: GeneratorInputComponent;
+  className?: string;
+  labelClassName?: string;
+  fieldClassName?: string;
+  inputClassName?: string;
+}
+
+export function GeneratorInput(props: GeneratorInputProps): import("react").JSX.Element;
+
+export interface EnumOptionDefinition {
+  value: SelectOptionValue;
+  label?: ReactNode;
+  labelKey?: string;
+  icon?: string;
+  iconName?: string;
+  iconVariant?: IconVariant;
+  iconSize?: IconSize;
+  className?: string;
+  [key: string]: unknown;
+}
+
+export interface EnumOptionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onSelect"> {
+  option: EnumOptionDefinition;
+  selected?: boolean;
+  onSelect?: (option: EnumOptionDefinition, event: import("react").MouseEvent<HTMLButtonElement>) => void;
+  renderIcon?: (option: EnumOptionDefinition) => ReactNode;
+}
+
+export function EnumOption(props: EnumOptionProps): import("react").JSX.Element;
+
+export interface EnumSelectorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "translate"> {
+  enumValues?: Array<EnumOptionDefinition | SelectOptionValue> | Record<string, EnumOptionDefinition | SelectOptionValue>;
+  selectedValue?: SelectOptionValue | null;
+  onValueChange?: (value: SelectOptionValue, option: EnumOptionDefinition) => void;
+  translationKeyPrefix?: string;
+  getIcon?: (value: SelectOptionValue, option: EnumOptionDefinition) => string | undefined;
+  getLabel?: (value: SelectOptionValue, translate: (key: string) => string, option: EnumOptionDefinition) => ReactNode;
+  renderIcon?: (option: EnumOptionDefinition) => ReactNode;
+  translate?: (key: string) => string;
+  isOptionVisible?: (value: SelectOptionValue, option: EnumOptionDefinition) => boolean;
+  optionClassName?: string;
+  ariaLabel?: string;
+}
+
+export function EnumSelector(props: EnumSelectorProps): import("react").JSX.Element;
+
+export interface CardProps extends HTMLAttributes<HTMLDivElement> {}
+export function Card(props: CardProps): import("react").JSX.Element;
+
+export interface ContainerProps extends HTMLAttributes<HTMLElement> {
+  as?: ElementType;
+  containerStyle?: ContainerStyleDefinition;
+}
+
+export const Container: import("react").ForwardRefExoticComponent<
+  ContainerProps & import("react").RefAttributes<HTMLElement>
+>;
+export function createContainer(
+  containerStyle?: ContainerStyleDefinition,
+  as?: ElementType,
+  defaultClassName?: string
+): import("react").ForwardRefExoticComponent<ContainerProps & import("react").RefAttributes<HTMLElement>> & {
+  defaultPropsConfig?: {
+    containerStyle?: ContainerStyleDefinition;
+    as?: ElementType;
+    className?: string;
+  };
+};
+export type ContainerDefinition =
+  | ContainerStyleDefinition
+  | [
+  containerStyle?: ContainerStyleDefinition,
+  as?: ElementType,
+  defaultClassName?: string
+];
+export function createContainers(
+  containerDefinitions?: ContainerDefinition[]
+): Array<import("react").ForwardRefExoticComponent<ContainerProps & import("react").RefAttributes<HTMLElement>>>;
+
+export interface PageProps extends HTMLAttributes<HTMLElement> {
+  formLauncher?: unknown;
+  showOperationsShortcut?: boolean;
+  showContentCard?: boolean;
+  fullsize?: boolean;
+}
+
+export function Page(props: PageProps): import("react").JSX.Element;
+
+export interface NavItemConfig {
+  id?: string;
+  name?: ReactNode;
+  label?: ReactNode;
+  url?: string;
+  to?: string;
+  path?: string;
+  routeKey?: string;
+  activeRoutes?: string[];
+  icon?: ReactNode;
+  iconSelected?: ReactNode;
+  iconName?: string;
+  iconSelectedName?: string;
+  badge?: ReactNode;
+  className?: string;
+  active?: boolean;
+  isActive?: (pathname: string, item: NavItem) => boolean;
+  onClick?: (...args: unknown[]) => unknown;
+}
+
+export class NavItem {
+  id?: string;
+  name?: ReactNode;
+  label?: ReactNode;
+  url?: string;
+  to?: string;
+  path?: string;
+  routeKey?: string;
+  activeRoutes: string[];
+  icon?: ReactNode;
+  iconSelected?: ReactNode;
+  iconName?: string;
+  iconSelectedName?: string;
+  badge?: ReactNode;
+  className?: string;
+  active?: boolean;
+  isActive?: (pathname: string, item: NavItem) => boolean;
+  onClick?: (...args: unknown[]) => unknown;
+  constructor(config?: NavItemConfig);
+  matches(pathname: string): boolean;
+  static from(data?: NavItemConfig | NavItem): NavItem;
+}
+
+export interface SidebarNavProps extends HTMLAttributes<HTMLElement> {
+  navItems?: Array<NavItemConfig | NavItem>;
+  NavItemComponent?: (props: { navItem: NavItem; active: boolean }) => ReactNode;
+  pathname?: string;
+}
+
+export function SidebarNav(props: SidebarNavProps): import("react").JSX.Element | null;
+
+export type MobileRouteTransitionDirection = "forward" | "back";
+
+export interface MobileRouteTransitionContext {
+  pathname: string;
+  navigationType?: string;
+  routeMatch?: unknown;
+}
+
+export interface MobileRouteTransitionRule {
+  id?: string;
+  routeKey?: string;
+  pathname?: string;
+  enabled?: boolean;
+  durationMs?: number;
+  enterClassName?: string;
+  exitClassName?: string;
+  match?: (context: MobileRouteTransitionContext) => boolean;
+}
+
+export interface MobileRouteTransitionResult {
+  enabled: boolean;
+  durationMs: number | null;
+  routeMatch?: unknown;
+  direction: MobileRouteTransitionDirection;
+  enterClassName: string;
+  exitClassName: string;
+}
+
+export interface ResolveMobileRouteTransitionOptions {
+  pathname: string;
+  navigationType?: string;
+  directionHint?: MobileRouteTransitionDirection;
+  previousPathname?: string | null;
+  rules?: MobileRouteTransitionRule[];
+  matchRoute?: (pathname: string) => unknown;
+  defaultTransition?: Partial<MobileRouteTransitionRule>;
+}
+
+export const DEFAULT_MOBILE_ROUTE_TRANSITION_STATE_KEY: string;
+export function resolveMobileRouteTransition(options: ResolveMobileRouteTransitionOptions): MobileRouteTransitionResult;
+
+export interface MobileRouteTransitionProps extends HTMLAttributes<HTMLDivElement> {
+  outlet?: ReactNode;
+  location?: {
+    key?: string;
+    pathname?: string;
+    state?: Record<string, unknown> | null;
+  };
+  navigationType?: string;
+  isMobile?: boolean;
+  rules?: MobileRouteTransitionRule[];
+  router?: {
+    matchLocalizedRoute?: (pathname: string) => unknown;
+  };
+  matchRoute?: (pathname: string) => unknown;
+  stateKey?: string;
+  defaultTransition?: Partial<MobileRouteTransitionRule>;
+  layerClassName?: string;
+}
+
+export function MobileRouteTransition(props: MobileRouteTransitionProps): import("react").JSX.Element;
+
+export interface NativeBackButtonHandlerProps {
+  app?: {
+    addListener?: (
+      eventName: "backButton",
+      listenerFunc: (event: { canGoBack?: boolean }) => void
+    ) => Promise<{ remove?: () => void | Promise<void> }>;
+  };
+  isNative?: boolean;
+  router?: {
+    matchLocalizedRoute?: (pathname: string) => { routeKey?: string } | null;
+  };
+  mainRouteKeys?: Iterable<string>;
+  transitionStateKey?: string;
+  closeableSelectSelectors?: string[];
+  selectSheetBackdropSelector?: string;
+  selectDropdownSelector?: string;
+  closeableOverlaySelectors?: string[];
+}
+
+export function NativeBackButtonHandler(props: NativeBackButtonHandlerProps): null;
+
+export interface AppearChildrenProps {
+  children?: ReactNode;
+}
+
+export function AppearChildren(props: AppearChildrenProps): ReactNode;
+
+export interface ClickableProps extends ButtonHTMLAttributes<HTMLButtonElement> {}
+export const Clickable: import("react").ForwardRefExoticComponent<
+  ClickableProps & import("react").RefAttributes<HTMLButtonElement>
+>;
+
+export interface CollapsibleBoxProps extends HTMLAttributes<HTMLDivElement> {
+  titleBox?: ReactNode | ((isExpanded: boolean) => ReactNode);
+  defaultExpanded?: boolean;
+}
+
+export function CollapsibleBox(props: CollapsibleBoxProps): import("react").JSX.Element;
+
+export interface CollapsibleCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+  title?: ReactNode;
+  defaultExpanded?: boolean;
+}
+
+export function CollapsibleCard(props: CollapsibleCardProps): import("react").JSX.Element;
+
+export interface GridProps extends HTMLAttributes<HTMLDivElement> {
+  minColumnWidth?: number;
+  maxColumns?: number;
+  gap?: number;
+  padding?: number;
+  staggerMs?: number;
+  maxStaggerMs?: number;
+}
+
+export function Grid(props: GridProps): import("react").JSX.Element;
+
+export interface LoaderProps extends HTMLAttributes<HTMLDivElement> {}
+export function Loader(props: LoaderProps): import("react").JSX.Element;
+
+export interface BackdropProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  label?: string;
+}
+
+export function Backdrop(props: BackdropProps): import("react").JSX.Element;
+
+export interface OverlayDismissOptions {
+  enabled?: boolean;
+  initialFocusRef?: { current: HTMLElement | null };
+  onEnterKeyDown?: (event: KeyboardEvent) => void;
+  onEscapeKeyDown?: (event: KeyboardEvent) => void;
+  restoreFocus?: boolean;
+  rootRef?: { current: HTMLElement | null };
+  trapFocus?: boolean;
+  useCapture?: boolean;
+}
+
+export function useOverlayDismiss(options?: OverlayDismissOptions): void;
+
+export interface OverlayProps extends HTMLAttributes<HTMLDivElement> {
+  backdropLabel?: string;
+  backdropStyle?: CSSProperties;
+  centerContent?: boolean;
+  closing?: boolean;
+  initialFocusRef?: { current: HTMLElement | null };
+  onBackdropClick?: MouseEventHandler<HTMLButtonElement>;
+  onEnterKeyDown?: (event: KeyboardEvent) => void;
+  onEscapeKeyDown?: (event: KeyboardEvent) => void;
+  portal?: boolean;
+  portalTarget?: Element | DocumentFragment | null;
+  restoreFocus?: boolean;
+  trapFocus?: boolean;
+  useKeyboardCapture?: boolean;
+}
+
+export function Overlay(props: OverlayProps): import("react").JSX.Element | null;
+
+export interface OverlayDialogProps extends OverlayProps {
+  role?: string;
+}
+
+export function OverlayDialog(props: OverlayDialogProps): import("react").JSX.Element | null;
+
+export interface UseSheetDragDismissOptions {
+  canStartContentDrag?: (event: PointerEvent | import("react").PointerEvent<HTMLElement>) => boolean;
+  closing?: boolean;
+  containerRef?: { current: HTMLElement | null };
+  dragZoneRef?: { current: HTMLElement | null };
+  enableContentDrag?: boolean;
+  isMobile?: boolean;
+  onDragDismiss?: () => void;
+  onRequestClose?: () => void;
+  scrollRef?: { current: HTMLElement | null };
+  showDragHandle?: boolean;
+}
+
+export interface UseSheetDragDismissResult {
+  backdropStyle: CSSProperties;
+  dragging: boolean;
+  gestureClosing: boolean;
+  handlePointerDown: (event: import("react").PointerEvent<HTMLElement>, source?: "content" | "handle") => void;
+  handlePointerEnd: (event: import("react").PointerEvent<HTMLElement>) => void;
+  handlePointerMove: (event: import("react").PointerEvent<HTMLElement>) => void;
+  handleTransitionEnd: () => void;
+  sheetStyle: CSSProperties;
+}
+
+export function useSheetDragDismiss(options?: UseSheetDragDismissOptions): UseSheetDragDismissResult;
+
+export interface SheetProps extends OverlayProps {
+  beforeScrollContent?: ReactNode;
+  canStartContentDrag?: (event: PointerEvent | import("react").PointerEvent<HTMLElement>) => boolean;
+  enableContentDrag?: boolean;
+  feedbackState?: "success" | "failure" | string;
+  isMobile?: boolean;
+  onDragDismiss?: () => void;
+  onRequestClose?: () => void;
+  showDragHandle?: boolean;
+}
+
+export const Sheet: import("react").ForwardRefExoticComponent<SheetProps & import("react").RefAttributes<HTMLDivElement>>;
+
+export interface TableColumn<Row = Record<string, unknown>> {
+  key: string;
+  header?: ReactNode;
+  accessor?: (row: Row) => unknown;
+  cell?: (row: Row) => ReactNode;
+  sortable?: boolean;
+  width?: string | number;
+  className?: string;
+  headerClassName?: string;
+  cellClassName?: string;
+}
+
+export interface TableShortcut<Row = Record<string, unknown>> {
+  key?: string;
+  keys?: string | string[];
+  shortcut?: string;
+  enabled?: boolean;
+  preventDefault?: boolean;
+  stopPropagation?: boolean;
+  onTrigger?: (row: Row, event: KeyboardEvent) => void;
+}
+
+export interface TableProps<Row = Record<string, unknown>> extends HTMLAttributes<HTMLDivElement> {
+  data?: Row[];
+  columns?: TableColumn<Row>[];
+  initialSort?: { key: string | null; direction: "asc" | "desc" };
+  getRowKey?: (row: Row, index: number) => string | number;
+  striped?: boolean;
+  conditionalRowClassName?: (row: Row, index: number) => string;
+  onRowClick?: (row: Row, event?: unknown) => void;
+  onSelectedClick?: (row: Row, event?: unknown) => void;
+  onDeselect?: () => void;
+  onSelectionChange?: (row: Row | null, key: string | number | null) => void;
+  onRowRightClick?: (row: Row, event: unknown) => void;
+  selectOnRightClick?: boolean;
+  onEnterRow?: (row: Row, event: unknown) => void;
+  enableKeyboardNav?: boolean;
+  hasActiveSearch?: boolean;
+  isLoading?: boolean;
+  sourceDataCount?: number | null;
+  rowShortcuts?: TableShortcut<Row>[];
+  sortAscIcon?: ReactNode;
+  sortDescIcon?: ReactNode;
+  emptyState?: ReactNode | ((context: TableStateContext<Row>) => ReactNode);
+  noResultsState?: ReactNode | ((context: TableStateContext<Row>) => ReactNode);
+}
+
+export interface TableStateContext<Row = Record<string, unknown>> {
+  className: string;
+  columns: TableColumn<Row>[];
+  data: Row[];
+  hasActiveSearch: boolean;
+  sourceDataCount: number | null;
+}
+
+export function Table<Row = Record<string, unknown>>(props: TableProps<Row>): import("react").JSX.Element;
+export function TableBody<Row = Record<string, unknown>>(props: Record<string, unknown>): import("react").JSX.Element;
+export function TableHead<Row = Record<string, unknown>>(props: Record<string, unknown>): import("react").JSX.Element;
+export function TableRow<Row = Record<string, unknown>>(props: Record<string, unknown>): import("react").JSX.Element;
+export function FullSearchBar(props: {
+  options?: Array<Record<string, unknown>>;
+  selectedOption?: SelectOptionValue;
+  onChangeOption?: (value: SelectOptionValue) => void;
+  setData?: (data: unknown[]) => void;
+  onQueryChange?: (query: string) => void;
+  initialQuery?: string;
+  filters?: boolean;
+  addButton?: boolean;
+  buttonName?: string;
+  enableCtrlF?: boolean;
+  translate?: (key: string, values?: Record<string, unknown>) => string;
+  isMobile?: boolean;
+  onAdd?: (option?: Record<string, unknown> | null) => void;
+  searchIcon?: ReactNode;
+  renderActionButton?: (props: Record<string, unknown>) => ReactNode;
+  searchScope?: string;
+}): import("react").JSX.Element;
+export function TableCRUD<Row = Record<string, unknown>>(
+  props: TableProps<Row> & {
+    id?: string;
+    table_name?: string | null;
+    addFormName?: string;
+    searchKeys?: string[];
+    initialData?: Row[];
+    buttonName?: string;
+    includeHeader?: boolean;
+    translate?: (key: string, values?: Record<string, unknown>) => string;
+    renderActionButton?: (props: Record<string, unknown>) => ReactNode;
+    searchIcon?: ReactNode;
+    searchScope?: string;
+    includePageSearchbar?: boolean;
+    useGlobalSearch?: boolean;
+  }
+): import("react").JSX.Element;
+export function ResponsiveTable<Row = Record<string, unknown>>(props: {
+  id?: string;
+  table_name?: string;
+  addFormName?: string;
+  optionsFormName?: string;
+  searchKeys?: string[];
+  columns?: TableColumn<Row>[];
+  initialData?: Row[];
+  isLoading?: boolean;
+  buttonName?: string;
+  mainAction?: (row: Row, event?: unknown) => void;
+  desktopMenuActions?: unknown[];
+  onEditRow?: (row: Row) => void;
+  onToggleArchiveRow?: (row: Row) => void;
+  onDeleteRow?: (row: Row) => void;
+  allowArchive?: boolean;
+  allowDelete?: boolean;
+  openMobileMenu?: (row: Row, event?: unknown) => void;
+  conditionalRowClassName?: (row: Row, index: number) => string;
+  rowShortcuts?: TableShortcut<Row>[];
+  fillAvailableHeight?: boolean;
+  includeHeader?: boolean;
+  translate?: (key: string, values?: Record<string, unknown>) => string;
+  createActionsPayload?: (row: Row, actions: unknown[]) => unknown;
+  TableCRUDComponent?: (props: Record<string, unknown>) => ReactNode;
+  renderActionButton?: (props: Record<string, unknown>) => ReactNode;
+  searchIcon?: ReactNode;
+  emptyState?: ReactNode | ((context: TableStateContext<Row>) => ReactNode);
+  noResultsState?: ReactNode | ((context: TableStateContext<Row>) => ReactNode);
+  searchScope?: string;
+  includePageSearchbar?: boolean;
+  useGlobalSearch?: boolean;
+}): import("react").JSX.Element;
+export function useDebounce<Value = unknown>(value: Value, delay?: number): Value;
+export const GLOBAL_TABLE_SEARCH_SCOPE: string;
+export function TableSearchProvider(props: {
+  children?: ReactNode;
+  resetKey?: string | number;
+}): import("react").JSX.Element;
+export function useTableSearch(
+  scope?: string,
+  options?: { debounceMs?: number }
+): {
+  query: string;
+  debouncedQuery: string;
+  setQuery: (value: string) => void;
+  clearQuery: () => void;
+};
+export function EmptyCell(props: { icon?: ReactNode }): import("react").JSX.Element;
+export function TextCell<Row = Record<string, unknown>>(props: {
+  row: Row;
+  getValue: (row: Row) => ReactNode;
+  renderEmpty?: ReactNode;
+}): ReactNode;
+export function IconTextCell<Row = Record<string, unknown>>(props: {
+  row: Row;
+  getIconName?: (row: Row) => string | undefined;
+  getIconSrc?: (row: Row) => string | undefined;
+  getAlt?: (row: Row) => string;
+  getValue: (row: Row) => ReactNode;
+  renderIcon?: (props: { name: string; alt: string; size: IconSize; row: Row }) => ReactNode;
+  size?: IconSize;
+}): import("react").JSX.Element;
+export function FloatingRowMenu<Row = Record<string, unknown>>(props: {
+  x: number;
+  y: number;
+  row?: Row | null;
+  actions?: Array<{
+    label?: ReactNode | ((row: Row) => ReactNode);
+    icon?: string;
+    iconName?: string;
+    renderIcon?: (props: { icon?: string; iconName?: string; row: Row }) => ReactNode;
+    onClick?: (row: Row) => void;
+    color?: string;
+    shortcut?: ReactNode;
+    disabled?: boolean | ((row: Row) => boolean);
+  }>;
+  onClose?: () => void;
+}): import("react").JSX.Element | null;
+export function useTableSorting<Row = Record<string, unknown>>(options: {
+  data: Row[];
+  columns: TableColumn<Row>[];
+  initialSort?: { key: string | null; direction: "asc" | "desc" };
+}): {
+  sortConfig: { key: string | null; direction: "asc" | "desc" };
+  requestSort: (key: string, sortable?: boolean) => void;
+  sortedData: Row[];
+};
+export function useTableSelection<Row = Record<string, unknown>>(options: Record<string, unknown>): {
+  selectedKey: string | number | null;
+  getRowHandlers: (row: Row, rowKey: string | number) => Record<string, unknown>;
+};