@1interface/widgets 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2556 @@
+import { Component } from 'react';
+import { Context } from 'react';
+import { default as default_2 } from 'react';
+import { Dispatch } from 'react';
+import { ErrorInfo } from 'react';
+import { ImageStyle } from '../../react-native-web';
+import { JSX } from 'react';
+import { JSXElementConstructor } from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { TextStyle } from '../../react-native-web';
+import { ViewStyle } from '../../react-native-web';
+
+export declare const ACTION_TYPES: {
+    readonly URL: "url";
+    readonly TABS: "tabs";
+    readonly DATA_CHECKBOX: "data-checkbox";
+    readonly DATA_SELECT: "data-select";
+    readonly QUANTITY_CHANGE: "quantity.change";
+    readonly UPLOAD_SELECT: "upload.select";
+    readonly UPLOAD_REMOVE: "upload.remove";
+    readonly UPLOAD_ERROR: "upload.error";
+    readonly REPLY: "reply";
+    readonly REPLY_TEMPLATE: "reply-template";
+    readonly UPLOAD_SUBMIT: "upload.submit";
+    readonly ORDER_SUBMIT: "order.submit";
+    readonly MODE_CHANGE: "mode-change";
+};
+
+export declare interface ActionConfig {
+    type: string;
+    payload?: Record<string, unknown>;
+}
+
+export declare type ActionHandler = (action: any, formData?: any, isConsumer?: boolean) => void;
+
+declare type ActionHandler_2 = (action: ActionConfig, 
+e?: unknown, 
+isLoader?: unknown) => void;
+
+export declare const ActionHandlerContext: Context<((action: any, formData?: any, isConsumer?: boolean) => void) | null>;
+
+export declare type Alignment = (typeof ALIGNMENTS)[keyof typeof ALIGNMENTS];
+
+export declare const ALIGNMENTS: {
+    readonly start: "start";
+    readonly center: "center";
+    readonly end: "end";
+    readonly baseline: "baseline";
+    readonly stretch: "stretch";
+};
+
+declare type AnyWidget = WidgetComponent | WidgetRoot;
+
+export declare type AreaSeries = {
+    type: typeof SERIES_TYPES.area;
+    label?: string;
+    dataKey: string;
+    color?: ColorValue;
+    curveType?: CurveType;
+    stack?: string;
+};
+
+export declare function Badge(p: ResolvedBadge): JSX.Element;
+
+declare type Badge_2 = BadgeProps;
+
+export declare const BADGE_COLORS: {
+    readonly primary: "primary";
+    readonly secondary: "secondary";
+    readonly success: "success";
+    readonly danger: "danger";
+    readonly warning: "warning";
+    readonly info: "info";
+    readonly discovery: "discovery";
+};
+
+export declare const BADGE_SIZES: {
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+};
+
+export declare const BADGE_VARIANTS: {
+    readonly solid: "solid";
+    readonly soft: "soft";
+    readonly outline: "outline";
+};
+
+export declare type BadgeColor = (typeof BADGE_COLORS)[keyof typeof BADGE_COLORS];
+
+export declare type BadgeProps = {
+    type: "Badge";
+    key?: string;
+    id?: string;
+    label: string;
+    color?: BadgeColor;
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    pill?: boolean;
+};
+
+export declare type BadgeSize = (typeof BADGE_SIZES)[keyof typeof BADGE_SIZES];
+
+export declare type BadgeVariant = (typeof BADGE_VARIANTS)[keyof typeof BADGE_VARIANTS];
+
+declare type BadgeVariantKey = "solid" | "soft" | "outline";
+
+export declare type BarSeries = {
+    type: typeof SERIES_TYPES.bar;
+    label?: string;
+    dataKey: string;
+    color?: ColorValue;
+    stack?: string;
+};
+
+declare const BASE_TOKENS: {
+    readonly spacingUnit: 3;
+    readonly space: {
+        readonly 0: 0;
+        readonly 2: 2;
+        readonly 4: 4;
+        readonly 6: 6;
+        readonly 8: 8;
+        readonly 10: 10;
+        readonly 12: 12;
+        readonly 14: 14;
+        readonly 16: 16;
+        readonly 20: 20;
+        readonly 24: 24;
+        readonly 32: 32;
+    };
+    readonly radius: {
+        readonly none: 0;
+        readonly "2xs": 2;
+        readonly xs: 4;
+        readonly sm: 6;
+        readonly md: 8;
+        readonly lg: 10;
+        readonly xl: 12;
+        readonly "2xl": 16;
+        readonly "3xl": 20;
+        readonly "4xl": 24;
+        readonly pill: 9999;
+    };
+    readonly font: {
+        readonly family: "System";
+        readonly monoFamily: "monospace";
+        readonly baseSize: 14;
+        readonly weight: {
+            readonly normal: "400";
+            readonly medium: "500";
+            readonly semibold: "600";
+            readonly bold: "700";
+        };
+        readonly size: {
+            readonly text: {
+                readonly xs: 12;
+                readonly sm: 14;
+                readonly md: 16;
+                readonly lg: 18;
+                readonly xl: 20;
+                readonly "2xl": 24;
+                readonly "3xl": 32;
+                readonly "2xs": 10;
+            };
+            readonly title: {
+                readonly sm: 18;
+                readonly md: 20;
+                readonly lg: 24;
+                readonly xl: 32;
+                readonly "2xl": 36;
+                readonly "3xl": 48;
+                readonly "4xl": 60;
+                readonly "5xl": 72;
+            };
+            readonly caption: {
+                readonly sm: 14;
+                readonly md: 16;
+                readonly lg: 18;
+            };
+        };
+    };
+    readonly color: {
+        readonly surface: "#FFFFFF";
+        readonly surfaceAlt: "#F4F4F5";
+        readonly surfaceTertiary: "#F3F3F3";
+        readonly text: "#1A1A1A";
+        readonly textMuted: "#6B6B6B";
+        readonly textFaint: "#9B9B9B";
+        readonly placeholder: "#9B9B9B";
+        readonly border: "rgba(0,0,0,0.1)";
+        readonly borderInput: "rgba(0,0,0,0.1)";
+        readonly transparent: "transparent";
+        readonly primary: StatusColorTriplet;
+        readonly secondary: StatusColorTriplet;
+        readonly success: StatusColorTriplet;
+        readonly danger: StatusColorTriplet;
+        readonly warning: StatusColorTriplet;
+        readonly info: StatusColorTriplet;
+        readonly discovery: StatusColorTriplet;
+    };
+    readonly control: {
+        readonly size: {
+            readonly "3xs": {
+                readonly h: 22;
+                readonly padH: 6;
+                readonly font: 12;
+                readonly gap: 3;
+                readonly iconPx: 12;
+                readonly radiusScale: 0.375;
+            };
+            readonly "2xs": {
+                readonly h: 24;
+                readonly padH: 8;
+                readonly font: 12;
+                readonly gap: 4;
+                readonly iconPx: 12;
+                readonly radiusScale: 0.375;
+            };
+            readonly xs: {
+                readonly h: 26;
+                readonly padH: 8;
+                readonly font: 14;
+                readonly gap: 4;
+                readonly iconPx: 14;
+                readonly radiusScale: 0.375;
+            };
+            readonly sm: {
+                readonly h: 28;
+                readonly padH: 10;
+                readonly font: 14;
+                readonly gap: 4;
+                readonly iconPx: 16;
+                readonly radiusScale: 0.375;
+            };
+            readonly md: {
+                readonly h: 32;
+                readonly padH: 12;
+                readonly font: 14;
+                readonly gap: 6;
+                readonly iconPx: 18;
+                readonly radiusScale: 0.5;
+            };
+            readonly lg: {
+                readonly h: 36;
+                readonly padH: 12;
+                readonly font: 14;
+                readonly gap: 6;
+                readonly iconPx: 20;
+                readonly radiusScale: 0.5;
+            };
+            readonly xl: {
+                readonly h: 40;
+                readonly padH: 14;
+                readonly font: 16;
+                readonly gap: 6;
+                readonly iconPx: 22;
+                readonly radiusScale: 0.625;
+            };
+            readonly "2xl": {
+                readonly h: 44;
+                readonly padH: 16;
+                readonly font: 16;
+                readonly gap: 6;
+                readonly iconPx: 24;
+                readonly radiusScale: 0.625;
+            };
+            readonly "3xl": {
+                readonly h: 48;
+                readonly padH: 16;
+                readonly font: 16;
+                readonly gap: 6;
+                readonly iconPx: 24;
+                readonly radiusScale: 0.625;
+            };
+        };
+    };
+    readonly badge: {
+        readonly size: {
+            readonly sm: {
+                readonly padH: 5;
+                readonly font: 12;
+                readonly lineHeight: 20;
+                readonly radiusScale: 0.25;
+            };
+            readonly md: {
+                readonly padH: 6;
+                readonly font: 14;
+                readonly lineHeight: 22;
+                readonly radiusScale: 0.25;
+            };
+            readonly lg: {
+                readonly padH: 8;
+                readonly font: 14;
+                readonly lineHeight: 24;
+                readonly radiusScale: 0.375;
+            };
+        };
+        readonly gap: 4;
+        readonly fontWeight: "600";
+    };
+    readonly card: {
+        readonly size: {
+            readonly sm: 400;
+            readonly md: 448;
+            readonly lg: 800;
+            readonly full: 9999;
+        };
+        readonly defaultPadPx: 16;
+        readonly contentGap: 12;
+        readonly actionRowGap: 8;
+        readonly shellGap: 12;
+        readonly actionButtonSize: "lg";
+    };
+    readonly icon: {
+        readonly size: {
+            readonly xs: 14;
+            readonly sm: 16;
+            readonly md: 18;
+            readonly lg: 20;
+            readonly xl: 22;
+            readonly "2xl": 24;
+            readonly "3xl": 26;
+            readonly button: 18;
+        };
+        readonly wrapperPad: 6;
+        readonly wrapperRoundingPct: 0.2;
+    };
+    readonly ui: {
+        readonly disabledOpacity: 0.5;
+        readonly pressedOpacity: 0.85;
+        readonly pressedOverlayAlpha: 0.04;
+        readonly hairlineAlpha: 0.1;
+        readonly hairlineBorder: number;
+        readonly cardBorderWidth: number;
+    };
+    readonly button: {
+        readonly alwaysPill: false;
+    };
+    readonly checkbox: {
+        readonly size: 18;
+        readonly borderWidth: 1.5;
+        readonly radius: 4;
+        readonly tick: {
+            readonly fontSize: 12;
+            readonly lineHeight: 14;
+            readonly weight: "700";
+        };
+        readonly rowGap: 8;
+    };
+    readonly radio: {
+        readonly ring: 20;
+        readonly ringBorder: 2;
+        readonly dot: 10;
+        readonly rowGap: 8;
+        readonly groupGap: 12;
+    };
+    readonly counter: {
+        readonly btn: 32;
+        readonly btnRadius: 8;
+        readonly glyph: {
+            readonly fontSize: 20;
+            readonly lineHeight: 22;
+            readonly weight: "400";
+        };
+        readonly valueMinWidth: 24;
+        readonly rowGap: 8;
+    };
+    readonly modal: {
+        readonly backdrop: "rgba(0,0,0,0.4)";
+        readonly sheetMaxHeight: "60%";
+        readonly sheetTopRadius: 16;
+        readonly sheetPadV: 4;
+        readonly optionPadV: 12;
+        readonly optionPadH: 16;
+    };
+    readonly overlay: {
+        readonly video: "rgba(0,0,0,0.15)";
+        readonly videoDefaultH: 200;
+    };
+    readonly glass: {
+        readonly fallbackBg: "rgba(255,255,255,0.04)";
+        readonly fallbackBorder: "rgba(255,255,255,0.10)";
+        readonly fallbackBorderWidth: 0.5;
+        readonly webFilter: "blur(40px) saturate(1.3) brightness(1.1)";
+        readonly nativeIntensity: 28;
+        readonly nativeTint: {
+            readonly dark: "systemUltraThinMaterialDark";
+            readonly light: "systemUltraThinMaterialLight";
+        };
+        readonly androidTint: {
+            readonly dark: "dark";
+            readonly light: "light";
+        };
+        readonly androidBlurMethod: "dimezisBlurView";
+    };
+    readonly placeholder: {
+        readonly padding: 16;
+        readonly minHeight: 80;
+        readonly innerGap: 4;
+        readonly borderWidth: 1;
+        readonly label: {
+            readonly fontSize: 13;
+            readonly weight: "600";
+        };
+        readonly note: {
+            readonly fontSize: 11;
+        };
+    };
+    readonly fileUpload: {
+        readonly rowGap: 12;
+        readonly padV: 10;
+        readonly padH: 14;
+        readonly colGap: 2;
+        readonly label: {
+            readonly fontSize: 14;
+            readonly weight: "500";
+        };
+        readonly hint: {
+            readonly fontSize: 11;
+        };
+    };
+    readonly banner: {
+        readonly padV: 8;
+        readonly padH: 12;
+        readonly gap: 6;
+        readonly defaultTextSize: "sm";
+    };
+    readonly listItem: {
+        readonly gap: 4;
+        readonly padV: 8;
+    };
+    readonly text: {
+        readonly captionOpacity: 0.9;
+        readonly titleLetterSpacing: -0.1;
+        readonly requiredMarker: {
+            readonly marginLeft: 4;
+        };
+    };
+    readonly layout: {
+        readonly button: {
+            readonly base: {
+                readonly alignSelf: "flex-start";
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+            readonly block: {
+                readonly width: string;
+                readonly alignSelf: "stretch";
+                readonly flexShrink: 1;
+            } | {
+                readonly flex: number;
+                readonly alignSelf: "stretch";
+                readonly flexShrink: 1;
+            };
+        };
+        readonly badge: {
+            readonly pill: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+        };
+        readonly card: {
+            readonly shell: {
+                readonly width: "100%";
+                readonly flexShrink: 0;
+            };
+            readonly wrapper: {
+                readonly width: "100%";
+                readonly overflow: "hidden";
+            };
+            readonly banner: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+            };
+            readonly actionRow: {
+                readonly flexDirection: "row";
+                readonly flexWrap: "wrap";
+                readonly justifyContent: "flex-start";
+                readonly alignItems: "center";
+                readonly width: "100%";
+                readonly flexShrink: 0;
+            };
+        };
+        readonly checkbox: {
+            readonly row: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+            };
+            readonly box: {
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+        };
+        readonly radio: {
+            readonly row: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+            };
+            readonly ring: {
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+            readonly group: {
+                readonly flexWrap: "wrap";
+            };
+        };
+        readonly counter: {
+            readonly row: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+            };
+            readonly btn: {
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+            readonly valueText: {
+                readonly textAlign: "center";
+            };
+        };
+        readonly input: {
+            readonly wrap: {
+                readonly justifyContent: "center";
+            };
+            readonly field: {
+                readonly flex: 1;
+            };
+        };
+        readonly select: {
+            readonly backdrop: {
+                readonly flex: 1;
+                readonly justifyContent: "flex-end";
+            };
+            readonly trigger: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+                readonly justifyContent: "space-between";
+            };
+            readonly block: {
+                readonly alignSelf: "stretch";
+            };
+            readonly sheetList: {
+                readonly flexGrow: 0;
+            };
+            readonly option: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+                readonly justifyContent: "space-between";
+            };
+            readonly label: {
+                readonly flex: 1;
+            };
+        };
+        readonly textarea: {
+            readonly input: {
+                readonly textAlignVertical: "top";
+            };
+        };
+        readonly datePicker: {
+            readonly input: {
+                readonly flex: 1;
+            };
+        };
+        readonly label: {
+            readonly row: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+                readonly marginBottom: 4;
+            };
+        };
+        readonly fileUpload: {
+            readonly row: {
+                readonly flexDirection: "row";
+                readonly alignItems: "center";
+            };
+            readonly col: {
+                readonly flex: 1;
+            };
+        };
+        readonly placeholder: {
+            readonly wrap: {
+                readonly borderStyle: "dashed";
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+        };
+        readonly video: {
+            readonly wrap: {
+                readonly overflow: "hidden";
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+            readonly overlay: {
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+        };
+        readonly icon: {
+            readonly wrapper: {
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+                readonly flexShrink: 0;
+            };
+        };
+        readonly image: {
+            readonly base: {
+                readonly backgroundColor: "transparent";
+            };
+            readonly placeholder: {
+                readonly alignItems: "center";
+                readonly justifyContent: "center";
+            };
+        };
+        readonly divider: {
+            readonly base: {
+                readonly alignSelf: "stretch";
+            };
+        };
+        readonly spacer: {
+            readonly base: {
+                readonly flex: 1;
+            };
+        };
+        readonly listItem: {
+            readonly row: {
+                readonly flexDirection: "row";
+                readonly alignSelf: "stretch";
+            };
+        };
+        readonly backgroundFill: {
+            readonly imageWrap: {
+                readonly overflow: "hidden";
+            };
+        };
+    };
+};
+
+export declare type BaseTextProps = {
+    value: string;
+    color?: ColorValue;
+    weight?: FontWeight;
+    textAlign?: TextAlign;
+    truncate?: boolean;
+    maxLines?: number;
+};
+
+export declare function BasicRoot(p: ResolvedBasic & {
+    children?: ReactNode;
+}): JSX.Element;
+
+declare type BasicRoot_2 = BasicRootProps;
+
+export declare type BasicRootProps = {
+    type: "Basic";
+    key?: string;
+    id?: string;
+    children: (WidgetComponent | WidgetRoot)[];
+    theme?: ThemeModeOverride;
+    direction?: Direction;
+} & Pick<BoxBaseProps, "gap" | "padding" | "align" | "justify">;
+
+export declare type BlockProps = {
+    height?: number | string;
+    width?: number | string;
+    size?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+    minSize?: number | string;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    maxSize?: number | string;
+    aspectRatio?: number | string;
+    radius?: RadiusValue;
+    margin?: number | string | Spacing;
+};
+
+export declare type Border = {
+    size: number;
+    color?: ColorValue;
+    style?: BorderStyle;
+};
+
+export declare const BORDER_STYLES: {
+    readonly solid: "solid";
+    readonly dashed: "dashed";
+    readonly dotted: "dotted";
+    readonly double: "double";
+    readonly groove: "groove";
+    readonly ridge: "ridge";
+    readonly inset: "inset";
+    readonly outset: "outset";
+};
+
+export declare type Borders = {
+    top?: number | Border;
+    right?: number | Border;
+    bottom?: number | Border;
+    left?: number | Border;
+    x?: number | Border;
+    y?: number | Border;
+};
+
+declare interface BorderSpec {
+    style: "none" | "solid" | "dashed" | "dotted";
+    color: string;
+    opacity: number;
+    width: string;
+    radius: string;
+}
+
+export declare type BorderStyle = (typeof BORDER_STYLES)[keyof typeof BORDER_STYLES];
+
+export declare type BorderValue = number | Border | Borders;
+
+export declare function Box(p: ResolvedBox & {
+    children?: ReactNode;
+}): JSX.Element;
+
+declare type Box_2 = BoxProps;
+
+export declare type BoxBaseProps = {
+    children?: WidgetComponent[];
+    align?: Alignment;
+    alignSelf?: Alignment;
+    justify?: Justification;
+    wrap?: WrapMode;
+    flex?: number | string;
+    gap?: number | string;
+    padding?: number | string | Spacing;
+    border?: BorderValue;
+    background?: ColorValue;
+    tint?: Tint;
+    scrollable?: boolean;
+    whiteSpace?: string;
+    hyphens?: string;
+    overflowWrap?: string;
+    wordBreak?: string;
+    tabId?: string;
+    activeId?: string;
+    onClickAction?: ActionConfig;
+} & BlockProps;
+
+export declare type BoxProps = {
+    type: "Box";
+    key?: string;
+    id?: string;
+    direction?: Direction;
+} & BoxBaseProps;
+
+export declare interface BrandingConfig {
+    start_screen?: {
+        mode?: string;
+        greeting_message?: string | null;
+        input_placeholder?: string;
+    };
+    typography: {
+        font_family: string;
+        font_family_mono?: string;
+        font_size: string | number;
+    };
+    corner_radius: "pill" | "rounded" | "sharp" | string;
+    themes: {
+        light: ThemeSpec;
+        dark?: ThemeSpec;
+    };
+}
+
+export declare function Button(p: ResolvedButton): JSX.Element;
+
+declare type Button_2 = ButtonProps;
+
+export declare const BUTTON_COLORS: {
+    readonly primary: "primary";
+    readonly secondary: "secondary";
+    readonly info: "info";
+    readonly discovery: "discovery";
+    readonly success: "success";
+    readonly caution: "caution";
+    readonly warning: "warning";
+    readonly danger: "danger";
+};
+
+export declare const BUTTON_ICON_SIZES: {
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly "2xl": "2xl";
+};
+
+export declare const BUTTON_STYLE_SHORTHANDS: {
+    readonly primary: "primary";
+    readonly secondary: "secondary";
+};
+
+export declare type ButtonColor = (typeof BUTTON_COLORS)[keyof typeof BUTTON_COLORS];
+
+export declare type ButtonIconSize = (typeof BUTTON_ICON_SIZES)[keyof typeof BUTTON_ICON_SIZES];
+
+export declare type ButtonProps = {
+    type: "Button";
+    key?: string;
+    id?: string;
+    submit?: boolean;
+    label?: string;
+    onClickAction?: ActionConfig;
+    iconStart?: WidgetIcon;
+    iconEnd?: WidgetIcon;
+    style?: ButtonStyleShorthand;
+    iconSize?: ButtonIconSize;
+    color?: ButtonColor;
+    variant?: ControlVariant;
+    size?: ControlSize;
+    pill?: boolean;
+    radius?: RadiusValue | number | string;
+    uniform?: boolean;
+    block?: boolean;
+    width?: number | string;
+    disabled?: boolean;
+    loader?: boolean;
+    isActive?: boolean;
+    activeId?: string;
+    tabId?: string;
+};
+
+export declare type ButtonStyleShorthand = (typeof BUTTON_STYLE_SHORTHANDS)[keyof typeof BUTTON_STYLE_SHORTHANDS];
+
+declare type ButtonVariantKey = "solid" | "soft" | "outline" | "ghost" | "tabs";
+
+export declare function Caption(p: ResolvedCaption): JSX.Element;
+
+declare type Caption_2 = CaptionProps;
+
+export declare const CAPTION_SIZES: {
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+};
+
+export declare type CaptionProps = {
+    type: "Caption";
+    key?: string;
+    id?: string;
+    size?: CaptionSize;
+} & BaseTextProps;
+
+export declare type CaptionSize = (typeof CAPTION_SIZES)[keyof typeof CAPTION_SIZES];
+
+export declare function Card(p: ResolvedCard & {
+    children?: ReactNode;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
+
+declare type Card_2 = CardProps;
+
+export declare const CARD_SIZES: {
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly full: "full";
+};
+
+export declare type CardAction = {
+    label: string;
+    action: ActionConfig;
+};
+
+export declare type CardProps = {
+    type: "Card";
+    key?: string;
+    id?: string;
+    asForm?: boolean;
+    children: WidgetComponent[];
+    background?: ColorValue;
+    size?: CardSize;
+    padding?: number | string | Spacing;
+    status?: WidgetStatus;
+    collapsed?: boolean;
+    confirm?: CardAction;
+    cancel?: CardAction;
+    theme?: ThemeModeOverride;
+    border?: BorderValue;
+    borderRadius?: string;
+    borderColor?: string;
+    tint?: Tint;
+};
+
+export declare type CardSize = (typeof CARD_SIZES)[keyof typeof CARD_SIZES];
+
+export declare function Chart(props: ChartProps_2): default_2.JSX.Element;
+
+declare type Chart_2 = ChartProps;
+
+export declare type ChartProps = {
+    type: "Chart";
+    key?: string;
+    id?: string;
+    data: Record<string, number | string>[];
+    series: Series[];
+    xAxis: XAxisConfig;
+    showYAxis?: boolean;
+    showLegend?: boolean;
+    barGap?: number;
+    barCategoryGap?: number;
+    flex?: number | string;
+} & BlockProps;
+
+declare type ChartProps_2 = Chart_2;
+
+export declare function Checkbox(p: Checkbox_2): JSX.Element;
+
+declare type Checkbox_2 = CheckboxProps;
+
+export declare type CheckboxProps = {
+    type: "Checkbox";
+    key?: string;
+    id?: string;
+    name: string;
+    label?: string;
+    defaultChecked?: boolean;
+    onChangeAction?: ActionConfig;
+    disabled?: boolean;
+    required?: boolean;
+};
+
+export declare function Col(p: BoxBaseProps & {
+    children?: ReactNode;
+}): JSX.Element;
+
+declare type Col_2 = ColProps;
+
+export declare type ColorValue = string | ThemeColor;
+
+export declare type ColProps = {
+    type: "Col";
+    key?: string;
+    id?: string;
+} & BoxBaseProps;
+
+export declare function configureMap(_config: MapConfig): void;
+
+export declare const CONSUMER_ACTIONS: Set<string>;
+
+export declare interface ConsumerAction {
+    type: string;
+    payload: Record<string, unknown>;
+    state: Record<string, unknown>;
+}
+
+export declare const CONTROL_SIZES: {
+    readonly "3xs": "3xs";
+    readonly "2xs": "2xs";
+    readonly xs: "xs";
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly "2xl": "2xl";
+    readonly "3xl": "3xl";
+};
+
+export declare const CONTROL_VARIANTS: {
+    readonly solid: "solid";
+    readonly soft: "soft";
+    readonly outline: "outline";
+    readonly ghost: "ghost";
+    readonly tabs: "tabs";
+};
+
+export declare type ControlSize = (typeof CONTROL_SIZES)[keyof typeof CONTROL_SIZES];
+
+declare type ControlSizeKey = keyof typeof BASE_TOKENS.control.size;
+
+export declare type ControlVariant = (typeof CONTROL_VARIANTS)[keyof typeof CONTROL_VARIANTS];
+
+export declare interface CoreValidationError {
+    name: string;
+    message: string;
+}
+
+export declare interface CoreValidationResult {
+    valid: boolean;
+    errors: CoreValidationError[];
+}
+
+export declare const CURVE_TYPES: {
+    readonly basis: "basis";
+    readonly basisClosed: "basisClosed";
+    readonly basisOpen: "basisOpen";
+    readonly bumpX: "bumpX";
+    readonly bumpY: "bumpY";
+    readonly bump: "bump";
+    readonly linear: "linear";
+    readonly linearClosed: "linearClosed";
+    readonly natural: "natural";
+    readonly monotoneX: "monotoneX";
+    readonly monotoneY: "monotoneY";
+    readonly monotone: "monotone";
+    readonly step: "step";
+    readonly stepBefore: "stepBefore";
+    readonly stepAfter: "stepAfter";
+};
+
+export declare type CurveType = (typeof CURVE_TYPES)[keyof typeof CURVE_TYPES];
+
+export declare function DatePicker(p: ResolvedDatePicker): JSX.Element;
+
+declare type DatePicker_2 = DatePickerProps;
+
+export declare type DatePickerProps = {
+    type: "DatePicker";
+    key?: string;
+    id?: string;
+    name: string;
+    onChangeAction?: ActionConfig;
+    placeholder?: string;
+    defaultValue?: string;
+    min?: string;
+    max?: string;
+    variant?: ControlVariant;
+    size?: ControlSize;
+    side?: PopoverSide;
+    align?: PopoverAlign;
+    pill?: boolean;
+    block?: boolean;
+    clearable?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+};
+
+export declare type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+
+export declare const DEFAULT_CONFIG: RendererConfig;
+
+declare const defaults: {
+    readonly Button: {
+        readonly size: ControlSizeKey;
+        readonly variant: "solid";
+        readonly color: StatusColorKey;
+        readonly pill: true;
+    };
+    readonly Input: {
+        readonly size: ControlSizeKey;
+        readonly variant: "soft";
+        readonly inputType: "text";
+    };
+    readonly Select: {
+        readonly size: ControlSizeKey;
+        readonly variant: "soft";
+    };
+    readonly Textarea: {
+        readonly size: ControlSizeKey;
+        readonly variant: "soft";
+        readonly rows: 3;
+    };
+    readonly DatePicker: {
+        readonly size: ControlSizeKey;
+        readonly variant: "soft";
+    };
+    readonly Badge: {
+        readonly size: "md";
+        readonly variant: "soft";
+        readonly color: "secondary";
+        readonly pill: true;
+    };
+    readonly Card: {
+        readonly size: "md";
+    };
+    readonly Text: {
+        readonly size: "md";
+        readonly weight: "normal";
+    };
+    readonly Title: {
+        readonly size: "lg";
+        readonly weight: "semibold";
+    };
+    readonly Caption: {
+        readonly size: "sm";
+        readonly weight: "normal";
+    };
+    readonly Label: {
+        readonly size: "md";
+        readonly weight: "medium";
+    };
+    readonly Icon: {
+        readonly size: "md";
+    };
+    readonly Box: {
+        readonly direction: "col";
+    };
+    readonly Row: {};
+    readonly Col: {};
+    readonly Basic: {
+        readonly direction: "col";
+    };
+    readonly ListView: {};
+    readonly ListViewItem: {};
+    readonly Spacer: {};
+    readonly Divider: {};
+    readonly Transition: {};
+    readonly Image: {};
+    readonly Video: {};
+    readonly Form: {
+        readonly direction: "col";
+    };
+    readonly Checkbox: {};
+    readonly RadioGroup: {
+        readonly direction: "col";
+    };
+    readonly FileUploadRequest: {};
+};
+
+export declare type Direction = (typeof DIRECTIONS)[keyof typeof DIRECTIONS];
+
+export declare const DIRECTIONS: {
+    readonly row: "row";
+    readonly col: "col";
+};
+
+export declare function Divider(p: Divider_2): JSX.Element;
+
+declare type Divider_2 = DividerProps;
+
+export declare type DividerProps = {
+    type: "Divider";
+    key?: string;
+    id?: string;
+    color?: ColorValue;
+    size?: number | string;
+    spacing?: number | string;
+    flush?: boolean;
+};
+
+export declare interface FieldDescriptor {
+    name: string;
+    value: string;
+    type: string;
+    required: boolean;
+    checked?: boolean;
+    pattern?: string;
+    dataPattern?: string;
+}
+
+declare interface FileUploadEntry {
+    file?: unknown;
+    fileName?: string | null;
+    uploaded?: boolean;
+    loading?: boolean;
+    error?: string | null;
+}
+
+export declare function FileUploadRequest(p: FileUploadRequest_2): JSX.Element;
+
+declare type FileUploadRequest_2 = FileUploadRequestProps;
+
+export declare type FileUploadRequestProps = {
+    type: "FileUploadRequest";
+    key?: string;
+    label: string;
+    fileRequestId: string;
+    icon: string;
+    messageId?: string;
+    maxFileSize?: number;
+    allowedFileExtensions?: string[];
+    uploaded?: boolean;
+    fileName?: string | null;
+    error?: string | null;
+};
+
+export declare const FIT_MODES: {
+    readonly cover: "cover";
+    readonly contain: "contain";
+    readonly fill: "fill";
+    readonly "scale-down": "scale-down";
+    readonly none: "none";
+};
+
+export declare type FitMode = (typeof FIT_MODES)[keyof typeof FIT_MODES];
+
+export declare const FONT_WEIGHTS: {
+    readonly normal: "normal";
+    readonly medium: "medium";
+    readonly semibold: "semibold";
+    readonly bold: "bold";
+};
+
+export declare type FontWeight = (typeof FONT_WEIGHTS)[keyof typeof FONT_WEIGHTS];
+
+export declare function Form(p: ResolvedForm & {
+    children?: ReactNode;
+}): JSX.Element;
+
+declare type Form_2 = FormProps;
+
+export declare function formatOrderItems(fields: Record<string, string | number>): string;
+
+export declare const FormContext: Context<FormContextValue_2 | null>;
+
+export declare interface FormContextValue {
+    submit: (() => void) | undefined;
+    registerRequired: (name: string, required: boolean) => void;
+    isRequired: (name: string) => boolean;
+}
+
+declare interface FormContextValue_2 {
+    submit: () => void;
+    validate: () => boolean;
+    formFields: Record<string, string>;
+    registerRequired: (name: string, required: boolean, tabId?: string, type?: string, pattern?: string) => void;
+    isRequired: (name: string) => boolean;
+    validationErrors: Record<string, string>;
+    setValidationErrors: (errors: Record<string, string>) => void;
+}
+
+export declare type FormProps = {
+    type: "Form";
+    key?: string;
+    id?: string;
+    onSubmitAction?: ActionConfig;
+    direction?: Direction;
+} & BoxBaseProps;
+
+export declare const GUTTER_SIZES: {
+    readonly "2xs": "2xs";
+    readonly xs: "xs";
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+};
+
+export declare type GutterSize = (typeof GUTTER_SIZES)[keyof typeof GUTTER_SIZES];
+
+export declare function Icon({ name, size, color, backgroundColor, background, }: IconProps_2): JSX.Element | null;
+
+declare type Icon_2 = IconProps;
+
+export declare const ICON_SIZES: {
+    readonly xs: "xs";
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly "2xl": "2xl";
+    readonly "3xl": "3xl";
+    readonly button: "button";
+};
+
+export declare type IconProps = {
+    type: "Icon";
+    key?: string;
+    id?: string;
+    name: WidgetIcon;
+    color?: ColorValue;
+    size?: IconSize;
+    backgroundColor?: ColorValue;
+    background?: ColorValue;
+};
+
+declare interface IconProps_2 {
+    name: string;
+    size?: IconSizeKey;
+    color?: string | ThemeColor;
+    backgroundColor?: string | ThemeColor;
+    background?: string | ThemeColor;
+}
+
+export declare type IconSize = (typeof ICON_SIZES)[keyof typeof ICON_SIZES];
+
+declare type IconSizeKey = keyof typeof BASE_TOKENS.icon.size;
+
+declare function Image_2(p: Image_3): JSX.Element;
+export { Image_2 as Image }
+
+declare type Image_3 = ImageProps;
+
+export declare const IMAGE_POSITIONS: {
+    readonly "top left": "top left";
+    readonly top: "top";
+    readonly "top right": "top right";
+    readonly left: "left";
+    readonly center: "center";
+    readonly right: "right";
+    readonly "bottom left": "bottom left";
+    readonly bottom: "bottom";
+    readonly "bottom right": "bottom right";
+};
+
+export declare type ImagePosition = (typeof IMAGE_POSITIONS)[keyof typeof IMAGE_POSITIONS];
+
+export declare type ImageProps = {
+    type: "Image";
+    key?: string;
+    id?: string;
+    src: string;
+    alt?: string;
+    frame?: boolean;
+    fit?: FitMode;
+    position?: ImagePosition;
+    flush?: boolean;
+} & BlockProps;
+
+export declare function Input(p: ResolvedInput): JSX.Element;
+
+declare type Input_2 = InputProps;
+
+export declare const INPUT_TYPES: {
+    readonly number: "number";
+    readonly email: "email";
+    readonly text: "text";
+    readonly password: "password";
+    readonly tel: "tel";
+    readonly url: "url";
+    readonly card_number: "card_number";
+    readonly month_year: "month_year";
+    readonly cvc: "cvc";
+    readonly counter: "counter";
+};
+
+export declare const INPUT_VARIANTS: {
+    readonly soft: "soft";
+    readonly outline: "outline";
+};
+
+export declare type InputProps = {
+    type: "Input";
+    key?: string;
+    id?: string;
+    name: string;
+    inputType?: InputType;
+    defaultValue?: string;
+    required?: boolean;
+    pattern?: string;
+    placeholder?: string;
+    allowAutofillExtensions?: boolean;
+    autoSelect?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    variant?: InputVariant;
+    size?: ControlSize;
+    gutterSize?: GutterSize;
+    pill?: boolean;
+    onChangeAction?: ActionConfig;
+};
+
+export declare type InputType = (typeof INPUT_TYPES)[keyof typeof INPUT_TYPES];
+
+export declare type InputVariant = (typeof INPUT_VARIANTS)[keyof typeof INPUT_VARIANTS];
+
+declare type InputVariantKey = "soft" | "outline" | "ghost";
+
+export declare type Justification = (typeof JUSTIFICATIONS)[keyof typeof JUSTIFICATIONS];
+
+export declare const JUSTIFICATIONS: {
+    readonly start: "start";
+    readonly center: "center";
+    readonly end: "end";
+    readonly between: "between";
+    readonly around: "around";
+    readonly evenly: "evenly";
+    readonly stretch: "stretch";
+};
+
+export declare function Label(p: ResolvedLabel): JSX.Element;
+
+declare type Label_2 = LabelProps;
+
+export declare type LabelProps = {
+    type: "Label";
+    key?: string;
+    id?: string;
+    value: string;
+    fieldName: string;
+    size?: TextSize;
+    weight?: FontWeight;
+    textAlign?: TextAlign;
+    color?: ColorValue;
+};
+
+export declare const LIMIT_AUTO: "auto";
+
+export declare type LineSeries = {
+    type: typeof SERIES_TYPES.line;
+    label?: string;
+    dataKey: string;
+    color?: ColorValue;
+    curveType?: CurveType;
+};
+
+export declare function ListView(p: ListView_2 & {
+    children?: ReactNode;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
+
+declare type ListView_2 = ListViewProps;
+
+export declare function ListViewItem(p: ListViewItem_2 & {
+    children?: ReactNode;
+    stretchTallest?: boolean;
+}): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+declare type ListViewItem_2 = ListViewItemProps;
+
+export declare type ListViewItemProps = {
+    type: "ListViewItem";
+    key?: string;
+    id?: string;
+    children: WidgetComponent[];
+    onClickAction?: ActionConfig;
+    gap?: number | string;
+    align?: Alignment;
+    props?: Record<string, unknown>;
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number | string;
+    minHeight?: number | string;
+    overflow?: string;
+    backgroundColor?: string;
+    background?: string;
+    border?: BorderValue;
+    radius?: RadiusValue | number | string;
+};
+
+export declare type ListViewProps = {
+    type: "ListView";
+    key?: string;
+    id?: string;
+    children: ListViewItem_2[];
+    limit?: number | typeof LIMIT_AUTO;
+    status?: WidgetStatus;
+    theme?: ThemeModeOverride;
+    direction?: Direction;
+    gap?: number | string;
+    scrollable?: boolean;
+    maxWidth?: number | string;
+    width?: number | string;
+    backgroundColor?: ColorValue;
+    border?: BorderValue;
+    borderRadius?: string;
+    borderColor?: string;
+    tint?: Tint;
+    background?: ColorValue;
+    padding?: number | string | Spacing;
+    showScrollIndicator?: boolean;
+    tabId?: string;
+    isActive?: string;
+    activeId?: string;
+};
+
+export declare interface LocationCoordinates {
+    lat: number;
+    lng: number;
+}
+
+export declare const MAP_MODES: {
+    readonly display: "display";
+    readonly input: "input";
+};
+
+export declare type MapCircle = MapCircleProps;
+
+export declare type MapCircleProps = {
+    type: "MapCircle";
+    key?: string;
+    id?: string;
+    center: MapCoordinate;
+    radius: number;
+    color?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    weight?: number;
+};
+
+export declare interface MapConfig {
+    provider?: string;
+    googleMapsApiKey?: string;
+    googleMapsMapId?: string;
+    thunderforestApiKey?: string;
+}
+
+export declare type MapCoordinate = {
+    lat: number;
+    long?: number;
+    lng?: number;
+};
+
+export declare type MapMarker = MapMarkerProps;
+
+export declare type MapMarkerProps = {
+    type: "MapMarker";
+    key?: string;
+    id?: string;
+    position: MapCoordinate;
+    label?: string;
+    icon?: string;
+    color?: string;
+    onClickAction?: ActionConfig;
+};
+
+export declare type MapMode = (typeof MAP_MODES)[keyof typeof MAP_MODES];
+
+export declare type MapOverlay = MapMarker | MapPolyline | MapCircle | MapPolygon;
+
+export declare type MapPolygon = MapPolygonProps;
+
+export declare type MapPolygonProps = {
+    type: "MapPolygon";
+    key?: string;
+    id?: string;
+    path: MapCoordinate[];
+    color?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    weight?: number;
+};
+
+export declare type MapPolyline = MapPolylineProps;
+
+export declare type MapPolylineProps = {
+    type: "MapPolyline";
+    key?: string;
+    id?: string;
+    path: MapCoordinate[];
+    color?: string;
+    weight?: number;
+    opacity?: number;
+    dashed?: boolean;
+};
+
+export declare type MapWidget = MapWidgetProps;
+
+export declare type MapWidgetProps = {
+    type: "Map";
+    key?: string;
+    id?: string;
+    mode?: MapMode;
+    name?: string;
+    center?: MapCoordinate;
+    height: string;
+    width: string;
+    zoom?: number;
+    children?: MapOverlay[];
+    allowSearch?: boolean;
+};
+
+export declare function Markdown(props: MarkdownProps_2): default_2.JSX.Element;
+
+declare type Markdown_2 = MarkdownProps;
+
+export declare type MarkdownProps = {
+    type: "Markdown";
+    key?: string;
+    id?: string;
+    value: string;
+    streaming?: boolean;
+};
+
+declare type MarkdownProps_2 = Markdown_2;
+
+export declare function markRequiredLabels(form: HTMLFormElement | null): void;
+
+export declare function mergeConfig(overrides?: DeepPartial<RendererConfig>): RendererConfig;
+
+export declare type OnConsumerAction = (action: ConsumerAction) => void;
+
+export declare const POPOVER_ALIGNS: {
+    readonly start: "start";
+    readonly center: "center";
+    readonly end: "end";
+};
+
+export declare const POPOVER_SIDES: {
+    readonly top: "top";
+    readonly bottom: "bottom";
+    readonly left: "left";
+    readonly right: "right";
+};
+
+export declare type PopoverAlign = (typeof POPOVER_ALIGNS)[keyof typeof POPOVER_ALIGNS];
+
+export declare type PopoverSide = (typeof POPOVER_SIDES)[keyof typeof POPOVER_SIDES];
+
+export declare const PRELOAD_MODES: {
+    readonly auto: "auto";
+    readonly metadata: "metadata";
+    readonly none: "none";
+};
+
+export declare type PreloadMode = (typeof PRELOAD_MODES)[keyof typeof PRELOAD_MODES];
+
+declare interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+    onError?: (error: Error, info: ErrorInfo) => void;
+}
+
+export declare function RadioGroup(p: ResolvedRadioGroup): JSX.Element;
+
+declare type RadioGroup_2 = RadioGroupProps;
+
+export declare type RadioGroupProps = {
+    type: "RadioGroup";
+    key?: string;
+    id?: string;
+    name: string;
+    options?: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }[];
+    ariaLabel?: string;
+    onChangeAction?: ActionConfig;
+    defaultValue?: string;
+    direction?: Direction;
+    disabled?: boolean;
+    required?: boolean;
+};
+
+export declare const RADIUS_VALUES: {
+    readonly "2xs": "2xs";
+    readonly xs: "xs";
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly "2xl": "2xl";
+    readonly "3xl": "3xl";
+    readonly "4xl": "4xl";
+    readonly full: "full";
+    readonly "100%": "100%";
+    readonly none: "none";
+};
+
+export declare type RadiusValue = (typeof RADIUS_VALUES)[keyof typeof RADIUS_VALUES];
+
+export declare const REDUCER_ACTIONS: {
+    readonly TOGGLE_CHECKBOX: "TOGGLE_CHECKBOX";
+    readonly SET_CHECKBOX_DATA: "SET_CHECKBOX_DATA";
+    readonly CLEAR_SELECTIONS: "CLEAR_SELECTIONS";
+    readonly SET_SELECTED_CATEGORY: "SET_SELECTED_CATEGORY";
+    readonly TOGGLE_QUANTITY: "TOGGLE_QUANTITY";
+    readonly UPLOAD_FILE: "UPLOAD_FILE";
+    readonly REMOVE_FILE: "REMOVE_FILE";
+    readonly SET_UPLOAD_ERROR: "SET_UPLOAD_ERROR";
+    readonly RESET_UPLOADS: "RESET_UPLOADS";
+    readonly SET_FORM_FIELD: "SET_FORM_FIELD";
+};
+
+export declare interface RendererConfig {
+    scroll: {
+        allowOrthogonalAxis: boolean;
+        forbidSameAxis: boolean;
+    };
+    animation: {
+        transitionDurationMs: number;
+    };
+    fileUpload: {
+        maxSizeBytes: number;
+        allowedExtensions: string[];
+    };
+    template: {
+        dataSelectToken: string;
+        dataCheckboxToken: string;
+        dataInputToken: string;
+        dataFieldPattern: RegExp;
+        formPlaceholderPattern: RegExp;
+    };
+    platform: {
+        monoFontFamily: string;
+    };
+}
+
+export declare function renderWidget(widget: AnyWidget): React.ReactElement;
+
+declare type Resolved<Schema, Defaulted extends object> = Omit<Schema, keyof Defaulted> & {
+    [K in Extract<keyof Defaulted, keyof Schema>]-?: NonNullable<Schema[K]>;
+};
+
+declare type ResolvedBadge = Resolved<Badge_2, typeof defaults.Badge>;
+
+declare type ResolvedBasic = Resolved<BasicRoot_2, typeof defaults.Basic>;
+
+declare type ResolvedBox = Resolved<Box_2, typeof defaults.Box>;
+
+declare type ResolvedButton = Resolved<Button_2, typeof defaults.Button>;
+
+declare type ResolvedCaption = Resolved<Caption_2, typeof defaults.Caption>;
+
+declare type ResolvedCard = Resolved<Card_2, typeof defaults.Card>;
+
+declare type ResolvedDatePicker = Resolved<DatePicker_2, typeof defaults.DatePicker>;
+
+declare type ResolvedForm = Resolved<Form_2, typeof defaults.Form>;
+
+declare type ResolvedInput = Resolved<Input_2, typeof defaults.Input>;
+
+declare type ResolvedLabel = Resolved<Label_2, typeof defaults.Label>;
+
+declare type ResolvedRadioGroup = Resolved<RadioGroup_2, typeof defaults.RadioGroup>;
+
+declare type ResolvedSelect = Resolved<Select_2, typeof defaults.Select>;
+
+declare type ResolvedText = Resolved<Text_3, typeof defaults.Text>;
+
+declare type ResolvedTextarea = Resolved<Textarea_2, typeof defaults.Textarea>;
+
+declare type ResolvedTitle = Resolved<Title_2, typeof defaults.Title>;
+
+export declare function resolveTemplate(templateText: string, state: {
+    checkboxes?: {
+        selected?: string[];
+    };
+    formFields?: Record<string, string>;
+}, payload?: Record<string, unknown>, config?: RendererConfig): string;
+
+export declare function Row(p: BoxBaseProps & {
+    children?: ReactNode;
+}): JSX.Element;
+
+declare type Row_2 = RowProps;
+
+export declare type RowProps = {
+    type: "Row";
+    key?: string;
+    id?: string;
+} & BoxBaseProps;
+
+export declare function safeRenderWidget(widget: WidgetComponent | WidgetRoot): default_2.ReactElement;
+
+export declare function Select(p: ResolvedSelect): JSX.Element;
+
+declare type Select_2 = SelectProps;
+
+export declare type SelectProps = {
+    type: "Select";
+    key?: string;
+    id?: string;
+    name: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    onChangeAction?: ActionConfig;
+    placeholder?: string;
+    defaultValue?: string;
+    variant?: ControlVariant;
+    size?: ControlSize;
+    pill?: boolean;
+    block?: boolean;
+    clearable?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    color?: ColorValue;
+};
+
+export declare const SELF_CONTAINED_ACTIONS: Set<string>;
+
+export declare type Series = BarSeries | AreaSeries | LineSeries;
+
+export declare const SERIES_TYPES: {
+    readonly bar: "bar";
+    readonly area: "area";
+    readonly line: "line";
+};
+
+export declare type SeriesType = (typeof SERIES_TYPES)[keyof typeof SERIES_TYPES];
+
+export declare function Spacer(p: Spacer_2): JSX.Element;
+
+declare type Spacer_2 = SpacerProps;
+
+export declare type SpacerProps = {
+    type: "Spacer";
+    key?: string;
+    id?: string;
+    minSize?: number | string;
+};
+
+export declare type Spacing = {
+    top?: number | string;
+    right?: number | string;
+    bottom?: number | string;
+    left?: number | string;
+    x?: number | string;
+    y?: number | string;
+};
+
+declare interface State {
+    error: Error | null;
+}
+
+declare type StatusColorKey = "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "discovery";
+
+declare interface StatusColorTriplet {
+    solid: string;
+    bg: string;
+    text: string;
+}
+
+export declare interface StatusThemeVariant {
+    solid: string;
+    background: string;
+    text: string;
+}
+
+declare interface SurfaceSpec {
+    background: string;
+    text_color?: string;
+    placeholder_color?: string;
+    border?: BorderSpec;
+    headings_color?: string;
+    text_content_color?: string;
+    icon_color?: string;
+    profile_text_color?: string;
+    group_background?: string;
+}
+
+declare interface SurfaceStyle {
+    bg: string;
+    fg: string;
+    border: string;
+    borderWidth: number;
+}
+
+declare function Text_2(p: ResolvedText): JSX.Element;
+export { Text_2 as Text }
+
+declare type Text_3 = TextProps;
+
+export declare const TEXT_ALIGNS: {
+    readonly start: "start";
+    readonly center: "center";
+    readonly end: "end";
+};
+
+export declare const TEXT_SIZES: {
+    readonly "2xs": "2xs";
+    readonly xs: "xs";
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly "2xl": "2xl";
+    readonly "3xl": "3xl";
+};
+
+export declare type TextAlign = (typeof TEXT_ALIGNS)[keyof typeof TEXT_ALIGNS];
+
+export declare function Textarea(p: ResolvedTextarea): JSX.Element;
+
+declare type Textarea_2 = TextareaProps;
+
+export declare type TextareaProps = {
+    type: "Textarea";
+    key?: string;
+    id?: string;
+    name: string;
+    defaultValue?: string;
+    required?: boolean;
+    pattern?: string;
+    placeholder?: string;
+    autoSelect?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    variant?: InputVariant;
+    size?: ControlSize;
+    gutterSize?: GutterSize;
+    rows?: number;
+    autoResize?: boolean;
+    maxRows?: number;
+    allowAutofillExtensions?: boolean;
+};
+
+export declare type TextProps = {
+    type: "Text";
+    key?: string;
+    id?: string;
+    value: string;
+    streaming?: boolean;
+    italic?: boolean;
+    lineThrough?: boolean;
+    width?: number | string;
+    size?: TextSize;
+    minLines?: number;
+    editable?: false | {
+        name: string;
+        autoFocus?: boolean;
+        autoSelect?: boolean;
+        autoComplete?: string;
+        allowAutofillExtensions?: boolean;
+        pattern?: string;
+        placeholder?: string;
+        required?: boolean;
+    };
+} & BaseTextProps;
+
+export declare type TextSize = (typeof TEXT_SIZES)[keyof typeof TEXT_SIZES];
+
+declare interface Theme {
+    tokens: Tokens;
+    variants: Variants;
+    mode: ThemeMode;
+    config: RendererConfig;
+    branding?: BrandingConfig | WidgetBrandingStyles;
+}
+
+export declare const THEME_MODES: {
+    readonly light: "light";
+    readonly dark: "dark";
+};
+
+export declare type ThemeColor = {
+    dark: string;
+    light: string;
+};
+
+export declare type ThemeMode = "light" | "dark";
+
+export declare type ThemeModeOverride = (typeof THEME_MODES)[keyof typeof THEME_MODES];
+
+declare function ThemeProvider({ branding, mode, config, children, }: ThemeProviderProps): JSX.Element;
+
+declare interface ThemeProviderProps {
+    branding?: BrandingConfig | WidgetBrandingStyles;
+    mode?: ThemeMode;
+    config?: RendererConfig;
+    children: ReactNode;
+}
+
+declare interface ThemeSpec {
+    accent: {
+        primary: string;
+    };
+    surface: {
+        chat?: {
+            background: string;
+        };
+        input?: SurfaceSpec;
+        widget?: {
+            background: string;
+            border?: BorderSpec;
+        };
+        user_message?: SurfaceSpec;
+        side_menu?: SurfaceSpec;
+        settings?: {
+            group_background?: string;
+        };
+    };
+    text: {
+        primary: string;
+        secondary: string;
+        tertiary: string;
+    };
+    status: {
+        primary: StatusThemeVariant;
+        secondary: StatusThemeVariant;
+        success: StatusThemeVariant;
+        danger: StatusThemeVariant;
+        warning: StatusThemeVariant;
+        info?: StatusThemeVariant;
+        discovery?: StatusThemeVariant;
+    };
+}
+
+export declare type Tint = (typeof TINTS)[keyof typeof TINTS];
+
+export declare const TINTS: {
+    readonly clear: "clear";
+};
+
+export declare function Title(p: ResolvedTitle): JSX.Element;
+
+declare type Title_2 = TitleProps;
+
+export declare const TITLE_SIZES: {
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly "2xl": "2xl";
+    readonly "3xl": "3xl";
+    readonly "4xl": "4xl";
+    readonly "5xl": "5xl";
+};
+
+export declare type TitleProps = {
+    type: "Title";
+    key?: string;
+    id?: string;
+    size?: TitleSize;
+} & BaseTextProps;
+
+export declare type TitleSize = (typeof TITLE_SIZES)[keyof typeof TITLE_SIZES];
+
+declare interface Tokens {
+    spacingUnit: number;
+    space: Record<keyof typeof BASE_TOKENS.space, number>;
+    radius: Record<keyof typeof BASE_TOKENS.radius, number>;
+    font: {
+        family: string;
+        monoFamily: string;
+        baseSize: number;
+        weight: {
+            normal: "400";
+            medium: "500";
+            semibold: "600";
+            bold: "700";
+        };
+        size: {
+            text: Record<keyof typeof BASE_TOKENS.font.size.text, number>;
+            title: Record<keyof typeof BASE_TOKENS.font.size.title, number>;
+            caption: Record<keyof typeof BASE_TOKENS.font.size.caption, number>;
+        };
+    };
+    color: {
+        surface: string;
+        surfaceAlt: string;
+        surfaceTertiary: string;
+        text: string;
+        textMuted: string;
+        textFaint: string;
+        placeholder: string;
+        border: string;
+        borderInput: string;
+        transparent: "transparent";
+        primary: StatusColorTriplet;
+        secondary: StatusColorTriplet;
+        success: StatusColorTriplet;
+        danger: StatusColorTriplet;
+        warning: StatusColorTriplet;
+        info: StatusColorTriplet;
+        discovery: StatusColorTriplet;
+    };
+    control: {
+        size: Record<keyof typeof BASE_TOKENS.control.size, {
+            h: number;
+            padH: number;
+            font: number;
+            gap: number;
+            iconPx: number;
+            radiusScale: number;
+        }>;
+    };
+    badge: {
+        size: Record<keyof typeof BASE_TOKENS.badge.size, {
+            padH: number;
+            font: number;
+            lineHeight: number;
+            radiusScale: number;
+        }>;
+        gap: number;
+        fontWeight: "600";
+    };
+    card: {
+        size: Record<keyof typeof BASE_TOKENS.card.size, number>;
+        defaultPadPx: number;
+        contentGap: number;
+        actionRowGap: number;
+        shellGap: number;
+        actionButtonSize: "lg";
+    };
+    icon: {
+        size: Record<keyof typeof BASE_TOKENS.icon.size, number>;
+        wrapperPad: number;
+        wrapperRoundingPct: number;
+    };
+    ui: {
+        disabledOpacity: number;
+        pressedOpacity: number;
+        pressedOverlayAlpha: number;
+        hairlineAlpha: number;
+        hairlineBorder: number;
+        cardBorderWidth: number;
+    };
+    button: {
+        alwaysPill: boolean;
+    };
+    checkbox: {
+        size: number;
+        borderWidth: number;
+        radius: number;
+        tick: {
+            fontSize: number;
+            lineHeight: number;
+            weight: "700";
+        };
+        rowGap: number;
+    };
+    radio: {
+        ring: number;
+        ringBorder: number;
+        dot: number;
+        rowGap: number;
+        groupGap: number;
+    };
+    counter: {
+        btn: number;
+        btnRadius: number;
+        glyph: {
+            fontSize: number;
+            lineHeight: number;
+            weight: "600";
+        };
+        valueMinWidth: number;
+        rowGap: number;
+    };
+    modal: {
+        backdrop: string;
+        sheetMaxHeight: "60%";
+        sheetTopRadius: number;
+        sheetPadV: number;
+        optionPadV: number;
+        optionPadH: number;
+    };
+    overlay: {
+        video: string;
+        videoDefaultH: number;
+    };
+    glass: {
+        fallbackBg: string;
+        fallbackBorder: string;
+        fallbackBorderWidth: number;
+        webFilter: string;
+        nativeIntensity: number;
+        nativeTint: {
+            dark: string;
+            light: string;
+        };
+        androidTint: {
+            dark: string;
+            light: string;
+        };
+        androidBlurMethod: string;
+    };
+    placeholder: {
+        padding: number;
+        minHeight: number;
+        innerGap: number;
+        borderWidth: number;
+        label: {
+            fontSize: number;
+            weight: "600";
+        };
+        note: {
+            fontSize: number;
+        };
+    };
+    fileUpload: {
+        rowGap: number;
+        padV: number;
+        padH: number;
+        colGap: number;
+        label: {
+            fontSize: number;
+            weight: "500";
+        };
+        hint: {
+            fontSize: number;
+        };
+    };
+    banner: {
+        padV: number;
+        padH: number;
+        gap: number;
+        defaultTextSize: "sm";
+    };
+    listItem: {
+        gap: number;
+        padV: number;
+    };
+    text: {
+        captionOpacity: number;
+        titleLetterSpacing: number;
+        requiredMarker: {
+            marginLeft: number;
+        };
+    };
+    layout: {
+        button: {
+            base: ViewStyle;
+            block: ViewStyle;
+        };
+        badge: {
+            pill: ViewStyle;
+        };
+        card: {
+            shell: ViewStyle;
+            wrapper: ViewStyle;
+            banner: ViewStyle;
+            actionRow: ViewStyle;
+        };
+        checkbox: {
+            row: ViewStyle;
+            box: ViewStyle;
+        };
+        radio: {
+            row: ViewStyle;
+            ring: ViewStyle;
+            group: ViewStyle;
+        };
+        counter: {
+            row: ViewStyle;
+            btn: ViewStyle;
+            valueText: TextStyle;
+        };
+        input: {
+            wrap: ViewStyle;
+            field: TextStyle;
+        };
+        select: {
+            backdrop: ViewStyle;
+            trigger: ViewStyle;
+            block: ViewStyle;
+            sheetList: ViewStyle;
+            option: ViewStyle;
+            label: TextStyle;
+        };
+        textarea: {
+            input: TextStyle;
+        };
+        datePicker: {
+            input: TextStyle;
+        };
+        label: {
+            row: ViewStyle;
+        };
+        fileUpload: {
+            row: ViewStyle;
+            col: ViewStyle;
+        };
+        placeholder: {
+            wrap: ViewStyle;
+        };
+        video: {
+            wrap: ViewStyle;
+            overlay: ViewStyle;
+        };
+        icon: {
+            wrapper: ViewStyle;
+        };
+        image: {
+            base: ImageStyle;
+            placeholder: ViewStyle;
+        };
+        divider: {
+            base: ViewStyle;
+        };
+        spacer: {
+            base: ViewStyle;
+        };
+        listItem: {
+            row: ViewStyle;
+        };
+        backgroundFill: {
+            imageWrap: ViewStyle;
+        };
+    };
+}
+
+export declare function Transition({ children }: {
+    children?: ReactNode;
+}): JSX.Element;
+
+declare type Transition_2 = TransitionProps;
+
+export declare type TransitionProps = {
+    type: "Transition";
+    key?: string;
+    id?: string;
+    children: WidgetComponent;
+};
+
+declare function useActionHandler(): ActionHandler_2;
+export { useActionHandler as defaultActionHandler }
+export { useActionHandler as useAction }
+export { useActionHandler }
+
+export declare function useFileUploadState(fileRequestId: string): FileUploadEntry;
+
+export declare function useFormContext(): FormContextValue | null;
+
+export declare function useMessageId(): string | undefined;
+
+export declare function useSelectedCategory(): string | undefined;
+
+export declare function useTheme(): Theme;
+
+export declare function useTokens(): Tokens;
+
+export declare function useVariants(): Variants;
+
+export declare function useWidgetDispatch(): Dispatch<WidgetStateAction>;
+
+export declare function useWidgetState(): WidgetInternalState;
+
+export declare const useWidgetTheme: () => ThemeMode;
+
+export declare function validateFields(fields: FieldDescriptor[]): CoreValidationResult;
+
+export declare function validateForm(form: HTMLFormElement): ValidationResult;
+
+export declare type ValidationError = {
+    name: string;
+    element: HTMLElement;
+    message: string;
+};
+
+export declare type ValidationResult = {
+    valid: boolean;
+    errors: ValidationError[];
+    firstInvalidStepId?: string;
+};
+
+declare interface Variants {
+    button: Record<ButtonVariantKey, Record<StatusColorKey, SurfaceStyle>>;
+    input: Record<InputVariantKey, SurfaceStyle>;
+    badge: Record<BadgeVariantKey, Record<StatusColorKey, SurfaceStyle>>;
+    card: {
+        default: SurfaceStyle;
+    };
+}
+
+export declare function Video(p: Video_2): JSX.Element;
+
+declare type Video_2 = VideoProps;
+
+export declare type VideoProps = {
+    type: "Video";
+    key?: string;
+    id?: string;
+    src: string;
+    poster?: string;
+    fit?: FitMode;
+    position?: ImagePosition;
+    controls?: boolean;
+    autoPlay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    playsInline?: boolean;
+    preload?: PreloadMode;
+    downloadable?: boolean;
+    flush?: boolean;
+} & BlockProps;
+
+export declare const WIDGET_TYPES: {
+    readonly Basic: "Basic";
+    readonly Card: "Card";
+    readonly ListView: "ListView";
+    readonly ListViewItem: "ListViewItem";
+    readonly Box: "Box";
+    readonly Row: "Row";
+    readonly Col: "Col";
+    readonly Form: "Form";
+    readonly Spacer: "Spacer";
+    readonly Divider: "Divider";
+    readonly Transition: "Transition";
+    readonly Title: "Title";
+    readonly Caption: "Caption";
+    readonly Text: "Text";
+    readonly Markdown: "Markdown";
+    readonly Badge: "Badge";
+    readonly Icon: "Icon";
+    readonly Image: "Image";
+    readonly Video: "Video";
+    readonly Button: "Button";
+    readonly Input: "Input";
+    readonly Textarea: "Textarea";
+    readonly Select: "Select";
+    readonly DatePicker: "DatePicker";
+    readonly Checkbox: "Checkbox";
+    readonly RadioGroup: "RadioGroup";
+    readonly Label: "Label";
+    readonly Chart: "Chart";
+    readonly FileUploadRequest: "FileUploadRequest";
+    readonly Map: "Map";
+    readonly MapMarker: "MapMarker";
+    readonly MapPolyline: "MapPolyline";
+    readonly MapCircle: "MapCircle";
+    readonly MapPolygon: "MapPolygon";
+};
+
+export declare interface WidgetBrandingStyles {
+    widgetBg: string;
+    inputBgColor: string;
+    widgetBorderStyle: "none" | "solid" | "dashed" | "dotted";
+    widgetBorderColor: string;
+    widgetBorderWidth: string;
+    widgetBorderOpacity: number;
+    inputBorderStyle: "none" | "solid" | "dashed" | "dotted";
+    inputBorderColor: string;
+    inputBorderWidth: string;
+    inputBorderOpacity: number;
+    primaryText: string;
+    secondaryText: string;
+    tertiaryText: string;
+    placeholderColor: string;
+    statusPrimary: StatusThemeVariant;
+    statusSecondary: StatusThemeVariant;
+    statusSuccess: StatusThemeVariant;
+    statusDanger: StatusThemeVariant;
+    statusWarning: StatusThemeVariant;
+    statusInfo: StatusThemeVariant;
+    statusDiscovery: StatusThemeVariant;
+    fontFamily: string;
+    fontSize: number;
+    borderRadius: number;
+    cornerRadiusMode: "pill" | "rounded" | "sharp";
+}
+
+export declare type WidgetComponent = Text_3 | Title_2 | Caption_2 | Badge_2 | Markdown_2 | Box_2 | Row_2 | Col_2 | Divider_2 | Icon_2 | Image_3 | Video_2 | Button_2 | Checkbox_2 | Chart_2 | Spacer_2 | Select_2 | DatePicker_2 | Form_2 | Input_2 | Label_2 | RadioGroup_2 | Textarea_2 | Transition_2 | ListViewItem_2 | FileUploadRequest_2 | MapWidget | MapMarker | MapPolyline | MapCircle | MapPolygon;
+
+export declare class WidgetErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
+}
+
+export declare type WidgetIcon = string;
+
+export declare interface WidgetInternalState {
+    fileUpload: {
+        files: Record<string, FileUploadEntry>;
+        loading: boolean;
+        error: string | null;
+    };
+    checkboxes: {
+        selected: string[];
+        disabled: string[];
+        maxSelection: number;
+    };
+    quantities: Record<string, number>;
+    selectedCategory?: string;
+    formFields: Record<string, string>;
+}
+
+export declare function WidgetRenderer({ widget, branding, brandingStyles, theme, messageId, onConsumerAction, config, errorFallback, userLocation, }: WidgetRendererProps): default_2.JSX.Element | null;
+
+export declare interface WidgetRendererProps {
+    widget: WidgetRoot | WidgetComponent | null;
+    branding?: BrandingConfig | WidgetBrandingStyles;
+    brandingStyles?: WidgetBrandingStyles;
+    theme?: ThemeMode;
+    messageId?: string;
+    onConsumerAction?: (action: ConsumerAction) => void;
+    config?: DeepPartial<RendererConfig>;
+    errorFallback?: ReactNode;
+    userLocation?: LocationCoordinates | null;
+}
+
+export declare type WidgetRoot = Card_2 | ListView_2 | BasicRoot_2;
+
+export declare type WidgetState = WidgetInternalState;
+
+declare type WidgetStateAction = {
+    type: typeof REDUCER_ACTIONS.TOGGLE_CHECKBOX;
+    payload: {
+        data: string;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.SET_CHECKBOX_DATA;
+    payload: {
+        data: string;
+        checked: boolean;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.CLEAR_SELECTIONS;
+} | {
+    type: typeof REDUCER_ACTIONS.SET_SELECTED_CATEGORY;
+    payload: {
+        id: string;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.TOGGLE_QUANTITY;
+    payload: {
+        id: string;
+        delta: number;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.UPLOAD_FILE;
+    payload: {
+        requestId: string;
+        file: unknown;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.REMOVE_FILE;
+    payload: {
+        requestId: string;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.SET_UPLOAD_ERROR;
+    payload: {
+        requestId: string;
+        error: string | null;
+    };
+} | {
+    type: typeof REDUCER_ACTIONS.RESET_UPLOADS;
+} | {
+    type: typeof REDUCER_ACTIONS.SET_FORM_FIELD;
+    payload: {
+        name: string;
+        value: string;
+    };
+};
+
+export declare function WidgetStateManager({ messageId, children, onConsumerAction, }: WidgetStateManagerProps_2): JSX.Element;
+
+export declare type WidgetStateManagerProps = {
+    messageId?: string;
+    onConsumerAction?: (action: any) => void;
+    children?: ReactNode;
+};
+
+declare interface WidgetStateManagerProps_2 {
+    messageId?: string;
+    children: ReactNode;
+    onConsumerAction?: OnConsumerAction;
+}
+
+export declare const WidgetStateProvider: typeof WidgetStateManager;
+
+export declare type WidgetStateProviderProps = WidgetStateManagerProps;
+
+export declare type WidgetStatus = {
+    text: string;
+    favicon?: string;
+    frame?: boolean;
+    icon?: WidgetIcon;
+    textSize?: TextSize;
+};
+
+export declare type WidgetTheme = "light" | "dark" | string;
+
+export declare const WidgetThemeProvider: typeof ThemeProvider;
+
+export declare type WidgetType = (typeof WIDGET_TYPES)[keyof typeof WIDGET_TYPES];
+
+export declare const WRAP_MODES: {
+    readonly nowrap: "nowrap";
+    readonly wrap: "wrap";
+    readonly "wrap-reverse": "wrap-reverse";
+};
+
+export declare type WrapMode = (typeof WRAP_MODES)[keyof typeof WRAP_MODES];
+
+export declare type XAxisConfig = {
+    dataKey: string;
+    hide?: boolean;
+    labels?: Record<string | number, string>;
+};
+
+export { }