vorma 0.85.0-pre.10 → 0.85.0-pre.12

package/.dist/kit/lab/design/components/remix/remix.d.ts

@@ -0,0 +1,2280 @@
+import { Handle, MixInput, Props, RemixNode } from "remix/ui";
+//#region kit/lab/design/core/color.d.ts
+type OKLCH = {
+  chroma: number;
+  hue: number;
+  lightness: number;
+};
+type Palette<TStep extends string = string> = Record<TStep, string>;
+//#endregion
+//#region kit/lab/design/core/css.d.ts
+type CSSVariableName = `--${string}`;
+type CSSVariableMap = Record<CSSVariableName, string | number>;
+type TokenPrimitive = string | number;
+type TokenReferences<T> = T extends TokenPrimitive ? string : { readonly [K in keyof T]: TokenReferences<T[K]> };
+//#endregion
+//#region kit/lab/design/core/recipe/style.d.ts
+type RecipeStyle = {
+  readonly [property: string]: unknown;
+};
+//#endregion
+//#region kit/lab/design/core/recipe/types.d.ts
+type RecipeConditionMap<TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = Partial<Record<TCondition, TStyle>>;
+type RecipeSlotInput<TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = {
+  base?: TStyle;
+  conditions?: RecipeConditionMap<TCondition, TStyle>;
+};
+type RecipeSlotMapInput<TSlot extends string = string, TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = Record<TSlot, RecipeSlotInput<TCondition, TStyle>>;
+type RecipeVariantSlotMapInput<TSlot extends string = string, TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = Partial<Record<TSlot, RecipeSlotInput<TCondition, TStyle>>>;
+type RecipeVariantGroupInput<TSlot extends string = string, TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = Record<string, RecipeVariantSlotMapInput<TSlot, TCondition, TStyle>>;
+type RecipeVariantsInput<TSlot extends string = string, TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = Record<string, RecipeVariantGroupInput<TSlot, TCondition, TStyle>>;
+type RecipeVariantValueMap = Record<string, string>;
+type RecipeVariantGroupsFor<TSlot extends string, TCondition extends string, TStyle extends RecipeStyle, TVariantValues extends RecipeVariantValueMap> = { readonly [K in keyof TVariantValues & string]: Record<TVariantValues[K], RecipeVariantSlotMapInput<TSlot, TCondition, TStyle>> };
+type RecipeWithVariantGroups<TSlot extends string, TCondition extends string, TStyle extends RecipeStyle, TVariantValues extends RecipeVariantValueMap> = RecipeInput<TSlot, TCondition, TStyle, RecipeVariantGroupsFor<TSlot, TCondition, TStyle, TVariantValues>>;
+type RecipeVariantSelection<TVariants extends RecipeVariantsInput = RecipeVariantsInput> = Partial<{ readonly [K in keyof TVariants & string]: keyof TVariants[K] & string }>;
+type RecipeCompoundVariantInput<TSlot extends string = string, TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle, TVariants extends RecipeVariantsInput<TSlot, TCondition, TStyle> = RecipeVariantsInput<TSlot, TCondition, TStyle>> = {
+  slots: RecipeVariantSlotMapInput<TSlot, TCondition, TStyle>;
+  variants: RecipeVariantSelection<TVariants>;
+};
+type RecipeInput<TSlot extends string = string, TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle, TVariants extends RecipeVariantsInput<TSlot, TCondition, TStyle> = RecipeVariantsInput<TSlot, TCondition, TStyle>> = {
+  compoundVariants?: readonly RecipeCompoundVariantInput<TSlot, TCondition, TStyle, TVariants>[];
+  defaultVariants?: RecipeVariantSelection<TVariants>;
+  slots: RecipeSlotMapInput<TSlot, TCondition, TStyle>;
+  variants?: TVariants;
+};
+type RecipeVariantGroups<TRecipe extends RecipeInput> = TRecipe extends RecipeInput<string, string, RecipeStyle, infer TVariants> ? TVariants : never;
+type RecipeVariantGroupName<TRecipe extends RecipeInput> = keyof RecipeVariantGroups<TRecipe> & string;
+type RecipeVariantValue<TRecipe extends RecipeInput, TGroup extends RecipeVariantGroupName<TRecipe>> = keyof RecipeVariantGroups<TRecipe>[TGroup] & string;
+type RecipeVariantProps<TRecipe extends RecipeInput> = Partial<{ readonly [K in RecipeVariantGroupName<TRecipe>]: RecipeVariantValue<TRecipe, K> }>;
+type RecipeVariantPropsFor<TRecipe extends RecipeInput, TGroups extends RecipeVariantGroupName<TRecipe>> = Pick<RecipeVariantProps<TRecipe>, TGroups>;
+type ResolvedRecipeSlot<TCondition extends string = string, TStyle extends RecipeStyle = RecipeStyle> = {
+  base: TStyle;
+  conditions: RecipeConditionMap<TCondition, TStyle>;
+};
+//#endregion
+//#region kit/lab/design/core/types.d.ts
+declare const primitive_token_keys: {
+  readonly aspect_ratio: "aspect-ratio";
+  readonly data_visualization: "data-visualization";
+  readonly font_family: "font-family";
+  readonly font_size: "font-size";
+  readonly font_weight: "font-weight";
+  readonly letter_spacing: "letter-spacing";
+  readonly line_height: "line-height";
+  readonly stroke_width: "stroke-width";
+  readonly text_style: "text-style";
+};
+declare const token_spec_fields: {
+  readonly mix: "mix";
+  readonly parts: "parts";
+  readonly path: "path";
+};
+declare const token_spec_kinds: {
+  readonly mix: "mix";
+  readonly ref: "ref";
+  readonly template: "template";
+};
+type TokenPath = readonly [string, ...string[]];
+declare const token_spec_kind: unique symbol;
+type TokenReferenceSpec<Path extends TokenPath = TokenPath> = {
+  readonly [token_spec_kind]: typeof token_spec_kinds.ref;
+  readonly [token_spec_fields.path]: Path;
+};
+type TokenMixSpec = {
+  readonly [token_spec_kind]: typeof token_spec_kinds.mix;
+  readonly [token_spec_fields.mix]: {
+    amount: string;
+    color: TokenSpec;
+    space: string;
+    with: TokenSpec;
+  };
+};
+type TokenTemplateSpec = {
+  readonly [token_spec_kind]: typeof token_spec_kinds.template;
+  readonly [token_spec_fields.parts]: readonly TokenSpec[];
+};
+type TokenSpec = string | number | OKLCH | TokenReferenceSpec | TokenMixSpec | TokenTemplateSpec;
+type PrimitiveTextStyleTokens = Partial<{
+  [primitive_token_keys.font_family]: string;
+  [primitive_token_keys.font_size]: string;
+  [primitive_token_keys.font_weight]: string;
+  [primitive_token_keys.letter_spacing]: string;
+  [primitive_token_keys.line_height]: string;
+}>;
+type TokenGroupInput = {
+  readonly [key: string]: TokenSpec | TokenGroupInput | undefined;
+};
+type SemanticInput = {
+  border?: TokenGroupInput;
+  color?: TokenGroupInput;
+  "data-visualization"?: TokenGroupInput;
+  elevation?: TokenGroupInput;
+  focus?: TokenGroupInput;
+  icon?: TokenGroupInput;
+  layout?: TokenGroupInput;
+  outline?: TokenGroupInput;
+  state?: TokenGroupInput;
+  surface?: TokenGroupInput;
+  text?: TokenGroupInput;
+  tone?: TokenGroupInput;
+  typography?: TokenGroupInput;
+  readonly [category: string]: TokenGroupInput | undefined;
+};
+type ResolvedTokenTree<T> = T extends TokenSpec ? string | number : { [K in keyof T as undefined extends T[K] ? never : K]: ResolvedTokenTree<Exclude<T[K], undefined>> };
+type PrimitiveTokens = {
+  border?: {
+    radius?: Record<string, string>;
+    shorthand?: Record<string, string | number>;
+    style?: Record<string, string | number>;
+    width?: Record<string, string>;
+  };
+  color?: {
+    palette?: Record<string, Palette>;
+    source: Record<string, string>;
+  };
+  content?: {
+    "aspect-ratio"?: Record<string, string | number>;
+    measure?: Record<string, string | number>;
+  };
+  "data-visualization"?: {
+    color?: Record<string, string | number>;
+    shape?: Record<string, string | number>;
+    stroke?: Record<string, string | number>;
+  };
+  dimension?: {
+    "aspect-ratio"?: Record<string, string | number>;
+    measure?: Record<string, string | number>;
+    size?: Record<string, Record<string, string>>;
+    space?: Record<string, string>;
+  };
+  effect?: {
+    blur?: Record<string, string | number>;
+    opacity?: Record<string, string | number>;
+    shadow?: Record<string, string | number>;
+  };
+  focus?: {
+    ring?: Record<string, string | number>;
+  };
+  icon?: {
+    asset?: Record<string, string | number>;
+    size?: Record<string, string>;
+    "stroke-width"?: Record<string, string>;
+  };
+  layout?: {
+    breakpoint?: Record<string, string | number>;
+    container?: Record<string, string | number>;
+    grid?: Record<string, string | number>;
+    layer?: Record<string, string | number>;
+  };
+  motion?: {
+    distance?: Record<string, string | number>;
+    duration?: Record<string, string | number>;
+    easing?: Record<string, string | number>;
+    transition?: Record<string, string | number>;
+  };
+  outline?: {
+    offset?: Record<string, string>;
+    shorthand?: Record<string, string | number>;
+    style?: Record<string, string | number>;
+    width?: Record<string, string>;
+  };
+  typography?: {
+    family?: Record<string, string | number>;
+    "letter-spacing"?: Record<string, string | number>;
+    "line-height"?: Record<string, string | number>;
+    size?: Record<string, string>;
+    "text-style"?: Record<string, PrimitiveTextStyleTokens>;
+    weight?: Record<string, string | number>;
+  };
+};
+type SystemTokens = {
+  primitive?: PrimitiveTokens;
+  semantic?: ResolvedTokenTree<SemanticInput>;
+};
+type AnyGeneratedSystemMetadata = GeneratedSystemMetadata<never> | GeneratedSystemMetadata<string>;
+type GeneratedSystem<TMode extends string = string, TTokenReferences = TokenReferences<SystemTokens>, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = {
+  metadata: TMetadata;
+  modes: Record<TMode, GeneratedSystemMode>;
+  variablePrefix: string;
+  token: TTokenReferences;
+};
+type GeneratedSystemMode = {
+  variables: CSSVariableMap;
+};
+type GeneratedSystemMetadata<TBreakpoint extends string = never> = [TBreakpoint] extends [never] ? {
+  breakpoint?: undefined;
+} : {
+  breakpoint: Record<TBreakpoint, string | number>;
+};
+//#endregion
+//#region kit/lab/design/components/remix/conditions.d.ts
+type CommonRecipeCondition = "active" | "disabled" | "focusVisible" | "hover" | "idle" | "invalid" | "placeholder" | "reducedMotion" | "selected";
+declare const commonConditions: {
+  readonly active: "&:active";
+  readonly disabled: "&:disabled, &[aria-disabled='true'], &[data-disabled]";
+  readonly focusVisible: "&:focus-visible";
+  readonly hover: "&:hover";
+  readonly idle: "&[data-idle='true']";
+  readonly invalid: "&[aria-invalid='true'], &[data-invalid]";
+  readonly placeholder: "&::placeholder";
+  readonly reducedMotion: "@media (prefers-reduced-motion: reduce)";
+  readonly selected: "&[aria-selected='true'], &[data-selected]";
+};
+//#endregion
+//#region kit/lab/design/components/remix/recipe.d.ts
+type RecipeConditionSelectorMap<TCondition extends string = string> = Partial<Readonly<Record<TCondition, string>>>;
+declare function mergeRecipeConditionSelectors<TCondition extends string>(...maps: readonly (RecipeConditionSelectorMap<TCondition> | undefined)[]): RecipeConditionSelectorMap<TCondition>;
+type RecipeStyleInput<TCondition extends string = string> = {
+  conditions?: RecipeConditionSelectorMap;
+  slot: ResolvedRecipeSlot<TCondition, RecipeStyle>;
+  style?: RecipeStyle;
+};
+declare function createRecipeStyle<TCondition extends string>(input: RecipeStyleInput<TCondition>): RecipeStyle;
+declare function createRecipeMix<TElement extends Element = Element, TCondition extends string = string>(input: RecipeStyleInput<TCondition>): MixInput<TElement>;
+//#endregion
+//#region kit/lab/design/components/remix/types.d.ts
+type ComponentStyle = RecipeStyle;
+type RemixComponent<TProps extends object = Record<string, unknown>, TContext = Record<string, never>> = (handle: Handle<TProps, TContext>) => (props: TProps) => RemixNode;
+type ComponentStyleSystem<TMode extends string = string, TToken = unknown, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = GeneratedSystem<TMode, TToken, TMetadata>;
+//#endregion
+//#region kit/lab/design/components/remix/responsive.d.ts
+type MetadataBreakpoint<TMetadata> = TMetadata extends {
+  breakpoint: Record<infer TBreakpoint, string | number>;
+} ? TBreakpoint & string : never;
+type ResponsiveProps<TProps extends object, TBreakpoint extends string> = {
+  at?: Partial<Record<TBreakpoint, Partial<TProps>>>;
+};
+type BreakpointForStyleSystem<TStyleSystem> = TStyleSystem extends ComponentStyleSystem<string, unknown, infer TMetadata> ? MetadataBreakpoint<TMetadata> : never;
+declare function createResponsiveStyle<TProps extends object, TMode extends string, TToken, TMetadata extends {
+  breakpoint?: Record<string, string | number>;
+}>(input: {
+  at: Partial<Record<string, Partial<TProps>>> | undefined;
+  resolve: (props: Partial<TProps>) => RecipeStyle | undefined;
+  styleSystem: ComponentStyleSystem<TMode, TToken, TMetadata>;
+}): RecipeStyle | undefined;
+declare function createResponsiveRecipeStyle<TProps extends object, TCondition extends string, TMode extends string, TToken, TMetadata extends {
+  breakpoint?: Record<string, string | number>;
+}>(input: {
+  at: Partial<Record<string, Partial<TProps>>> | undefined;
+  conditions?: RecipeConditionSelectorMap;
+  resolve: (props: Partial<TProps>) => ResolvedRecipeSlot<TCondition, RecipeStyle> | undefined;
+  styleSystem: ComponentStyleSystem<TMode, TToken, TMetadata>;
+}): RecipeStyle | undefined;
+//#endregion
+//#region kit/lab/design/components/remix/accordion.d.ts
+type AccordionRecipeCondition = CommonRecipeCondition | "closed" | "open";
+type AccordionRecipeInput<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"item" | "panel" | "root" | "trigger", string, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type AccordionRecipeLayout<TRecipe extends AccordionRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type AccordionRecipeVariant<TRecipe extends AccordionRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type AccordionRecipeSize<TRecipe extends AccordionRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type AccordionRecipeSelection<TRecipe extends AccordionRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "variant">;
+type AccordionStyleSystem<TMode extends string = string, TRecipe extends AccordionRecipeInput = AccordionRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    accordion: TRecipe;
+  };
+}, TMetadata>;
+type AccordionValue = string | readonly string[] | null;
+type AccordionValueChangeDetails = {
+  event?: Event;
+};
+type AccordionValueChangeHandler = (value: AccordionValue, details?: AccordionValueChangeDetails) => void;
+type AccordionRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type AccordionItemStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type AccordionRootProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & AccordionRootStyleProps<TLayout> & ResponsiveProps<AccordionRootStyleProps<TLayout>, TBreakpoint> & {
+  defaultValue?: AccordionValue;
+  multiple?: boolean;
+  onValueChange?: AccordionValueChangeHandler;
+  style?: never;
+  value?: AccordionValue;
+};
+type AccordionItemProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & AccordionItemStyleProps<TVariant, TSize> & ResponsiveProps<AccordionItemStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+  value: string;
+};
+type AccordionTriggerProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type AccordionPanelProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type AccordionComponents<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = {
+  Item: RemixComponent<AccordionItemProps<TVariant, TSize>, AccordionItemContext>;
+  Panel: RemixComponent<AccordionPanelProps>;
+  Root: RemixComponent<AccordionRootProps<TLayout>, AccordionRootContext>;
+  Trigger: RemixComponent<AccordionTriggerProps>;
+};
+type AccordionRootContext = {
+  get_multiple: () => boolean;
+  is_open: (value: string) => boolean;
+  toggle_value: (value: string, details?: AccordionValueChangeDetails) => void;
+};
+type AccordionItemContext = {
+  get_at: () => Partial<Record<string, Partial<AccordionItemStyleProps>>> | undefined;
+  get_open: () => boolean;
+  get_panel_id: () => string;
+  get_style_props: () => Partial<AccordionItemStyleProps>;
+  get_trigger_id: () => string;
+  get_value: () => string;
+  toggle: (details?: AccordionValueChangeDetails) => void;
+};
+declare function createAccordion<TMode extends string, TRecipe extends AccordionRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: AccordionStyleSystem<TMode, TRecipe, TMetadata>): AccordionComponents<AccordionRecipeLayout<TRecipe>, AccordionRecipeVariant<TRecipe>, AccordionRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/alert-dialog.d.ts
+type AlertDialogRecipeCondition = CommonRecipeCondition | "closed" | "open";
+type AlertDialogRecipeInput<TLayout extends string = string> = RecipeWithVariantGroups<"action" | "cancel" | "description" | "overlay" | "popup" | "title" | "trigger", string, ComponentStyle, {
+  layout: TLayout;
+}>;
+type AlertDialogRecipeLayout<TRecipe extends AlertDialogRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type AlertDialogRecipeSelection<TRecipe extends AlertDialogRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout">;
+type AlertDialogStyleSystem<TMode extends string = string, TRecipe extends AlertDialogRecipeInput = AlertDialogRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    alertDialog: TRecipe;
+  };
+}, TMetadata>;
+type AlertDialogOpenChangeReason = "action" | "cancel" | "escape" | "trigger";
+type AlertDialogOpenChangeDetails = {
+  event?: Event;
+  reason: AlertDialogOpenChangeReason;
+};
+type AlertDialogOpenChangeHandler = (open: boolean, details?: AlertDialogOpenChangeDetails) => void;
+type AlertDialogRootProps = {
+  children?: RemixNode;
+  defaultOpen?: boolean;
+  onOpenChange?: AlertDialogOpenChangeHandler;
+  onOpenChangeComplete?: AlertDialogOpenChangeHandler;
+  open?: boolean;
+};
+type AlertDialogPopupStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type AlertDialogTriggerProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type AlertDialogPopupProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"dialog">, "style"> & AlertDialogPopupStyleProps<TLayout> & ResponsiveProps<AlertDialogPopupStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type AlertDialogTitleProps = Omit<Props<"h2">, "style"> & {
+  style?: never;
+};
+type AlertDialogDescriptionProps = Omit<Props<"p">, "style"> & {
+  style?: never;
+};
+type AlertDialogActionProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type AlertDialogCancelProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type AlertDialogComponents<TLayout extends string = string> = {
+  Action: RemixComponent<AlertDialogActionProps>;
+  Cancel: RemixComponent<AlertDialogCancelProps>;
+  Description: RemixComponent<AlertDialogDescriptionProps>;
+  Popup: RemixComponent<AlertDialogPopupProps<TLayout>>;
+  Root: RemixComponent<AlertDialogRootProps, AlertDialogContext>;
+  Title: RemixComponent<AlertDialogTitleProps>;
+  Trigger: RemixComponent<AlertDialogTriggerProps>;
+};
+type AlertDialogContext = {
+  get_description_id: () => string;
+  get_open: () => boolean;
+  get_title_id: () => string;
+  set_open: (open: boolean, details?: AlertDialogOpenChangeDetails) => void;
+};
+declare function createAlertDialog<TMode extends string, TRecipe extends AlertDialogRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: AlertDialogStyleSystem<TMode, TRecipe, TMetadata>): AlertDialogComponents<AlertDialogRecipeLayout<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/alert.d.ts
+declare const alert_slot: {
+  readonly description: "description";
+  readonly icon: "icon";
+  readonly root: "root";
+  readonly title: "title";
+};
+type AlertRecipeSlot = (typeof alert_slot)[keyof typeof alert_slot];
+type AlertRecipeInput<TTone extends string = string, TVariant extends string = string> = RecipeWithVariantGroups<AlertRecipeSlot, string, ComponentStyle, {
+  tone: TTone;
+  variant: TVariant;
+}>;
+type AlertRecipeTone<TRecipe extends AlertRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type AlertRecipeVariant<TRecipe extends AlertRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type AlertRecipeSelection<TRecipe extends AlertRecipeInput> = RecipeVariantPropsFor<TRecipe, "tone" | "variant">;
+type AlertStyleSystem<TMode extends string = string, TRecipe extends AlertRecipeInput = AlertRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    alert: TRecipe;
+  };
+}, TMetadata>;
+type AlertRootStyleProps<TTone extends string = string, TVariant extends string = string> = {
+  tone?: TTone;
+  variant?: TVariant;
+};
+type AlertRootProps<TTone extends string = string, TVariant extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & AlertRootStyleProps<TTone, TVariant> & ResponsiveProps<AlertRootStyleProps<TTone, TVariant>, TBreakpoint> & {
+  style?: never;
+};
+type AlertIconProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type AlertTitleProps = Omit<Props<"h2">, "style"> & {
+  style?: never;
+};
+type AlertDescriptionProps = Omit<Props<"p">, "style"> & {
+  style?: never;
+};
+type AlertComponents<TTone extends string = string, TVariant extends string = string> = {
+  Description: RemixComponent<AlertDescriptionProps>;
+  Icon: RemixComponent<AlertIconProps>;
+  Root: RemixComponent<AlertRootProps<TTone, TVariant>>;
+  Title: RemixComponent<AlertTitleProps>;
+};
+declare function createAlert<TMode extends string, TRecipe extends AlertRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: AlertStyleSystem<TMode, TRecipe, TMetadata>): AlertComponents<AlertRecipeTone<TRecipe>, AlertRecipeVariant<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/aspect-ratio.d.ts
+type AspectRatioOverflow = "auto" | "clip" | "hidden" | "visible";
+type AspectRatioStyleProps = {
+  height?: number | string;
+  minHeight?: number | string;
+  overflow?: AspectRatioOverflow;
+  ratio?: string;
+  width?: number | string;
+};
+type AspectRatioProps<TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & AspectRatioStyleProps & ResponsiveProps<AspectRatioStyleProps, TBreakpoint> & {
+  style?: never;
+};
+declare function createAspectRatio<TMode extends string, TMetadata extends {
+  breakpoint?: Record<string, string | number>;
+}>(style_system: ComponentStyleSystem<TMode, unknown, TMetadata>): RemixComponent<AspectRatioProps<BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/root.d.ts
+type RootRecipeInput<TGroups extends Record<string, string>> = RecipeWithVariantGroups<"root", string, ComponentStyle, TGroups>;
+type RootStyleSystem<TMode extends string = string, TRecipe extends RootRecipeInput<Record<string, string>> = RootRecipeInput<Record<string, string>>, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata, TRecipeName extends string = string> = ComponentStyleSystem<TMode, {
+  recipe: Record<TRecipeName, TRecipe>;
+}, TMetadata>;
+type RootHostProps<TElement extends keyof HTMLElementTagNameMap> = Omit<Props<TElement>, "style"> & {
+  as?: TElement;
+  style?: never;
+};
+type RootComponentProps<TGroups extends string, TRecipe extends RootRecipeInput<Record<TGroups, string>>, TBreakpoint extends string> = RootHostProps<keyof HTMLElementTagNameMap> & Partial<RecipeVariantPropsFor<TRecipe, TGroups>> & ResponsiveProps<RecipeVariantPropsFor<TRecipe, TGroups>, TBreakpoint>;
+type RootComponent<TGroups extends string, TRecipe extends RootRecipeInput<Record<TGroups, string>>, TBreakpoint extends string> = RemixComponent<RootComponentProps<TGroups, TRecipe, TBreakpoint>>;
+//#endregion
+//#region kit/lab/design/components/remix/badge.d.ts
+type BadgeRecipeInput<TTone extends string = string, TSize extends string = string> = RootRecipeInput<{
+  size: TSize;
+  tone: TTone;
+}>;
+type BadgeRecipeTone<TRecipe extends BadgeRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type BadgeRecipeSize<TRecipe extends BadgeRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type BadgeStyleSystem<TMode extends string = string, TRecipe extends BadgeRecipeInput = BadgeRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = RootStyleSystem<TMode, TRecipe, TMetadata, "badge">;
+declare function createBadge<TMode extends string, TRecipe extends BadgeRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: BadgeStyleSystem<TMode, TRecipe, TMetadata>): RootComponent<"size" | "tone", TRecipe, BreakpointForStyleSystem<BadgeStyleSystem<TMode, TRecipe, TMetadata>>>;
+//#endregion
+//#region kit/lab/design/components/remix/box.d.ts
+type BoxRecipeInput<TLayout extends string = string> = RootRecipeInput<{
+  layout: TLayout;
+}>;
+type BoxRecipeLayout<TRecipe extends BoxRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type BoxStyleSystem<TMode extends string = string, TRecipe extends BoxRecipeInput = BoxRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = RootStyleSystem<TMode, TRecipe, TMetadata, "box">;
+declare function createBox<TMode extends string, TRecipe extends BoxRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: RootStyleSystem<TMode, TRecipe, TMetadata, "box">): RootComponent<"layout", TRecipe, BreakpointForStyleSystem<RootStyleSystem<TMode, TRecipe, TMetadata, "box">>>;
+//#endregion
+//#region kit/lab/design/components/remix/button.d.ts
+declare const button_slot: {
+  readonly content: "content";
+  readonly loading_indicator: "loadingIndicator";
+  readonly loading_indicator_frame: "loadingIndicatorFrame";
+  readonly root: "root";
+};
+type ButtonRecipeSlot = (typeof button_slot)[keyof typeof button_slot];
+type ButtonRecipeCondition = "active" | "disabled" | "focusVisible" | "hover" | "reducedMotion";
+type ButtonRecipeInput<TVariant extends string = string, TSize extends string = string, TLayout extends string = string> = RecipeWithVariantGroups<ButtonRecipeSlot, string, ComponentStyle, {
+  fluid: "true";
+  layout: TLayout;
+  loading: "true";
+  size: TSize;
+  variant: TVariant;
+}>;
+type ButtonRecipeVariant<TRecipe extends ButtonRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type ButtonRecipeSize<TRecipe extends ButtonRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type ButtonRecipeLayout<TRecipe extends ButtonRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type ButtonRecipeSelection<TRecipe extends ButtonRecipeInput> = RecipeVariantPropsFor<TRecipe, "fluid" | "layout" | "loading" | "size" | "variant">;
+type ButtonStyleSystem<TMode extends string = string, TRecipe extends ButtonRecipeInput = ButtonRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    button: TRecipe;
+  };
+}, TMetadata>;
+type ButtonStyleProps<TVariant extends string = string, TSize extends string = string, TLayout extends string = string> = {
+  fluid?: boolean;
+  layout?: TLayout;
+  size?: TSize;
+  variant?: TVariant;
+};
+type ButtonHostProps = Props<"button">;
+type ButtonProps<TVariant extends string = string, TSize extends string = string, TLayout extends string = string, TBreakpoint extends string = string> = Omit<ButtonHostProps, "style"> & ButtonStyleProps<TVariant, TSize, TLayout> & ResponsiveProps<ButtonStyleProps<TVariant, TSize, TLayout>, TBreakpoint> & {
+  loading?: boolean;
+  loadingLabel?: string;
+  style?: never;
+};
+type ButtonOptions = {
+  conditions?: Partial<Readonly<Record<ButtonRecipeSlot, RecipeConditionSelectorMap<string>>>>;
+};
+declare function createButton<TMode extends string, TRecipe extends ButtonRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ButtonStyleSystem<TMode, TRecipe, TMetadata>, options?: ButtonOptions): RemixComponent<ButtonProps<ButtonRecipeVariant<TRecipe>, ButtonRecipeSize<TRecipe>, ButtonRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/component-style.d.ts
+declare const component_scope_attribute = "data-vorma-scope";
+declare const component_part_attribute = "data-vorma-part";
+type ComponentRecipeStyleMetadata = {
+  breakpoint?: Record<string, string | number>;
+};
+type ComponentStyleHostElementName = keyof HTMLElementTagNameMap;
+type ComponentStyleHostElementMap<THost extends string> = Partial<Readonly<Record<THost, ComponentStyleHostElementName>>>;
+type ComponentStyleHostElement<THost extends string, THostElements extends ComponentStyleHostElementMap<THost>, TKey extends THost> = TKey extends keyof THostElements ? THostElements[TKey] extends ComponentStyleHostElementName ? HTMLElementTagNameMap[THostElements[TKey]] : Element : Element;
+declare const componentAnatomyAttrs: {
+  readonly part: "data-vorma-part";
+  readonly scope: "data-vorma-scope";
+};
+type ComponentAnatomyAttrs = {
+  readonly [component_part_attribute]: string;
+  readonly [component_scope_attribute]: string;
+};
+type ComponentSlotProps<TElement extends keyof HTMLElementTagNameMap> = Omit<Props<TElement>, "style"> & {
+  style?: never;
+};
+type ComponentSlotOwnProps = {
+  mix?: unknown;
+};
+type ComponentSlotInputProps<TProps extends object> = TProps & ComponentSlotOwnProps;
+declare function createComponentSlotProps<TProps extends object = {}>(input: {
+  attrs: ComponentAnatomyAttrs;
+  mix?: unknown;
+  props?: ComponentSlotInputProps<TProps>;
+}): Omit<ComponentSlotInputProps<TProps>, "mix"> & ComponentAnatomyAttrs & {
+  mix: unknown[];
+};
+type ComponentStyleTargetRecipeInput<TProps extends object, TCondition extends string> = {
+  conditions?: RecipeConditionSelectorMap;
+  resolveSlot: (props: Partial<TProps>) => ResolvedRecipeSlot<TCondition, RecipeStyle>;
+  resolveStyle?: (props: Partial<TProps>) => RecipeStyle | undefined;
+  style?: RecipeStyle;
+};
+type ComponentStyleTargetInput<TProps extends object, THost extends string, TCondition extends string> = ComponentStyleTargetRecipeInput<TProps, TCondition> & {
+  host: THost;
+  selectors?: readonly string[];
+};
+type ComponentStyleTargetsInput<TProps extends object, THost extends string, TTarget extends string, TCondition extends string, TMode extends string, TToken, TMetadata extends ComponentRecipeStyleMetadata, THostElements extends ComponentStyleHostElementMap<THost> = {}> = {
+  at?: Partial<Record<string, Partial<TProps>>>;
+  hostElements?: THostElements;
+  props: Partial<TProps>;
+  styleSystem: ComponentStyleSystem<TMode, TToken, TMetadata>;
+  targets: Record<TTarget, ComponentStyleTargetInput<TProps, THost, TCondition>>;
+};
+type ComponentStyleTargetOutput<TElement extends Element = Element> = {
+  mix: MixInput<TElement>;
+  style: RecipeStyle;
+};
+type ComponentStyleTargetsOutput<THost extends string, TTarget extends string, THostElements extends ComponentStyleHostElementMap<THost> = {}> = {
+  readonly hosts: { readonly [K in THost]: ComponentStyleTargetOutput<ComponentStyleHostElement<THost, THostElements, K>> };
+  readonly targets: { readonly [K in TTarget]: ComponentStyleTargetOutput };
+};
+declare function createComponentAnatomyAttrs(scope: string, part: string): ComponentAnatomyAttrs;
+declare function createComponentStyleTargets<TProps extends object, THost extends string, TTarget extends string, TCondition extends string, TMode extends string, TToken, TMetadata extends ComponentRecipeStyleMetadata, THostElements extends ComponentStyleHostElementMap<THost> = {}>(input: ComponentStyleTargetsInput<TProps, THost, TTarget, TCondition, TMode, TToken, TMetadata, THostElements>): ComponentStyleTargetsOutput<THost, TTarget, THostElements>;
+//#endregion
+//#region kit/lab/design/components/remix/callout.d.ts
+type CalloutRecipeInput<TTone extends string = string> = RecipeWithVariantGroups<"content" | "icon" | "root", never, ComponentStyle, {
+  tone: TTone;
+}>;
+type CalloutRecipeTone<TRecipe extends CalloutRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type CalloutRecipeSelection<TRecipe extends CalloutRecipeInput> = RecipeVariantPropsFor<TRecipe, "tone">;
+type CalloutStyleSystem<TMode extends string = string, TRecipe extends CalloutRecipeInput = CalloutRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    callout: TRecipe;
+  };
+}, TMetadata>;
+type CalloutProps<TTone extends string = string> = Omit<Props<"div">, "style"> & {
+  contentProps?: ComponentSlotProps<"div">;
+  icon?: RemixNode;
+  iconProps?: ComponentSlotProps<"span">;
+  style?: never;
+  tone?: TTone;
+};
+declare function createCallout<TMode extends string, TRecipe extends CalloutRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: CalloutStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<CalloutProps<CalloutRecipeTone<TRecipe>>>;
+//#endregion
+//#region kit/lab/design/components/remix/checkbox-group.d.ts
+type CheckboxGroupRecipeCondition = CommonRecipeCondition | "checked" | "unchecked";
+type CheckboxGroupRecipeInput<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"item" | "root", string, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type CheckboxGroupRecipeLayout<TRecipe extends CheckboxGroupRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type CheckboxGroupRecipeVariant<TRecipe extends CheckboxGroupRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type CheckboxGroupRecipeSize<TRecipe extends CheckboxGroupRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type CheckboxGroupRecipeSelection<TRecipe extends CheckboxGroupRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "variant">;
+type CheckboxGroupStyleSystem<TMode extends string = string, TRecipe extends CheckboxGroupRecipeInput = CheckboxGroupRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    checkboxGroup: TRecipe;
+  };
+}, TMetadata>;
+type CheckboxGroupValueChangeDetails = {
+  event?: Event;
+};
+type CheckboxGroupValueChangeHandler<TValue extends string = string> = (value: readonly TValue[], details?: CheckboxGroupValueChangeDetails) => void;
+type CheckboxGroupRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type CheckboxGroupItemStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type CheckboxGroupRootProps<TLayout extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"div">, "style"> & CheckboxGroupRootStyleProps<TLayout> & ResponsiveProps<CheckboxGroupRootStyleProps<TLayout>, TBreakpoint> & {
+  defaultValue?: readonly TValue[];
+  disabled?: boolean;
+  form?: string;
+  name?: string;
+  onValueChange?: CheckboxGroupValueChangeHandler<TValue>;
+  required?: boolean;
+  style?: never;
+  value?: readonly TValue[];
+};
+type CheckboxGroupItemProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"input">, "checked" | "defaultChecked" | "name" | "style" | "type" | "value"> & CheckboxGroupItemStyleProps<TVariant, TSize> & ResponsiveProps<CheckboxGroupItemStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+  value: TValue;
+};
+type CheckboxGroupComponents<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = {
+  Item: RemixComponent<CheckboxGroupItemProps<TVariant, TSize>>;
+  Root: RemixComponent<CheckboxGroupRootProps<TLayout>, CheckboxGroupContext>;
+};
+type CheckboxGroupContext = {
+  get_disabled: () => boolean;
+  get_form: () => string | undefined;
+  get_name: () => string | undefined;
+  get_required: () => boolean;
+  get_values: () => readonly string[];
+  set_item_checked: (value: string, checked: boolean, details?: CheckboxGroupValueChangeDetails) => void;
+};
+declare function createCheckboxGroup<TMode extends string, TRecipe extends CheckboxGroupRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: CheckboxGroupStyleSystem<TMode, TRecipe, TMetadata>): CheckboxGroupComponents<CheckboxGroupRecipeLayout<TRecipe>, CheckboxGroupRecipeVariant<TRecipe>, CheckboxGroupRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/checkable-state.d.ts
+declare const checkableState: {
+  readonly checked: "checked";
+  readonly indeterminate: "indeterminate";
+  readonly unchecked: "unchecked";
+};
+type CheckableStateName = (typeof checkableState)[keyof typeof checkableState];
+type CheckableChecked = boolean | typeof checkableState.indeterminate;
+//#endregion
+//#region kit/lab/design/components/remix/checkbox.d.ts
+type CheckboxRecipeCondition = CommonRecipeCondition | "checked" | "indeterminate" | "unchecked";
+type CheckboxChecked = CheckableChecked;
+type CheckboxRecipeInput<TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  size: TSize;
+  variant: TVariant;
+}>;
+type CheckboxRecipeVariant<TRecipe extends CheckboxRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type CheckboxRecipeSize<TRecipe extends CheckboxRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type CheckboxRecipeSelection<TRecipe extends CheckboxRecipeInput> = RecipeVariantPropsFor<TRecipe, "size" | "variant">;
+type CheckboxStyleSystem<TMode extends string = string, TRecipe extends CheckboxRecipeInput = CheckboxRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    checkbox: TRecipe;
+  };
+}, TMetadata>;
+type CheckboxProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"input">, "checked" | "defaultChecked" | "style" | "type"> & Partial<CheckboxRecipeSelection<CheckboxRecipeInput<TVariant, TSize>>> & ResponsiveProps<CheckboxRecipeSelection<CheckboxRecipeInput<TVariant, TSize>>, TBreakpoint> & {
+  checked?: CheckboxChecked;
+  defaultChecked?: CheckboxChecked;
+  style?: never;
+};
+declare function createCheckbox<TMode extends string, TRecipe extends CheckboxRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: CheckboxStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<CheckboxProps<CheckboxRecipeVariant<TRecipe>, CheckboxRecipeSize<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/chip.d.ts
+type ChipRecipeInput<TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  selected: "false" | "true";
+  size: TSize;
+  variant: TVariant;
+}>;
+type ChipRecipeVariant<TRecipe extends ChipRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type ChipRecipeSize<TRecipe extends ChipRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type ChipRecipeSelection<TRecipe extends ChipRecipeInput> = RecipeVariantPropsFor<TRecipe, "selected" | "size" | "variant">;
+type ChipStyleSystem<TMode extends string = string, TRecipe extends ChipRecipeInput = ChipRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    chip: TRecipe;
+  };
+}, TMetadata>;
+type ChipStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  selected?: boolean;
+  size?: TSize;
+  variant?: TVariant;
+};
+type ChipProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style"> & ChipStyleProps<TVariant, TSize> & ResponsiveProps<ChipStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+};
+declare function createChip<TMode extends string, TRecipe extends ChipRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ChipStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<ChipProps<ChipRecipeVariant<TRecipe>, ChipRecipeSize<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/code-block.d.ts
+type CodeBlockRecipeInput = RecipeWithVariantGroups<"caption" | "code" | "header" | "pre" | "root", never, ComponentStyle, Record<string, never>>;
+type CodeBlockStyleSystem<TMode extends string = string, TRecipe extends CodeBlockRecipeInput = CodeBlockRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    codeBlock: TRecipe;
+  };
+}, TMetadata>;
+type CodeBlockProps = Omit<Props<"figure">, "style"> & {
+  caption?: RemixNode;
+  captionProps?: ComponentSlotProps<"figcaption">;
+  codeProps?: ComponentSlotProps<"code">;
+  header?: RemixNode;
+  headerProps?: ComponentSlotProps<"div">;
+  preProps?: ComponentSlotProps<"pre">;
+  style?: never;
+};
+declare function createCodeBlock<TMode extends string, TRecipe extends CodeBlockRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: CodeBlockStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<CodeBlockProps>;
+//#endregion
+//#region kit/lab/design/components/remix/collapsible.d.ts
+type CollapsibleRecipeCondition = CommonRecipeCondition | "closed" | "open";
+type CollapsibleRecipeInput<TLayout extends string = string> = RecipeWithVariantGroups<"content" | "root" | "trigger", string, ComponentStyle, {
+  layout: TLayout;
+}>;
+type CollapsibleRecipeLayout<TRecipe extends CollapsibleRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type CollapsibleRecipeSelection<TRecipe extends CollapsibleRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout">;
+type CollapsibleStyleSystem<TMode extends string = string, TRecipe extends CollapsibleRecipeInput = CollapsibleRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    collapsible: TRecipe;
+  };
+}, TMetadata>;
+type CollapsibleOpenChangeDetails = {
+  event?: Event;
+  reason: "trigger";
+};
+type CollapsibleOpenChangeHandler = (open: boolean, details?: CollapsibleOpenChangeDetails) => void;
+type CollapsibleRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type CollapsibleRootProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & CollapsibleRootStyleProps<TLayout> & ResponsiveProps<CollapsibleRootStyleProps<TLayout>, TBreakpoint> & {
+  defaultOpen?: boolean;
+  onOpenChange?: CollapsibleOpenChangeHandler;
+  onOpenChangeComplete?: CollapsibleOpenChangeHandler;
+  open?: boolean;
+  style?: never;
+};
+type CollapsibleTriggerProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type CollapsibleContentProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type CollapsibleComponents<TLayout extends string = string> = {
+  Content: RemixComponent<CollapsibleContentProps>;
+  Root: RemixComponent<CollapsibleRootProps<TLayout>, CollapsibleContext>;
+  Trigger: RemixComponent<CollapsibleTriggerProps>;
+};
+type CollapsibleContext = {
+  get_content_id: () => string;
+  get_open: () => boolean;
+  get_trigger_id: () => string;
+  toggle: (details: CollapsibleOpenChangeDetails) => void;
+};
+declare function createCollapsible<TMode extends string, TRecipe extends CollapsibleRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: CollapsibleStyleSystem<TMode, TRecipe, TMetadata>): CollapsibleComponents<CollapsibleRecipeLayout<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/component-state.d.ts
+declare const componentStateAttribute = "data-state";
+declare const componentDataAttribute: {
+  readonly disabled: "data-disabled";
+  readonly highlighted: "data-highlighted";
+  readonly invalid: "data-invalid";
+  readonly open: "data-open";
+  readonly placeholder: "data-placeholder";
+  readonly readOnly: "data-readonly";
+  readonly required: "data-required";
+  readonly selected: "data-selected";
+};
+type ARIABoolean = "false" | "true";
+declare function ariaBoolean(value: boolean): ARIABoolean;
+declare function ariaTrue(value: boolean): "true" | undefined;
+declare function dataFlag(value: boolean): "" | undefined;
+declare const openState: {
+  readonly closed: "closed";
+  readonly open: "open";
+};
+type OpenStateName = (typeof openState)[keyof typeof openState];
+declare const selectionState: {
+  readonly selected: "selected";
+  readonly unselected: "unselected";
+};
+type SelectionStateName = (typeof selectionState)[keyof typeof selectionState];
+declare function openStateFromBoolean(open: boolean): OpenStateName;
+declare function selectionStateFromBoolean(selected: boolean): SelectionStateName;
+//#endregion
+//#region kit/lab/design/components/remix/description-list.d.ts
+type DescriptionListRecipeInput<TTone extends string = string, TDescriptionTone extends string = string, TLayout extends string = string> = RecipeWithVariantGroups<"description" | "item" | "root" | "term", never, ComponentStyle, {
+  descriptionTone: TDescriptionTone;
+  layout: TLayout;
+  tone: TTone;
+}>;
+type DescriptionListRecipeTone<TRecipe extends DescriptionListRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type DescriptionListRecipeDescriptionTone<TRecipe extends DescriptionListRecipeInput> = RecipeVariantValue<TRecipe, "descriptionTone">;
+type DescriptionListLayout<TRecipe extends DescriptionListRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type DescriptionListRecipeSelection<TRecipe extends DescriptionListRecipeInput> = RecipeVariantPropsFor<TRecipe, "descriptionTone" | "layout" | "tone">;
+type DescriptionListStyleSystem<TMode extends string = string, TRecipe extends DescriptionListRecipeInput = DescriptionListRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    descriptionList: TRecipe;
+  };
+}, TMetadata>;
+type DescriptionListProps = Omit<Props<"dl">, "style"> & {
+  style?: never;
+};
+type DescriptionListItemStyleProps<TDescriptionTone extends string = string, TTone extends string = string, TLayout extends string = string> = {
+  descriptionTone?: TDescriptionTone;
+  layout?: TLayout;
+  tone?: TTone;
+};
+type DescriptionListItemProps<TDescriptionTone extends string = string, TTone extends string = string, TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & DescriptionListItemStyleProps<TDescriptionTone, TTone, TLayout> & ResponsiveProps<DescriptionListItemStyleProps<TDescriptionTone, TTone, TLayout>, TBreakpoint> & {
+  descriptionProps?: ComponentSlotProps<"dd">;
+  style?: never;
+  term: RemixNode;
+  termProps?: ComponentSlotProps<"dt">;
+};
+declare function createDescriptionList<TMode extends string, TRecipe extends DescriptionListRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: DescriptionListStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<DescriptionListProps>;
+declare function createDescriptionListItem<TMode extends string, TRecipe extends DescriptionListRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: DescriptionListStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<DescriptionListItemProps<DescriptionListRecipeDescriptionTone<TRecipe>, DescriptionListRecipeTone<TRecipe>, DescriptionListLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/dialog.d.ts
+type DialogRequiredRecipeSlot = "close" | "description" | "popup" | "title" | "trigger";
+type DialogRecipeSlot = DialogRequiredRecipeSlot | "overlay";
+type DialogRecipeCondition = "active" | "disabled" | "focusVisible" | "hover" | "modal" | "open" | "reducedMotion";
+type DialogRecipeInput<TPopupLayout extends string = string> = RecipeWithVariantGroups<DialogRequiredRecipeSlot, string, ComponentStyle, {
+  popupLayout: TPopupLayout;
+}>;
+type DialogRecipePopupLayout<TRecipe extends DialogRecipeInput> = RecipeVariantValue<TRecipe, "popupLayout">;
+type DialogRecipeSelection<TRecipe extends DialogRecipeInput> = RecipeVariantPropsFor<TRecipe, "popupLayout">;
+type DialogStyleSystem<TMode extends string = string, TRecipe extends DialogRecipeInput = DialogRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    dialog: TRecipe;
+  };
+}, TMetadata>;
+declare const dialog_open_change_reason: {
+  readonly close: "close";
+  readonly escape: "escape";
+  readonly interactOutside: "interactOutside";
+  readonly trigger: "trigger";
+};
+type DialogOpenChangeReason = (typeof dialog_open_change_reason)[keyof typeof dialog_open_change_reason];
+type DialogOpenChangeDetails = {
+  event?: Event;
+  reason: DialogOpenChangeReason;
+};
+type DialogOpenChangeHandler = (open: boolean, details?: DialogOpenChangeDetails) => void;
+type DialogProps = {
+  children?: RemixNode;
+  closeOnInteractOutside?: boolean;
+  defaultOpen?: boolean;
+  modal?: boolean;
+  onOpenChange?: DialogOpenChangeHandler;
+  onOpenChangeComplete?: DialogOpenChangeHandler;
+  open?: boolean;
+  shouldCloseOnInteractOutside?: (element: Element) => boolean;
+};
+type DialogTriggerProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type DialogPopupStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type DialogPopupProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"dialog">, "style"> & DialogPopupStyleProps<TLayout> & ResponsiveProps<DialogPopupStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type DialogOverlayProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type DialogTitleProps = Omit<Props<"h2">, "style"> & {
+  style?: never;
+};
+type DialogDescriptionProps = Omit<Props<"p">, "style"> & {
+  style?: never;
+};
+type DialogCloseProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type DialogComponents<TPopupLayout extends string = string> = {
+  Close: RemixComponent<DialogCloseProps>;
+  Description: RemixComponent<DialogDescriptionProps>;
+  Overlay: RemixComponent<DialogOverlayProps>;
+  Popup: RemixComponent<DialogPopupProps<TPopupLayout>>;
+  Root: RemixComponent<DialogProps, DialogRuntimeContext>;
+  Title: RemixComponent<DialogTitleProps>;
+  Trigger: RemixComponent<DialogTriggerProps>;
+};
+type DialogRuntimeContext = {
+  closeOnInteractOutside: () => boolean;
+  isModal: () => boolean;
+  isOpen: () => boolean;
+  shouldCloseOnInteractOutside: () => ((element: Element) => boolean) | undefined;
+  setOpen: (open: boolean, details?: DialogOpenChangeDetails) => void;
+};
+declare function createDialog<TMode extends string, TRecipe extends DialogRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: DialogStyleSystem<TMode, TRecipe, TMetadata>): DialogComponents<DialogRecipePopupLayout<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/empty-state.d.ts
+type EmptyStateRecipeInput = RecipeWithVariantGroups<"body" | "indicator" | "root" | "title", never, ComponentStyle, Record<string, never>>;
+type EmptyStateStyleSystem<TMode extends string = string, TRecipe extends EmptyStateRecipeInput = EmptyStateRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    emptyState: TRecipe;
+  };
+}, TMetadata>;
+type EmptyStateProps = Omit<Props<"div">, "style"> & {
+  bodyProps?: ComponentSlotProps<"div">;
+  indicator?: RemixNode;
+  indicatorProps?: ComponentSlotProps<"div">;
+  style?: never;
+  title: RemixNode;
+  titleProps?: ComponentSlotProps<"div">;
+};
+declare function createEmptyState<TMode extends string, TRecipe extends EmptyStateRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: EmptyStateStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<EmptyStateProps>;
+//#endregion
+//#region kit/lab/design/components/remix/field.d.ts
+declare const field_slot: {
+  readonly description: "description";
+  readonly error: "error";
+  readonly label: "label";
+  readonly root: "root";
+};
+type FieldRecipeSlot = (typeof field_slot)[keyof typeof field_slot];
+type FieldRecipeInput = RecipeWithVariantGroups<FieldRecipeSlot, string, ComponentStyle, Record<never, string>>;
+type FieldStyleSystem<TMode extends string = string, TRecipe extends FieldRecipeInput = FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    field: TRecipe;
+  };
+}, TMetadata>;
+type FieldProps = Omit<Props<"div">, "style"> & {
+  controlID?: string;
+  disabled?: boolean;
+  invalid?: boolean;
+  style?: never;
+};
+type FieldLabelProps = Omit<Props<"label">, "style"> & {
+  style?: never;
+};
+type FieldDescriptionProps = Omit<Props<"p">, "style"> & {
+  style?: never;
+};
+type FieldErrorProps = Omit<Props<"p">, "style"> & {
+  match?: boolean;
+  style?: never;
+};
+type FieldContext = {
+  controlID: () => string;
+  descriptionID: () => string;
+  describedBy: () => string;
+  disabled: () => boolean;
+  errorID: () => string;
+  invalid: () => boolean;
+};
+type FieldControlMixin = <TElement extends HTMLElement = HTMLElement>() => MixInput<TElement>;
+type FieldComponents = {
+  controlMixin: FieldControlMixin;
+  Description: RemixComponent<FieldDescriptionProps>;
+  Error: RemixComponent<FieldErrorProps>;
+  Label: RemixComponent<FieldLabelProps>;
+  Root: RemixComponent<FieldProps, FieldContext>;
+};
+declare function createFieldParts<TMode extends string, TRecipe extends FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldStyleSystem<TMode, TRecipe, TMetadata>): FieldComponents;
+declare function createField<TMode extends string, TRecipe extends FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<FieldProps, FieldContext>;
+declare function createFieldLabel<TMode extends string, TRecipe extends FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<FieldLabelProps>;
+declare function createFieldDescription<TMode extends string, TRecipe extends FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<FieldDescriptionProps>;
+declare function createFieldError<TMode extends string, TRecipe extends FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<FieldErrorProps>;
+declare function createFieldControlMixin<TMode extends string, TRecipe extends FieldRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldStyleSystem<TMode, TRecipe, TMetadata>): FieldControlMixin;
+//#endregion
+//#region kit/lab/design/components/remix/fieldset.d.ts
+type FieldsetRecipeInput<TLayout extends string = string> = RecipeWithVariantGroups<"legend" | "root", string, ComponentStyle, {
+  layout: TLayout;
+}>;
+type FieldsetRecipeLayout<TRecipe extends FieldsetRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type FieldsetRecipeSelection<TRecipe extends FieldsetRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout">;
+type FieldsetStyleSystem<TMode extends string = string, TRecipe extends FieldsetRecipeInput = FieldsetRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    fieldset: TRecipe;
+  };
+}, TMetadata>;
+type FieldsetRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type FieldsetRootProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"fieldset">, "style"> & FieldsetRootStyleProps<TLayout> & ResponsiveProps<FieldsetRootStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type FieldsetLegendProps = Omit<Props<"legend">, "style"> & {
+  style?: never;
+};
+type FieldsetComponents<TLayout extends string = string> = {
+  Legend: RemixComponent<FieldsetLegendProps>;
+  Root: RemixComponent<FieldsetRootProps<TLayout>>;
+};
+declare function createFieldset<TMode extends string, TRecipe extends FieldsetRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FieldsetStyleSystem<TMode, TRecipe, TMetadata>): FieldsetComponents<FieldsetRecipeLayout<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/form.d.ts
+type FormRecipeInput<TLayout extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  layout: TLayout;
+}>;
+type FormRecipeLayout<TRecipe extends FormRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type FormRecipeSelection<TRecipe extends FormRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout">;
+type FormStyleSystem<TMode extends string = string, TRecipe extends FormRecipeInput = FormRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    form: TRecipe;
+  };
+}, TMetadata>;
+type FormStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type FormProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"form">, "style"> & FormStyleProps<TLayout> & ResponsiveProps<FormStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+declare function createForm<TMode extends string, TRecipe extends FormRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: FormStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<FormProps<FormRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/grid.d.ts
+type GridAlign = "center" | "end" | "start" | "stretch";
+type GridJustify = "center" | "end" | "start" | "stretch";
+type GridRecipeInput<TColumns extends string = string, TGap extends string = string, TLayout extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  columns: TColumns;
+  gap: TGap;
+  layout: TLayout;
+}>;
+type GridRecipeColumns<TRecipe extends GridRecipeInput> = RecipeVariantValue<TRecipe, "columns">;
+type GridRecipeGap<TRecipe extends GridRecipeInput> = RecipeVariantValue<TRecipe, "gap">;
+type GridRecipeLayout<TRecipe extends GridRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type GridRecipeSelection<TRecipe extends GridRecipeInput> = RecipeVariantPropsFor<TRecipe, "columns" | "gap" | "layout">;
+type GridStyleSystem<TMode extends string = string, TRecipe extends GridRecipeInput = GridRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    grid: TRecipe;
+  };
+}, TMetadata>;
+type GridStyleProps<TColumns extends string = string, TGap extends string = string, TLayout extends string = string> = Partial<GridRecipeSelection<GridRecipeInput<TColumns, TGap, TLayout>>> & {
+  align?: GridAlign;
+  justify?: GridJustify;
+};
+type GridProps<TColumns extends string = string, TGap extends string = string, TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<keyof HTMLElementTagNameMap>, "style"> & GridStyleProps<TColumns, TGap, TLayout> & ResponsiveProps<GridStyleProps<TColumns, TGap, TLayout>, TBreakpoint> & {
+  as?: keyof HTMLElementTagNameMap;
+  style?: never;
+};
+declare function createGrid<TMode extends string, TRecipe extends GridRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: GridStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<GridProps<GridRecipeColumns<TRecipe>, GridRecipeGap<TRecipe>, GridRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/icon.d.ts
+type IconElement = "div" | "span";
+type IconRotate = string;
+type IconRecipeInput<TSize extends string = string, TTone extends string = string, TLayout extends string = string> = RecipeWithVariantGroups<"root", never, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  tone: TTone;
+}>;
+type IconRecipeSize<TRecipe extends IconRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type IconRecipeTone<TRecipe extends IconRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type IconRecipeLayout<TRecipe extends IconRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type IconRecipeSelection<TRecipe extends IconRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "tone">;
+type IconStyleSystem<TMode extends string = string, TRecipe extends IconRecipeInput = IconRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    icon: TRecipe;
+  };
+}, TMetadata>;
+type IconStyleProps<TSize extends string = string, TTone extends string = string, TLayout extends string = string> = {
+  layout?: TLayout;
+  rotate?: IconRotate;
+  size?: TSize;
+  tone?: TTone;
+};
+type IconProps<TSize extends string = string, TTone extends string = string, TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<IconElement>, "style"> & IconStyleProps<TSize, TTone, TLayout> & ResponsiveProps<IconStyleProps<TSize, TTone, TLayout>, TBreakpoint> & {
+  as?: IconElement;
+  decorative?: boolean;
+  style?: never;
+};
+declare function createIcon<TMode extends string, TRecipe extends IconRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: IconStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<IconProps<IconRecipeSize<TRecipe>, IconRecipeTone<TRecipe>, IconRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/input.d.ts
+type InputRecipeInput<TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  size: TSize;
+  variant: TVariant;
+}>;
+type InputRecipeVariant<TRecipe extends InputRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type InputRecipeSize<TRecipe extends InputRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type InputRecipeSelection<TRecipe extends InputRecipeInput> = RecipeVariantPropsFor<TRecipe, "size" | "variant">;
+type InputStyleSystem<TMode extends string = string, TRecipe extends InputRecipeInput = InputRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    input: TRecipe;
+  };
+}, TMetadata>;
+type InputProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"input">, "size" | "style"> & Partial<InputRecipeSelection<InputRecipeInput<TVariant, TSize>>> & ResponsiveProps<InputRecipeSelection<InputRecipeInput<TVariant, TSize>>, TBreakpoint> & {
+  style?: never;
+};
+declare function createInput<TMode extends string, TRecipe extends InputRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: InputStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<InputProps<InputRecipeVariant<TRecipe>, InputRecipeSize<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/kbd.d.ts
+declare const kbdDefaultElement = "kbd";
+declare const kbdScope = "kbd";
+type KbdRecipeInput<TSize extends string = string> = RootRecipeInput<{
+  size: TSize;
+}>;
+type KbdRecipeSize<TRecipe extends KbdRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type KbdStyleSystem<TMode extends string = string, TRecipe extends KbdRecipeInput = KbdRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = RootStyleSystem<TMode, TRecipe, TMetadata, typeof kbdScope>;
+type KbdProps<TRecipe extends KbdRecipeInput = KbdRecipeInput, TBreakpoint extends string = string> = RootComponentProps<"size", TRecipe, TBreakpoint>;
+declare function createKbd<TMode extends string, TRecipe extends KbdRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: KbdStyleSystem<TMode, TRecipe, TMetadata>): RootComponent<"size", TRecipe, BreakpointForStyleSystem<KbdStyleSystem<TMode, TRecipe, TMetadata>>>;
+//#endregion
+//#region kit/lab/design/components/remix/list.d.ts
+type ListElement = "ol" | "ul";
+type ListRecipeInput = RecipeWithVariantGroups<"item" | "root", never, ComponentStyle, Record<string, never>>;
+type ListStyleSystem<TMode extends string = string, TRecipe extends ListRecipeInput = ListRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    list: TRecipe;
+  };
+}, TMetadata>;
+type ListProps = Omit<Props<ListElement>, "style"> & {
+  as?: ListElement;
+  style?: never;
+};
+type ListItemProps = Omit<Props<"li">, "style"> & {
+  style?: never;
+};
+declare function createList<TMode extends string, TRecipe extends ListRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ListStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<ListProps>;
+declare function createListItem<TMode extends string, TRecipe extends ListRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ListStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<ListItemProps>;
+//#endregion
+//#region kit/lab/design/components/remix/group-label.d.ts
+type GroupLabelRelationship = {
+  get_label_id: () => string;
+  get_labelled_by: () => string | undefined;
+  register_label: (node: HTMLElement | null) => void;
+};
+//#endregion
+//#region kit/lab/design/components/remix/ordered-collection.d.ts
+type OrderedCollectionItem<TValue extends string = string> = {
+  disabled: boolean;
+  id: string;
+  node: HTMLElement;
+  text: string;
+  value: TValue;
+};
+//#endregion
+//#region kit/lab/design/components/remix/listbox.d.ts
+declare const listbox_slot: {
+  readonly group: "group";
+  readonly groupLabel: "groupLabel";
+  readonly option: "option";
+  readonly optionIndicator: "optionIndicator";
+  readonly optionText: "optionText";
+  readonly root: "root";
+};
+type ListboxRecipeSlot = (typeof listbox_slot)[keyof typeof listbox_slot];
+type ListboxRecipeCondition = CommonRecipeCondition | "highlighted";
+type ListboxRecipeInput<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<ListboxRecipeSlot, string, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type ListboxRecipeLayout<TRecipe extends ListboxRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type ListboxRecipeVariant<TRecipe extends ListboxRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type ListboxRecipeSize<TRecipe extends ListboxRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type ListboxRecipeSelection<TRecipe extends ListboxRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "variant">;
+type ListboxStyleSystem<TMode extends string = string, TRecipe extends ListboxRecipeInput = ListboxRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    listbox: TRecipe;
+  };
+}, TMetadata>;
+declare const listboxValueChangeReason: {
+  readonly keyboard: "keyboard";
+  readonly pointer: "pointer";
+};
+declare const listboxHighlightChangeReason: {
+  readonly focus: "focus";
+  readonly keyboard: "keyboard";
+  readonly pointer: "pointer";
+  readonly typeahead: "typeahead";
+};
+type ListboxValueChangeReason = (typeof listboxValueChangeReason)[keyof typeof listboxValueChangeReason];
+type ListboxHighlightChangeReason = (typeof listboxHighlightChangeReason)[keyof typeof listboxHighlightChangeReason];
+type ListboxValueChangeDetails = {
+  event?: Event;
+  reason: ListboxValueChangeReason;
+};
+type ListboxHighlightChangeDetails = {
+  event?: Event;
+  reason: ListboxHighlightChangeReason;
+};
+type ListboxValueChangeHandler<TValue extends string = string> = (value: TValue | null, details?: ListboxValueChangeDetails) => void;
+type ListboxHighlightChangeHandler<TValue extends string = string> = (value: TValue | null, details?: ListboxHighlightChangeDetails) => void;
+type ListboxValuesChangeHandler<TValue extends string = string> = (values: readonly TValue[], details?: ListboxValueChangeDetails) => void;
+type ListboxSelectionMode = "multiple" | "single";
+type ListboxRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type ListboxOrientation = "horizontal" | "vertical";
+type ListboxRootSharedProps<TValue extends string = string> = {
+  defaultHighlightedValue?: TValue | null;
+  disabled?: boolean;
+  highlightedValue?: TValue | null;
+  invalid?: boolean;
+  loopFocus?: boolean;
+  onHighlightChange?: ListboxHighlightChangeHandler<TValue>;
+  orientation?: ListboxOrientation;
+  required?: boolean;
+  style?: never;
+  typeahead?: boolean;
+};
+type ListboxRootSingleSelectionProps<TValue extends string = string> = {
+  defaultValue?: TValue | null;
+  defaultValues?: never;
+  onValueChange?: ListboxValueChangeHandler<TValue>;
+  onValuesChange?: never;
+  selectionFollowsFocus?: boolean;
+  selectionMode?: "single";
+  value?: TValue | null;
+  values?: never;
+};
+type ListboxRootMultipleSelectionProps<TValue extends string = string> = {
+  defaultValue?: never;
+  defaultValues?: readonly TValue[];
+  onValueChange?: never;
+  onValuesChange?: ListboxValuesChangeHandler<TValue>;
+  selectionFollowsFocus?: never;
+  selectionMode: "multiple";
+  value?: never;
+  values?: readonly TValue[];
+};
+type ListboxRootSelectionProps<TValue extends string = string> = ListboxRootSingleSelectionProps<TValue> | ListboxRootMultipleSelectionProps<TValue>;
+type ListboxOptionStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type ListboxRootProps<TLayout extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"div">, "style"> & ListboxRootStyleProps<TLayout> & ResponsiveProps<ListboxRootStyleProps<TLayout>, TBreakpoint> & ListboxRootSharedProps<TValue> & ListboxRootSelectionProps<TValue>;
+type ListboxOptionProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"div">, "style"> & ListboxOptionStyleProps<TVariant, TSize> & ResponsiveProps<ListboxOptionStyleProps<TVariant, TSize>, TBreakpoint> & {
+  disabled?: boolean;
+  style?: never;
+  textValue?: string;
+  value: TValue;
+};
+type ListboxGroupProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type ListboxGroupLabelProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type ListboxOptionTextProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type ListboxOptionIndicatorProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type ListboxComponents<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = {
+  Group: RemixComponent<ListboxGroupProps, ListboxGroupRuntimeContext>;
+  GroupLabel: RemixComponent<ListboxGroupLabelProps>;
+  Option: RemixComponent<ListboxOptionProps<TVariant, TSize>>;
+  OptionIndicator: RemixComponent<ListboxOptionIndicatorProps>;
+  OptionText: RemixComponent<ListboxOptionTextProps>;
+  Root: RemixComponent<ListboxRootProps<TLayout>, ListboxRuntimeContext>;
+};
+type ListboxOptions = {
+  conditions?: Partial<Readonly<Record<ListboxRecipeSlot, RecipeConditionSelectorMap<string>>>>;
+};
+type ListboxRuntimeContext = {
+  get_disabled: () => boolean;
+  get_highlighted_id: () => string | undefined;
+  get_highlighted_value: () => string | null;
+  get_invalid: () => boolean;
+  get_required: () => boolean;
+  get_value: () => string | null;
+  handle_focus: (event: FocusEvent) => void;
+  handle_keydown: (event: KeyboardEvent) => void;
+  highlight_value: (value: string | null, details: ListboxHighlightChangeDetails) => void;
+  register_option: (option: RegisteredListboxOption) => void;
+  select_value: (value: string | null, details: ListboxValueChangeDetails) => void;
+  value_selected: (value: string) => boolean;
+  unregister_option: (id: string) => void;
+};
+type ListboxGroupRuntimeContext = GroupLabelRelationship;
+type RegisteredListboxOption = OrderedCollectionItem<string>;
+declare function createListbox<TMode extends string, TRecipe extends ListboxRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ListboxStyleSystem<TMode, TRecipe, TMetadata>, options?: ListboxOptions): ListboxComponents<ListboxRecipeLayout<TRecipe>, ListboxRecipeVariant<TRecipe>, ListboxRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/popup-behavior.d.ts
+type PopupRelationship = {
+  containsTarget: (target: EventTarget | null) => boolean;
+  focusTrigger: () => void;
+  getPopup: () => HTMLElement | null;
+  getTrigger: () => HTMLElement | null;
+  registerPopup: (node: HTMLElement | null) => void;
+  registerTrigger: (node: HTMLElement | null) => void;
+  syncPopup: (open: boolean) => void;
+};
+//#endregion
+//#region kit/lab/design/components/remix/menu.d.ts
+declare const menuAnatomy: {
+  readonly group: "group";
+  readonly groupLabel: "groupLabel";
+  readonly item: "item";
+  readonly itemIndicator: "itemIndicator";
+  readonly popup: "popup";
+  readonly separator: "separator";
+  readonly trigger: "trigger";
+};
+type MenuRecipeSlot = (typeof menuAnatomy)[keyof typeof menuAnatomy];
+type MenuRecipeCondition = CommonRecipeCondition | "checked" | "closed" | "highlighted" | "indeterminate" | "open" | "unchecked";
+type MenuRecipeInput<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<MenuRecipeSlot, string, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type MenuRecipeLayout<TRecipe extends MenuRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type MenuRecipeVariant<TRecipe extends MenuRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type MenuRecipeSize<TRecipe extends MenuRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type MenuRecipeSelection<TRecipe extends MenuRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "variant">;
+type MenuStyleSystem<TMode extends string = string, TRecipe extends MenuRecipeInput = MenuRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    menu: TRecipe;
+  };
+}, TMetadata>;
+type MenuOpenChangeDetails = {
+  event?: Event;
+  reason: MenuOpenChangeReason;
+};
+type MenuOpenChangeHandler = (open: boolean, details?: MenuOpenChangeDetails) => void;
+type MenuRootProps = {
+  children?: RemixNode;
+  closeOnSelect?: boolean;
+  defaultOpen?: boolean;
+  loopFocus?: boolean;
+  onOpenChange?: MenuOpenChangeHandler;
+  onOpenChangeComplete?: MenuOpenChangeHandler;
+  open?: boolean;
+  typeahead?: boolean;
+};
+type MenuTriggerStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type MenuPopupStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type MenuItemStyleProps<TVariant extends string = string, TSize extends string = string> = MenuTriggerStyleProps<TVariant, TSize>;
+type MenuTriggerProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style"> & MenuTriggerStyleProps<TVariant, TSize> & ResponsiveProps<MenuTriggerStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+};
+type MenuPopupProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & MenuPopupStyleProps<TLayout> & ResponsiveProps<MenuPopupStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type MenuItemProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style"> & MenuItemStyleProps<TVariant, TSize> & ResponsiveProps<MenuItemStyleProps<TVariant, TSize>, TBreakpoint> & {
+  disabled?: boolean;
+  style?: never;
+  textValue?: string;
+};
+type MenuChecked = CheckableChecked;
+type MenuCheckedChangeHandler = (checked: MenuChecked, details?: MenuItemSelectDetails) => void;
+type MenuRadioValueChangeHandler<TValue extends string = string> = (value: TValue, details?: MenuItemSelectDetails) => void;
+type MenuCheckboxItemProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style"> & MenuItemStyleProps<TVariant, TSize> & ResponsiveProps<MenuItemStyleProps<TVariant, TSize>, TBreakpoint> & {
+  checked?: MenuChecked;
+  defaultChecked?: MenuChecked;
+  disabled?: boolean;
+  onCheckedChange?: MenuCheckedChangeHandler;
+  style?: never;
+  textValue?: string;
+};
+type MenuRadioGroupProps<TValue extends string = string> = {
+  children?: RemixNode;
+  defaultValue?: TValue | null;
+  onValueChange?: MenuRadioValueChangeHandler<TValue>;
+  value?: TValue | null;
+};
+type MenuRadioItemProps<TValue extends string = string, TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style" | "value"> & MenuItemStyleProps<TVariant, TSize> & ResponsiveProps<MenuItemStyleProps<TVariant, TSize>, TBreakpoint> & {
+  disabled?: boolean;
+  style?: never;
+  textValue?: string;
+  value: TValue;
+};
+type MenuItemIndicatorProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type MenuSeparatorProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type MenuGroupProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type MenuGroupLabelProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type MenuComponents<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = {
+  CheckboxItem: RemixComponent<MenuCheckboxItemProps<TVariant, TSize>, MenuItemRuntimeContext>;
+  Group: RemixComponent<MenuGroupProps, MenuGroupContext>;
+  GroupLabel: RemixComponent<MenuGroupLabelProps>;
+  Item: RemixComponent<MenuItemProps<TVariant, TSize>>;
+  ItemIndicator: RemixComponent<MenuItemIndicatorProps>;
+  Popup: RemixComponent<MenuPopupProps<TLayout>>;
+  RadioGroup: RemixComponent<MenuRadioGroupProps, MenuRadioGroupContext>;
+  RadioItem: RemixComponent<MenuRadioItemProps<string, TVariant, TSize>, MenuItemRuntimeContext>;
+  Root: RemixComponent<MenuRootProps, MenuContext>;
+  Separator: RemixComponent<MenuSeparatorProps>;
+  Trigger: RemixComponent<MenuTriggerProps<TVariant, TSize>>;
+};
+type MenuContext = {
+  close: (details: MenuOpenChangeDetails) => void;
+  get_close_on_select: () => boolean;
+  get_current_item_value: () => string | null;
+  get_open: () => boolean;
+  get_popup_relationship: () => PopupRelationship;
+  get_popup_id: () => string;
+  get_trigger_id: () => string;
+  handle_popup_keydown: (event: KeyboardEvent) => void;
+  open: (details: MenuOpenChangeDetails, focus?: MenuOpenFocus) => void;
+  register_item: (item: RegisteredMenuItem) => void;
+  register_trigger: (node: HTMLButtonElement | null) => void;
+  select_item: (value: string, details: MenuItemSelectDetails) => void;
+  set_current_item: (value: string | null, details: MenuItemFocusDetails, focus?: boolean) => void;
+  toggle: (details: MenuOpenChangeDetails, focus?: MenuOpenFocus) => void;
+  unregister_item: (id: string) => void;
+  sync_popup: () => void;
+};
+type MenuGroupContext = GroupLabelRelationship;
+type MenuRadioGroupContext = {
+  get_value: () => string | null;
+  set_value: (value: string, details: MenuItemSelectDetails) => void;
+};
+type MenuItemRuntimeContext = {
+  get_state: () => CheckableStateName | undefined;
+};
+declare const menuOpenChangeReason: {
+  readonly escape: "escape";
+  readonly interactOutside: "interactOutside";
+  readonly item: "item";
+  readonly tab: "tab";
+  readonly trigger: "trigger";
+};
+declare const menuItemFocusReason: {
+  readonly keyboard: "keyboard";
+  readonly open: "open";
+  readonly pointer: "pointer";
+  readonly typeahead: "typeahead";
+};
+declare const menuItemSelectReason: {
+  readonly keyboard: "keyboard";
+  readonly pointer: "pointer";
+};
+type MenuOpenChangeReason = (typeof menuOpenChangeReason)[keyof typeof menuOpenChangeReason];
+type MenuItemFocusReason = (typeof menuItemFocusReason)[keyof typeof menuItemFocusReason];
+type MenuItemSelectReason = (typeof menuItemSelectReason)[keyof typeof menuItemSelectReason];
+type MenuItemFocusDetails = {
+  event?: Event;
+  reason: MenuItemFocusReason;
+};
+type MenuItemSelectDetails = {
+  event?: Event;
+  reason: MenuItemSelectReason;
+};
+type RegisteredMenuItem = OrderedCollectionItem<string> & {
+  activate: (details: MenuItemSelectDetails) => void;
+};
+type MenuOpenFocus = "first" | "last";
+declare function createMenu<TMode extends string, TRecipe extends MenuRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: MenuStyleSystem<TMode, TRecipe, TMetadata>): MenuComponents<MenuRecipeLayout<TRecipe>, MenuRecipeVariant<TRecipe>, MenuRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/popover.d.ts
+declare const popoverAnatomy: {
+  readonly parts: {
+    readonly arrow: "arrow";
+    readonly close: "close";
+    readonly description: "description";
+    readonly popup: "popup";
+    readonly title: "title";
+    readonly trigger: "trigger";
+  };
+  readonly scope: "popover";
+};
+type PopoverRecipeSlot = (typeof popoverAnatomy.parts)[keyof typeof popoverAnatomy.parts];
+type PopoverRecipeCondition = string;
+type PopoverRecipeInput<TSize extends string = string> = RecipeWithVariantGroups<PopoverRecipeSlot, string, ComponentStyle, {
+  size: TSize;
+}>;
+type PopoverRecipeSize<TRecipe extends PopoverRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type PopoverStyleSystem<TMode extends string = string, TRecipe extends PopoverRecipeInput = PopoverRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    popover: TRecipe;
+  };
+}, TMetadata>;
+type PopoverOpenChangeReason = "close" | "escape" | "interactOutside" | "trigger";
+type PopoverOpenChangeDetails = {
+  event?: Event;
+  reason: PopoverOpenChangeReason;
+};
+type PopoverOpenChangeHandler = (open: boolean, details?: PopoverOpenChangeDetails) => void;
+type PopoverRootProps = {
+  children?: RemixNode;
+  closeOnEscape?: boolean;
+  closeOnInteractOutside?: boolean;
+  defaultOpen?: boolean;
+  modal?: boolean;
+  open?: boolean;
+  onOpenChange?: PopoverOpenChangeHandler;
+  onOpenChangeComplete?: PopoverOpenChangeHandler;
+  shouldCloseOnInteractOutside?: (element: Element) => boolean;
+};
+type PopoverTriggerProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type PopoverSide = "bottom" | "left" | "right" | "top";
+type PopoverAlign = "center" | "end" | "start";
+type PopoverPopupStyleProps<TSize extends string = string> = {
+  size?: TSize;
+};
+type PopoverPopupProps<TSize extends string = string> = Omit<Props<"div">, "style"> & PopoverPopupStyleProps<TSize> & {
+  align?: PopoverAlign;
+  alignOffset?: number;
+  arrowPadding?: number;
+  avoidCollisions?: boolean;
+  collisionPadding?: number;
+  side?: PopoverSide;
+  sideOffset?: number;
+  style?: never;
+};
+type PopoverArrowProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type PopoverTitleProps = Omit<Props<"h2">, "style"> & {
+  style?: never;
+};
+type PopoverDescriptionProps = Omit<Props<"p">, "style"> & {
+  style?: never;
+};
+type PopoverCloseProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type PopoverComponents<TSize extends string = string> = {
+  Arrow: RemixComponent<PopoverArrowProps>;
+  Close: RemixComponent<PopoverCloseProps>;
+  Description: RemixComponent<PopoverDescriptionProps>;
+  Popup: RemixComponent<PopoverPopupProps<TSize>>;
+  Root: RemixComponent<PopoverRootProps, PopoverRuntimeContext>;
+  Title: RemixComponent<PopoverTitleProps>;
+  Trigger: RemixComponent<PopoverTriggerProps>;
+};
+type PopoverConditionSelectors = Partial<Readonly<Record<PopoverRecipeSlot, RecipeConditionSelectorMap<string>>>>;
+type PopoverOptions = {
+  conditions?: PopoverConditionSelectors;
+};
+type PopoverRuntimeContext = {
+  close: (details: PopoverOpenChangeDetails) => void;
+  get_close_on_escape: () => boolean;
+  get_close_on_interact_outside: () => boolean;
+  get_description_id: () => string;
+  get_open: () => boolean;
+  get_popup_relationship: () => PopupRelationship;
+  get_popup_id: () => string;
+  get_should_close_on_interact_outside: () => ((element: Element) => boolean) | undefined;
+  get_title_id: () => string;
+  get_trigger_id: () => string;
+  open: (details: PopoverOpenChangeDetails) => void;
+  register_trigger: (node: HTMLElement | null) => void;
+  sync_popup: () => void;
+  toggle: (details: PopoverOpenChangeDetails) => void;
+};
+declare function createPopover<TMode extends string, TRecipe extends PopoverRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: PopoverStyleSystem<TMode, TRecipe, TMetadata>, options?: PopoverOptions): PopoverComponents<PopoverRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/progress.d.ts
+type ProgressRecipeInput<TTone extends string = string> = RecipeWithVariantGroups<"root" | "segment", never, ComponentStyle, {
+  tone: TTone;
+}>;
+type ProgressRecipeTone<TRecipe extends ProgressRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type ProgressRecipeSelection<TRecipe extends ProgressRecipeInput> = RecipeVariantPropsFor<TRecipe, "tone">;
+type ProgressStyleSystem<TMode extends string = string, TRecipe extends ProgressRecipeInput = ProgressRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    progress: TRecipe;
+  };
+}, TMetadata>;
+type ProgressSegment<TTone extends string = string> = {
+  key?: string;
+  label?: RemixNode;
+  props?: ComponentSlotProps<"div">;
+  tone?: TTone;
+  value: number;
+};
+type ProgressProps<TTone extends string = string> = Omit<Props<"div">, "style"> & {
+  max?: number;
+  segments?: readonly ProgressSegment<TTone>[];
+  style?: never;
+  tone?: TTone;
+  value?: number;
+};
+declare function createProgress<TMode extends string, TRecipe extends ProgressRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ProgressStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<ProgressProps<ProgressRecipeTone<TRecipe>>>;
+//#endregion
+//#region kit/lab/design/components/remix/radio-group.d.ts
+type RadioGroupRecipeCondition = CommonRecipeCondition | "checked" | "unchecked";
+type RadioGroupRecipeInput<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"item" | "root", string, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type RadioGroupRecipeLayout<TRecipe extends RadioGroupRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type RadioGroupRecipeVariant<TRecipe extends RadioGroupRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type RadioGroupRecipeSize<TRecipe extends RadioGroupRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type RadioGroupRecipeSelection<TRecipe extends RadioGroupRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "variant">;
+type RadioGroupStyleSystem<TMode extends string = string, TRecipe extends RadioGroupRecipeInput = RadioGroupRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    radioGroup: TRecipe;
+  };
+}, TMetadata>;
+type RadioGroupValueChangeDetails = {
+  event?: Event;
+};
+type RadioGroupValueChangeHandler<TValue extends string = string> = (value: TValue, details?: RadioGroupValueChangeDetails) => void;
+type RadioGroupRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type RadioGroupItemStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type RadioGroupRootProps<TLayout extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"div">, "style"> & RadioGroupRootStyleProps<TLayout> & ResponsiveProps<RadioGroupRootStyleProps<TLayout>, TBreakpoint> & {
+  defaultValue?: TValue | null;
+  disabled?: boolean;
+  form?: string;
+  name?: string;
+  onValueChange?: RadioGroupValueChangeHandler<TValue>;
+  required?: boolean;
+  style?: never;
+  value?: TValue | null;
+};
+type RadioGroupItemProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"input">, "checked" | "defaultChecked" | "name" | "style" | "type" | "value"> & RadioGroupItemStyleProps<TVariant, TSize> & ResponsiveProps<RadioGroupItemStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+  value: TValue;
+};
+type RadioGroupComponents<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = {
+  Item: RemixComponent<RadioGroupItemProps<TVariant, TSize>>;
+  Root: RemixComponent<RadioGroupRootProps<TLayout>, RadioGroupContext>;
+};
+type RadioGroupContext = {
+  get_disabled: () => boolean;
+  get_form: () => string | undefined;
+  get_name: () => string;
+  get_required: () => boolean;
+  get_value: () => string | null;
+  set_value: (value: string, details?: RadioGroupValueChangeDetails) => void;
+};
+declare function createRadioGroup<TMode extends string, TRecipe extends RadioGroupRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: RadioGroupStyleSystem<TMode, TRecipe, TMetadata>): RadioGroupComponents<RadioGroupRecipeLayout<TRecipe>, RadioGroupRecipeVariant<TRecipe>, RadioGroupRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/select.d.ts
+declare const select_slot: {
+  readonly group: "group";
+  readonly groupLabel: "groupLabel";
+  readonly icon: "icon";
+  readonly list: "list";
+  readonly option: "option";
+  readonly optionIndicator: "optionIndicator";
+  readonly optionText: "optionText";
+  readonly popup: "popup";
+  readonly separator: "separator";
+  readonly trigger: "trigger";
+  readonly value: "value";
+};
+type SelectRecipeSlot = (typeof select_slot)[keyof typeof select_slot];
+type SelectRecipeCondition = "active" | "disabled" | "focusVisible" | "highlighted" | "hover" | "open" | "placeholder" | "reducedMotion" | "selected";
+type SelectRecipeInput<TVariant extends string = string, TSize extends string = string, TPopupLayout extends string = string> = RecipeWithVariantGroups<SelectRecipeSlot, string, ComponentStyle, {
+  popupLayout: TPopupLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type SelectRecipeVariant<TRecipe extends SelectRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type SelectRecipeSize<TRecipe extends SelectRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type SelectRecipePopupLayout<TRecipe extends SelectRecipeInput> = RecipeVariantValue<TRecipe, "popupLayout">;
+type SelectRecipeSelection<TRecipe extends SelectRecipeInput> = RecipeVariantPropsFor<TRecipe, "popupLayout" | "size" | "variant">;
+type SelectStyleSystem<TMode extends string = string, TRecipe extends SelectRecipeInput = SelectRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    select: TRecipe;
+  };
+}, TMetadata>;
+declare const selectOpenChangeReason: {
+  readonly escape: "escape";
+  readonly interactOutside: "interactOutside";
+  readonly option: "option";
+  readonly tab: "tab";
+  readonly trigger: "trigger";
+};
+declare const selectValueChangeReason: {
+  readonly keyboard: "keyboard";
+  readonly pointer: "pointer";
+};
+declare const selectHighlightChangeReason: {
+  readonly keyboard: "keyboard";
+  readonly open: "open";
+  readonly pointer: "pointer";
+  readonly typeahead: "typeahead";
+};
+type SelectOpenChangeReason = (typeof selectOpenChangeReason)[keyof typeof selectOpenChangeReason];
+type SelectValueChangeReason = (typeof selectValueChangeReason)[keyof typeof selectValueChangeReason];
+type SelectHighlightChangeReason = (typeof selectHighlightChangeReason)[keyof typeof selectHighlightChangeReason];
+type SelectOpenChangeDetails = {
+  event?: Event;
+  reason: SelectOpenChangeReason;
+};
+type SelectValueChangeDetails = {
+  event?: Event;
+  reason: SelectValueChangeReason;
+};
+type SelectHighlightChangeDetails = {
+  event?: Event;
+  reason: SelectHighlightChangeReason;
+};
+type SelectValueChangeHandler<TValue extends string = string> = (value: TValue | null, details?: SelectValueChangeDetails) => void;
+type SelectOpenChangeHandler = (open: boolean, details?: SelectOpenChangeDetails) => void;
+type SelectHighlightChangeHandler<TValue extends string = string> = (value: TValue | null, details?: SelectHighlightChangeDetails) => void;
+type SelectProps<TValue extends string = string> = {
+  autoComplete?: string;
+  children?: RemixNode;
+  defaultOpen?: boolean;
+  defaultHighlightedValue?: TValue | null;
+  defaultValue?: TValue | null;
+  disabled?: boolean;
+  form?: string;
+  highlightedValue?: TValue | null;
+  invalid?: boolean;
+  loopFocus?: boolean;
+  name?: string;
+  onHighlightChange?: SelectHighlightChangeHandler<TValue>;
+  onOpenChange?: SelectOpenChangeHandler;
+  onOpenChangeComplete?: SelectOpenChangeHandler;
+  onValueChange?: SelectValueChangeHandler<TValue>;
+  open?: boolean;
+  placeholder?: string;
+  readOnly?: boolean;
+  required?: boolean;
+  typeahead?: boolean;
+  value?: TValue | null;
+};
+type SelectTriggerStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type SelectTriggerProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style"> & SelectTriggerStyleProps<TVariant, TSize> & ResponsiveProps<SelectTriggerStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+};
+type SelectPopupStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type SelectPopupProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & SelectPopupStyleProps<TLayout> & ResponsiveProps<SelectPopupStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type SelectListProps<TLayout extends string = string, TBreakpoint extends string = string> = SelectPopupProps<TLayout, TBreakpoint>;
+type SelectValueProps = Omit<Props<"span">, "style"> & {
+  placeholder?: RemixNode;
+  style?: never;
+};
+type SelectIconProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type SelectGroupProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type SelectGroupLabelProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type SelectSeparatorProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type SelectOptionProps<TValue extends string = string> = Omit<Props<"div">, "style"> & {
+  disabled?: boolean;
+  style?: never;
+  textValue?: string;
+  value: TValue;
+};
+type SelectOptionTextProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type SelectOptionIndicatorProps = Omit<Props<"span">, "style"> & {
+  style?: never;
+};
+type SelectComponents<TVariant extends string = string, TSize extends string = string, TPopupLayout extends string = string> = {
+  Group: RemixComponent<SelectGroupProps, SelectGroupRuntimeContext>;
+  GroupLabel: RemixComponent<SelectGroupLabelProps>;
+  Icon: RemixComponent<SelectIconProps>;
+  List: RemixComponent<SelectListProps<TPopupLayout>>;
+  Option: RemixComponent<SelectOptionProps>;
+  OptionIndicator: RemixComponent<SelectOptionIndicatorProps>;
+  OptionText: RemixComponent<SelectOptionTextProps>;
+  Popup: RemixComponent<SelectPopupProps<TPopupLayout>>;
+  Root: RemixComponent<SelectProps, SelectRuntimeContext>;
+  Separator: RemixComponent<SelectSeparatorProps>;
+  Trigger: RemixComponent<SelectTriggerProps<TVariant, TSize>>;
+  Value: RemixComponent<SelectValueProps>;
+};
+type SelectOptions = {
+  conditions?: Partial<Readonly<Record<SelectRecipeSlot, RecipeConditionSelectorMap<string>>>>;
+};
+type SelectRuntimeContext = {
+  close: (details: SelectOpenChangeDetails) => void;
+  get_disabled: () => boolean;
+  get_highlighted_id: () => string | undefined;
+  get_highlighted_value: () => string | null;
+  get_invalid: () => boolean;
+  get_list_id: () => string;
+  get_open: () => boolean;
+  get_placeholder: () => string | undefined;
+  get_popup_relationship: () => PopupRelationship;
+  get_popup_id: () => string;
+  get_read_only: () => boolean;
+  get_required: () => boolean;
+  get_selected_text: () => string | undefined;
+  get_trigger_id: () => string;
+  get_value: () => string | null;
+  handle_keydown: (event: KeyboardEvent) => void;
+  highlight_by_offset: (offset: number, details: SelectHighlightChangeDetails) => void;
+  highlight_first: () => void;
+  highlight_last: () => void;
+  highlight_value: (value: string | null, details: SelectHighlightChangeDetails) => void;
+  open: (details: SelectOpenChangeDetails, highlight?: SelectOpenHighlight) => void;
+  register_option: (option: RegisteredSelectOption) => void;
+  register_trigger: (node: HTMLElement | null) => void;
+  search: (text: string, event: KeyboardEvent) => void;
+  select_value: (value: string | null, details: SelectValueChangeDetails) => void;
+  sync_popup: () => void;
+  toggle: (details: SelectOpenChangeDetails) => void;
+  unregister_option: (id: string) => void;
+};
+type RegisteredSelectOption = OrderedCollectionItem<string>;
+type SelectOpenHighlight = "first" | "last" | "selected";
+type SelectGroupRuntimeContext = GroupLabelRelationship;
+declare function createSelect<TMode extends string, TRecipe extends SelectRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: SelectStyleSystem<TMode, TRecipe, TMetadata>, options?: SelectOptions): SelectComponents<SelectRecipeVariant<TRecipe>, SelectRecipeSize<TRecipe>, SelectRecipePopupLayout<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/separator.d.ts
+declare const separatorDecorativeRole = "presentation";
+declare const separatorHiddenAttribute = "aria-hidden";
+declare const separatorOrientation: {
+  readonly horizontal: "horizontal";
+  readonly vertical: "vertical";
+};
+declare const separatorOrientationAttribute = "data-orientation";
+declare const separatorRole = "separator";
+type SeparatorOrientation = (typeof separatorOrientation)[keyof typeof separatorOrientation];
+type SeparatorRecipeInput = RecipeWithVariantGroups<"root", string, ComponentStyle, Record<never, string>>;
+type SeparatorStyleSystem<TMode extends string = string, TRecipe extends SeparatorRecipeInput = SeparatorRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    separator: TRecipe;
+  };
+}, TMetadata>;
+type SeparatorProps = Omit<Props<"div">, "children" | "role" | "style" | "tabIndex"> & {
+  children?: never;
+  decorative?: boolean;
+  orientation?: SeparatorOrientation;
+  style?: never;
+};
+declare function createSeparator<TMode extends string, TRecipe extends SeparatorRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: SeparatorStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<SeparatorProps>;
+//#endregion
+//#region kit/lab/design/components/remix/slider.d.ts
+type SliderRecipeCondition = "disabled" | "focusVisible";
+declare const slider_slot: {
+  readonly progress: "progress";
+  readonly root: "root";
+  readonly thumb: "thumb";
+  readonly track: "track";
+};
+type SliderRecipeSlot = (typeof slider_slot)[keyof typeof slider_slot];
+type SliderStyleTarget = SliderRecipeSlot | "thumbMoz" | "thumbWebkit" | "trackMoz" | "trackWebkit";
+type SliderTargetStyles = Partial<Readonly<Record<SliderStyleTarget, ComponentStyle>>>;
+type SliderRecipeInput<TLayout extends string = string> = RecipeWithVariantGroups<SliderRecipeSlot, string, ComponentStyle, {
+  layout: TLayout;
+}>;
+type SliderRecipeLayout<TRecipe extends SliderRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type SliderRecipeSelection<TRecipe extends SliderRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout">;
+type SliderStyleSystem<TMode extends string = string, TRecipe extends SliderRecipeInput = SliderRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    slider: TRecipe;
+  };
+}, TMetadata>;
+type SliderStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type SliderProps<TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"input">, "style" | "type"> & SliderStyleProps<TLayout> & ResponsiveProps<SliderStyleProps<TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type SliderOptions = {
+  progressVariable?: string;
+  targetStyles?: SliderTargetStyles;
+};
+declare const sliderProgressVariable = "--vorma-slider-progress";
+declare function createSlider<TMode extends string, TRecipe extends SliderRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: SliderStyleSystem<TMode, TRecipe, TMetadata>, options?: SliderOptions): RemixComponent<SliderProps<SliderRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/spinner.d.ts
+type SpinnerRecipeInput<TTone extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  size: TSize;
+  tone: TTone;
+}>;
+type SpinnerRecipeTone<TRecipe extends SpinnerRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type SpinnerRecipeSize<TRecipe extends SpinnerRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type SpinnerRecipeSelection<TRecipe extends SpinnerRecipeInput> = RecipeVariantPropsFor<TRecipe, "size" | "tone">;
+type SpinnerStyleSystem<TMode extends string = string, TRecipe extends SpinnerRecipeInput = SpinnerRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    spinner: TRecipe;
+  };
+}, TMetadata>;
+type SpinnerProps<TTone extends string = string, TSize extends string = string> = Omit<Props<"span">, "style"> & Partial<SpinnerRecipeSelection<SpinnerRecipeInput<TTone, TSize>>> & {
+  idle?: boolean;
+  style?: never;
+};
+declare function createSpinner<TMode extends string, TRecipe extends SpinnerRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: SpinnerStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<SpinnerProps<SpinnerRecipeTone<TRecipe>, SpinnerRecipeSize<TRecipe>>>;
+//#endregion
+//#region kit/lab/design/components/remix/stack.d.ts
+type StackAlign = "center" | "end" | "start" | "stretch";
+type StackDirection = "column" | "column-reverse" | "row" | "row-reverse";
+type StackJustify = "between" | "center" | "end" | "start";
+type StackRecipeInput<TGap extends string = string, TLayout extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  gap: TGap;
+  layout: TLayout;
+}>;
+type StackRecipeGap<TRecipe extends StackRecipeInput> = RecipeVariantValue<TRecipe, "gap">;
+type StackRecipeLayout<TRecipe extends StackRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type StackRecipeSelection<TRecipe extends StackRecipeInput> = RecipeVariantPropsFor<TRecipe, "gap" | "layout">;
+type StackStyleSystem<TMode extends string = string, TRecipe extends StackRecipeInput = StackRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    stack: TRecipe;
+  };
+}, TMetadata>;
+type StackStyleProps<TGap extends string = string, TLayout extends string = string> = Partial<StackRecipeSelection<StackRecipeInput<TGap, TLayout>>> & {
+  align?: StackAlign;
+  direction?: StackDirection;
+  justify?: StackJustify;
+  wrap?: boolean;
+};
+type StackProps<TGap extends string = string, TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<keyof HTMLElementTagNameMap>, "style"> & StackStyleProps<TGap, TLayout> & ResponsiveProps<StackStyleProps<TGap, TLayout>, TBreakpoint> & {
+  as?: keyof HTMLElementTagNameMap;
+  style?: never;
+};
+type StackOptions = {
+  defaultAlign?: StackAlign;
+  defaultDirection?: StackDirection;
+  defaultJustify?: StackJustify;
+  defaultWrap?: boolean;
+};
+declare function createStack<TMode extends string, TRecipe extends StackRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: StackStyleSystem<TMode, TRecipe, TMetadata>, options?: StackOptions): RemixComponent<StackProps<StackRecipeGap<TRecipe>, StackRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/stat.d.ts
+type StatRecipeInput<TValueTone extends string = string> = RecipeWithVariantGroups<"root" | "title" | "value", never, ComponentStyle, {
+  valueTone: TValueTone;
+}>;
+type StatRecipeValueTone<TRecipe extends StatRecipeInput> = RecipeVariantValue<TRecipe, "valueTone">;
+type StatRecipeSelection<TRecipe extends StatRecipeInput> = RecipeVariantPropsFor<TRecipe, "valueTone">;
+type StatStyleSystem<TMode extends string = string, TRecipe extends StatRecipeInput = StatRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    stat: TRecipe;
+  };
+}, TMetadata>;
+type StatProps<TValueTone extends string = string> = Omit<Props<"div">, "style"> & {
+  style?: never;
+  title: RemixNode;
+  titleProps?: ComponentSlotProps<"div">;
+  value: RemixNode;
+  valueProps?: ComponentSlotProps<"div">;
+  valueTone?: TValueTone;
+};
+declare function createStat<TMode extends string, TRecipe extends StatRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: StatStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<StatProps<StatRecipeValueTone<TRecipe>>>;
+//#endregion
+//#region kit/lab/design/components/remix/surface.d.ts
+type SurfaceRecipeInput<TVariant extends string = string, TDensity extends string = string, TLayout extends string = string> = RootRecipeInput<{
+  density: TDensity;
+  layout: TLayout;
+  variant: TVariant;
+}>;
+type SurfaceRecipeVariant<TRecipe extends SurfaceRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type SurfaceRecipeDensity<TRecipe extends SurfaceRecipeInput> = RecipeVariantValue<TRecipe, "density">;
+type SurfaceRecipeLayout<TRecipe extends SurfaceRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type SurfaceStyleSystem<TMode extends string = string, TRecipe extends SurfaceRecipeInput = SurfaceRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = RootStyleSystem<TMode, TRecipe, TMetadata, "surface">;
+declare function createSurface<TMode extends string, TRecipe extends SurfaceRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: SurfaceStyleSystem<TMode, TRecipe, TMetadata>): RootComponent<"density" | "layout" | "variant", TRecipe, BreakpointForStyleSystem<SurfaceStyleSystem<TMode, TRecipe, TMetadata>>>;
+//#endregion
+//#region kit/lab/design/components/remix/switch.d.ts
+type SwitchRecipeCondition = CommonRecipeCondition | "checked" | "unchecked";
+type SwitchRecipeInput<TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  size: TSize;
+  variant: TVariant;
+}>;
+type SwitchRecipeVariant<TRecipe extends SwitchRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type SwitchRecipeSize<TRecipe extends SwitchRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type SwitchRecipeSelection<TRecipe extends SwitchRecipeInput> = RecipeVariantPropsFor<TRecipe, "size" | "variant">;
+type SwitchStyleSystem<TMode extends string = string, TRecipe extends SwitchRecipeInput = SwitchRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    switch: TRecipe;
+  };
+}, TMetadata>;
+type SwitchProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"input">, "checked" | "defaultChecked" | "role" | "style" | "type"> & Partial<SwitchRecipeSelection<SwitchRecipeInput<TVariant, TSize>>> & ResponsiveProps<SwitchRecipeSelection<SwitchRecipeInput<TVariant, TSize>>, TBreakpoint> & {
+  checked?: boolean;
+  defaultChecked?: boolean;
+  style?: never;
+};
+declare function createSwitch<TMode extends string, TRecipe extends SwitchRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: SwitchStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<SwitchProps<SwitchRecipeVariant<TRecipe>, SwitchRecipeSize<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/table.d.ts
+type TableCellRole = "body" | "columnHeader" | "rowHeader";
+type TableHeaderCellScope = "col" | "row";
+type TableRecipeInput<TDensity extends string = string, TLayout extends string = string, TRowVariant extends string = string, TCellVariant extends string = string> = RecipeWithVariantGroups<"body" | "cell" | "head" | "root" | "row", never, ComponentStyle, {
+  cellRole: TableCellRole;
+  cellVariant: TCellVariant;
+  density: TDensity;
+  layout: TLayout;
+  rowVariant: TRowVariant;
+}>;
+type TableRecipeDensity<TRecipe extends TableRecipeInput> = RecipeVariantValue<TRecipe, "density">;
+type TableRecipeLayout<TRecipe extends TableRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type TableRecipeRowVariant<TRecipe extends TableRecipeInput> = RecipeVariantValue<TRecipe, "rowVariant">;
+type TableRecipeCellVariant<TRecipe extends TableRecipeInput> = RecipeVariantValue<TRecipe, "cellVariant">;
+type TableRecipeSelection<TRecipe extends TableRecipeInput> = RecipeVariantPropsFor<TRecipe, "cellRole" | "cellVariant" | "density" | "layout" | "rowVariant">;
+type TableStyleSystem<TMode extends string = string, TRecipe extends TableRecipeInput = TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    table: TRecipe;
+  };
+}, TMetadata>;
+type TableStyleProps<TDensity extends string = string, TLayout extends string = string> = {
+  density?: TDensity;
+  layout?: TLayout;
+};
+type TableProps<TDensity extends string = string, TLayout extends string = string, TBreakpoint extends string = string> = Omit<Props<"table">, "style"> & TableStyleProps<TDensity, TLayout> & ResponsiveProps<TableStyleProps<TDensity, TLayout>, TBreakpoint> & {
+  style?: never;
+};
+type TableSectionProps<TElement extends "tbody" | "thead"> = Omit<Props<TElement>, "style"> & {
+  style?: never;
+};
+type TableRowProps<TRowVariant extends string = string> = Omit<Props<"tr">, "style"> & {
+  style?: never;
+  variant?: TRowVariant;
+};
+type TableCellProps<TCellVariant extends string = string> = Omit<Props<"td">, "style"> & {
+  style?: never;
+  variant?: TCellVariant;
+};
+type TableHeaderCellProps<TCellVariant extends string = string> = Omit<Props<"th">, "scope" | "style"> & {
+  scope?: TableHeaderCellScope;
+  style?: never;
+  variant?: TCellVariant;
+};
+declare function createTable<TMode extends string, TRecipe extends TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TableStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TableProps<TableRecipeDensity<TRecipe>, TableRecipeLayout<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+declare function createTableHead<TMode extends string, TRecipe extends TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TableStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TableSectionProps<"thead">>;
+declare function createTableBody<TMode extends string, TRecipe extends TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TableStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TableSectionProps<"tbody">>;
+declare function createTableRow<TMode extends string, TRecipe extends TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TableStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TableRowProps<TableRecipeRowVariant<TRecipe>>>;
+declare function createTableCell<TMode extends string, TRecipe extends TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TableStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TableCellProps<TableRecipeCellVariant<TRecipe>>>;
+declare function createTableHeaderCell<TMode extends string, TRecipe extends TableRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TableStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TableHeaderCellProps<TableRecipeCellVariant<TRecipe>>>;
+//#endregion
+//#region kit/lab/design/components/remix/tabs.d.ts
+type TabsRecipeCondition = CommonRecipeCondition | "selected" | "unselected";
+type TabsRecipeInput<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"list" | "panel" | "root" | "trigger", string, ComponentStyle, {
+  layout: TLayout;
+  size: TSize;
+  variant: TVariant;
+}>;
+type TabsRecipeLayout<TRecipe extends TabsRecipeInput> = RecipeVariantValue<TRecipe, "layout">;
+type TabsRecipeVariant<TRecipe extends TabsRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type TabsRecipeSize<TRecipe extends TabsRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type TabsRecipeSelection<TRecipe extends TabsRecipeInput> = RecipeVariantPropsFor<TRecipe, "layout" | "size" | "variant">;
+type TabsStyleSystem<TMode extends string = string, TRecipe extends TabsRecipeInput = TabsRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    tabs: TRecipe;
+  };
+}, TMetadata>;
+type TabsValueChangeDetails = {
+  event?: Event;
+};
+type TabsValueChangeHandler<TValue extends string = string> = (value: TValue, details?: TabsValueChangeDetails) => void;
+type TabsRootStyleProps<TLayout extends string = string> = {
+  layout?: TLayout;
+};
+type TabsTriggerStyleProps<TVariant extends string = string, TSize extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type TabsRootProps<TLayout extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"div">, "style"> & TabsRootStyleProps<TLayout> & ResponsiveProps<TabsRootStyleProps<TLayout>, TBreakpoint> & {
+  defaultValue?: TValue | null;
+  onValueChange?: TabsValueChangeHandler<TValue>;
+  style?: never;
+  value?: TValue | null;
+};
+type TabsListProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type TabsTriggerProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string, TValue extends string = string> = Omit<Props<"button">, "style" | "value"> & TabsTriggerStyleProps<TVariant, TSize> & ResponsiveProps<TabsTriggerStyleProps<TVariant, TSize>, TBreakpoint> & {
+  style?: never;
+  value: TValue;
+};
+type TabsPanelProps<TValue extends string = string> = Omit<Props<"div">, "style"> & {
+  style?: never;
+  value: TValue;
+};
+type TabsComponents<TLayout extends string = string, TVariant extends string = string, TSize extends string = string> = {
+  List: RemixComponent<TabsListProps>;
+  Panel: RemixComponent<TabsPanelProps>;
+  Root: RemixComponent<TabsRootProps<TLayout>, TabsRootContext>;
+  Trigger: RemixComponent<TabsTriggerProps<TVariant, TSize>>;
+};
+type TabsRootContext = {
+  get_panel_id: (value: string) => string;
+  get_trigger_id: (value: string) => string;
+  get_value: () => string | null;
+  set_value: (value: string, details?: TabsValueChangeDetails) => void;
+};
+declare function createTabs<TMode extends string, TRecipe extends TabsRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TabsStyleSystem<TMode, TRecipe, TMetadata>): TabsComponents<TabsRecipeLayout<TRecipe>, TabsRecipeVariant<TRecipe>, TabsRecipeSize<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/text.d.ts
+type TextAlign = "center" | "end" | "justify" | "start";
+type TextRecipeSlot = "root";
+type TextRecipeInput<TVariant extends string = string, TTone extends string = string> = RecipeWithVariantGroups<TextRecipeSlot, string, ComponentStyle, {
+  tone: TTone;
+  variant: TVariant;
+}>;
+type TextRecipeVariant<TRecipe extends TextRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type TextRecipeTone<TRecipe extends TextRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type TextRecipeSelection<TRecipe extends TextRecipeInput> = RecipeVariantPropsFor<TRecipe, "tone" | "variant">;
+type TextStyleSystem<TMode extends string = string, TRecipe extends TextRecipeInput = TextRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    text: TRecipe;
+  };
+}, TMetadata>;
+type TextStyleProps<TVariant extends string, TTone extends string> = Partial<TextRecipeSelection<TextRecipeInput<TVariant, TTone>>> & {
+  align?: TextAlign;
+};
+type TextProps<TVariant extends string = string, TTone extends string = string, TBreakpoint extends string = string> = Omit<Props<keyof HTMLElementTagNameMap>, "style"> & TextStyleProps<TVariant, TTone> & ResponsiveProps<TextStyleProps<TVariant, TTone>, TBreakpoint> & {
+  as?: keyof HTMLElementTagNameMap;
+  style?: never;
+};
+declare function createText<TMode extends string, TRecipe extends TextRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TextStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TextProps<TextRecipeVariant<TRecipe>, TextRecipeTone<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/textarea.d.ts
+type TextareaRecipeInput<TVariant extends string = string, TSize extends string = string> = RecipeWithVariantGroups<"root", string, ComponentStyle, {
+  size: TSize;
+  variant: TVariant;
+}>;
+type TextareaRecipeVariant<TRecipe extends TextareaRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type TextareaRecipeSize<TRecipe extends TextareaRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type TextareaRecipeSelection<TRecipe extends TextareaRecipeInput> = RecipeVariantPropsFor<TRecipe, "size" | "variant">;
+type TextareaStyleSystem<TMode extends string = string, TRecipe extends TextareaRecipeInput = TextareaRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    textarea: TRecipe;
+  };
+}, TMetadata>;
+type TextareaProps<TVariant extends string = string, TSize extends string = string, TBreakpoint extends string = string> = Omit<Props<"textarea">, "style"> & Partial<TextareaRecipeSelection<TextareaRecipeInput<TVariant, TSize>>> & ResponsiveProps<TextareaRecipeSelection<TextareaRecipeInput<TVariant, TSize>>, TBreakpoint> & {
+  style?: never;
+};
+declare function createTextarea<TMode extends string, TRecipe extends TextareaRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TextareaStyleSystem<TMode, TRecipe, TMetadata>): RemixComponent<TextareaProps<TextareaRecipeVariant<TRecipe>, TextareaRecipeSize<TRecipe>, BreakpointForStyleSystem<typeof style_system>>>;
+//#endregion
+//#region kit/lab/design/components/remix/toast.d.ts
+type ToastRecipeCondition = CommonRecipeCondition | "closed" | "open";
+type ToastRecipeInput<TTone extends string = string, TVariant extends string = string> = RecipeWithVariantGroups<"close" | "description" | "root" | "title" | "viewport", string, ComponentStyle, {
+  tone: TTone;
+  variant: TVariant;
+}>;
+type ToastRecipeTone<TRecipe extends ToastRecipeInput> = RecipeVariantValue<TRecipe, "tone">;
+type ToastRecipeVariant<TRecipe extends ToastRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type ToastRecipeSelection<TRecipe extends ToastRecipeInput> = RecipeVariantPropsFor<TRecipe, "tone" | "variant">;
+type ToastStyleSystem<TMode extends string = string, TRecipe extends ToastRecipeInput = ToastRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    toast: TRecipe;
+  };
+}, TMetadata>;
+type ToastOpenChangeDetails = {
+  event?: Event;
+  reason: "close";
+};
+type ToastOpenChangeHandler = (open: boolean, details?: ToastOpenChangeDetails) => void;
+type ToastRootStyleProps<TTone extends string = string, TVariant extends string = string> = {
+  tone?: TTone;
+  variant?: TVariant;
+};
+type ToastRootProps<TTone extends string = string, TVariant extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & ToastRootStyleProps<TTone, TVariant> & ResponsiveProps<ToastRootStyleProps<TTone, TVariant>, TBreakpoint> & {
+  defaultOpen?: boolean;
+  onOpenChange?: ToastOpenChangeHandler;
+  open?: boolean;
+  style?: never;
+};
+type ToastViewportProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type ToastTitleProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type ToastDescriptionProps = Omit<Props<"div">, "style"> & {
+  style?: never;
+};
+type ToastCloseProps = Omit<Props<"button">, "style"> & {
+  style?: never;
+};
+type ToastComponents<TTone extends string = string, TVariant extends string = string> = {
+  Close: RemixComponent<ToastCloseProps>;
+  Description: RemixComponent<ToastDescriptionProps>;
+  Root: RemixComponent<ToastRootProps<TTone, TVariant>, ToastContext>;
+  Title: RemixComponent<ToastTitleProps>;
+  Viewport: RemixComponent<ToastViewportProps>;
+};
+type ToastContext = {
+  close: (details: ToastOpenChangeDetails) => void;
+  get_open: () => boolean;
+};
+declare function createToast<TMode extends string, TRecipe extends ToastRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: ToastStyleSystem<TMode, TRecipe, TMetadata>): ToastComponents<ToastRecipeTone<TRecipe>, ToastRecipeVariant<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/tooltip.d.ts
+type TooltipRecipeCondition = CommonRecipeCondition | "closed" | "open";
+type TooltipRecipeInput<TSize extends string = string, TVariant extends string = string> = RecipeWithVariantGroups<"popup" | "trigger", string, ComponentStyle, {
+  size: TSize;
+  variant: TVariant;
+}>;
+type TooltipRecipeSize<TRecipe extends TooltipRecipeInput> = RecipeVariantValue<TRecipe, "size">;
+type TooltipRecipeVariant<TRecipe extends TooltipRecipeInput> = RecipeVariantValue<TRecipe, "variant">;
+type TooltipRecipeSelection<TRecipe extends TooltipRecipeInput> = RecipeVariantPropsFor<TRecipe, "size" | "variant">;
+type TooltipStyleSystem<TMode extends string = string, TRecipe extends TooltipRecipeInput = TooltipRecipeInput, TMetadata extends AnyGeneratedSystemMetadata = AnyGeneratedSystemMetadata> = ComponentStyleSystem<TMode, {
+  recipe: {
+    tooltip: TRecipe;
+  };
+}, TMetadata>;
+type TooltipOpenChangeDetails = {
+  event?: Event;
+  reason: "blur" | "focus" | "pointerEnter" | "pointerLeave";
+};
+type TooltipOpenChangeHandler = (open: boolean, details?: TooltipOpenChangeDetails) => void;
+type TooltipRootProps = {
+  children?: RemixNode;
+  defaultOpen?: boolean;
+  onOpenChange?: TooltipOpenChangeHandler;
+  open?: boolean;
+};
+type TooltipStyleProps<TSize extends string = string, TVariant extends string = string> = {
+  size?: TSize;
+  variant?: TVariant;
+};
+type TooltipTriggerProps<TSize extends string = string, TVariant extends string = string, TBreakpoint extends string = string> = Omit<Props<"button">, "style"> & TooltipStyleProps<TSize, TVariant> & ResponsiveProps<TooltipStyleProps<TSize, TVariant>, TBreakpoint> & {
+  style?: never;
+};
+type TooltipPopupProps<TSize extends string = string, TVariant extends string = string, TBreakpoint extends string = string> = Omit<Props<"div">, "style"> & TooltipStyleProps<TSize, TVariant> & ResponsiveProps<TooltipStyleProps<TSize, TVariant>, TBreakpoint> & {
+  style?: never;
+};
+type TooltipComponents<TSize extends string = string, TVariant extends string = string> = {
+  Popup: RemixComponent<TooltipPopupProps<TSize, TVariant>>;
+  Root: RemixComponent<TooltipRootProps, TooltipContext>;
+  Trigger: RemixComponent<TooltipTriggerProps<TSize, TVariant>>;
+};
+type TooltipContext = {
+  close: (details: TooltipOpenChangeDetails) => void;
+  get_open: () => boolean;
+  get_popup_id: () => string;
+  open: (details: TooltipOpenChangeDetails) => void;
+};
+declare function createTooltip<TMode extends string, TRecipe extends TooltipRecipeInput, TMetadata extends AnyGeneratedSystemMetadata>(style_system: TooltipStyleSystem<TMode, TRecipe, TMetadata>): TooltipComponents<TooltipRecipeSize<TRecipe>, TooltipRecipeVariant<TRecipe>>;
+//#endregion
+//#region kit/lab/design/components/remix/visually-hidden.d.ts
+declare const visuallyHiddenDefaultElement = "span";
+declare const visuallyHiddenFocusableSelector = "&:not(:focus):not(:active)";
+declare const visuallyHiddenPart: {
+  readonly root: "root";
+};
+declare const visuallyHiddenScope = "visuallyHidden";
+declare const visuallyHiddenStyle: {
+  readonly border: 0;
+  readonly clip: "rect(0 0 0 0)";
+  readonly clipPath: "inset(50%)";
+  readonly height: "1px";
+  readonly margin: "-1px";
+  readonly overflow: "hidden";
+  readonly padding: 0;
+  readonly position: "absolute";
+  readonly whiteSpace: "nowrap";
+  readonly width: "1px";
+};
+type VisuallyHiddenElement = keyof HTMLElementTagNameMap;
+type VisuallyHiddenProps<TElement extends VisuallyHiddenElement = "span"> = Omit<Props<TElement>, "style"> & {
+  as?: TElement;
+  isFocusable?: boolean;
+  style?: never;
+};
+declare function createVisuallyHidden<TMode extends string, TMetadata extends {
+  breakpoint?: Record<string, string | number>;
+}>(style_system: ComponentStyleSystem<TMode, unknown, TMetadata>): RemixComponent<VisuallyHiddenProps>;
+//#endregion
+export { type ARIABoolean, type AccordionComponents, type AccordionItemProps, type AccordionItemStyleProps, type AccordionPanelProps, type AccordionRecipeCondition, type AccordionRecipeInput, type AccordionRecipeLayout, type AccordionRecipeSelection, type AccordionRecipeSize, type AccordionRecipeVariant, type AccordionRootProps, type AccordionRootStyleProps, type AccordionStyleSystem, type AccordionTriggerProps, type AccordionValue, type AccordionValueChangeDetails, type AccordionValueChangeHandler, type AlertComponents, type AlertDescriptionProps, type AlertDialogActionProps, type AlertDialogCancelProps, type AlertDialogComponents, type AlertDialogDescriptionProps, type AlertDialogOpenChangeDetails, type AlertDialogOpenChangeHandler, type AlertDialogOpenChangeReason, type AlertDialogPopupProps, type AlertDialogPopupStyleProps, type AlertDialogRecipeCondition, type AlertDialogRecipeInput, type AlertDialogRecipeLayout, type AlertDialogRecipeSelection, type AlertDialogRootProps, type AlertDialogStyleSystem, type AlertDialogTitleProps, type AlertDialogTriggerProps, type AlertIconProps, type AlertRecipeInput, type AlertRecipeSelection, type AlertRecipeSlot, type AlertRecipeTone, type AlertRecipeVariant, type AlertRootProps, type AlertRootStyleProps, type AlertStyleSystem, type AlertTitleProps, type AspectRatioOverflow, type AspectRatioProps, type AspectRatioStyleProps, type BadgeRecipeInput, type BadgeRecipeSize, type BadgeRecipeTone, type BadgeStyleSystem, type BoxRecipeInput, type BoxRecipeLayout, type BoxStyleSystem, type BreakpointForStyleSystem, type ButtonOptions, type ButtonProps, type ButtonRecipeCondition, type ButtonRecipeInput, type ButtonRecipeLayout, type ButtonRecipeSelection, type ButtonRecipeSize, type ButtonRecipeSlot, type ButtonRecipeVariant, type ButtonStyleProps, type ButtonStyleSystem, type CalloutProps, type CalloutRecipeInput, type CalloutRecipeSelection, type CalloutRecipeTone, type CalloutStyleSystem, type CheckboxChecked, type CheckboxGroupComponents, type CheckboxGroupItemProps, type CheckboxGroupItemStyleProps, type CheckboxGroupRecipeCondition, type CheckboxGroupRecipeInput, type CheckboxGroupRecipeLayout, type CheckboxGroupRecipeSelection, type CheckboxGroupRecipeSize, type CheckboxGroupRecipeVariant, type CheckboxGroupRootProps, type CheckboxGroupRootStyleProps, type CheckboxGroupStyleSystem, type CheckboxGroupValueChangeDetails, type CheckboxGroupValueChangeHandler, type CheckboxProps, type CheckboxRecipeCondition, type CheckboxRecipeInput, type CheckboxRecipeSelection, type CheckboxRecipeSize, type CheckboxRecipeVariant, type CheckboxStyleSystem, type ChipProps, type ChipRecipeInput, type ChipRecipeSelection, type ChipRecipeSize, type ChipRecipeVariant, type ChipStyleProps, type ChipStyleSystem, type CodeBlockProps, type CodeBlockRecipeInput, type CodeBlockStyleSystem, type CollapsibleComponents, type CollapsibleContentProps, type CollapsibleOpenChangeDetails, type CollapsibleOpenChangeHandler, type CollapsibleRecipeCondition, type CollapsibleRecipeInput, type CollapsibleRecipeLayout, type CollapsibleRecipeSelection, type CollapsibleRootProps, type CollapsibleRootStyleProps, type CollapsibleStyleSystem, type CollapsibleTriggerProps, type CommonRecipeCondition, type ComponentAnatomyAttrs, type ComponentSlotProps, type ComponentStyle, type ComponentStyleHostElementMap, type ComponentStyleSystem, type ComponentStyleTargetInput, type ComponentStyleTargetOutput, type ComponentStyleTargetRecipeInput, type ComponentStyleTargetsInput, type ComponentStyleTargetsOutput, type DescriptionListItemProps, type DescriptionListItemStyleProps, type DescriptionListLayout, type DescriptionListProps, type DescriptionListRecipeDescriptionTone, type DescriptionListRecipeInput, type DescriptionListRecipeSelection, type DescriptionListRecipeTone, type DescriptionListStyleSystem, type DialogCloseProps, type DialogComponents, type DialogDescriptionProps, type DialogOpenChangeDetails, type DialogOpenChangeHandler, type DialogOpenChangeReason, type DialogOverlayProps, type DialogPopupProps, type DialogPopupStyleProps, type DialogProps, type DialogRecipeCondition, type DialogRecipeInput, type DialogRecipePopupLayout, type DialogRecipeSelection, type DialogRecipeSlot, type DialogRequiredRecipeSlot, type DialogStyleSystem, type DialogTitleProps, type DialogTriggerProps, type EmptyStateProps, type EmptyStateRecipeInput, type EmptyStateStyleSystem, type FieldComponents, type FieldControlMixin, type FieldDescriptionProps, type FieldErrorProps, type FieldLabelProps, type FieldProps, type FieldRecipeInput, type FieldRecipeSlot, type FieldStyleSystem, type FieldsetComponents, type FieldsetLegendProps, type FieldsetRecipeInput, type FieldsetRecipeLayout, type FieldsetRecipeSelection, type FieldsetRootProps, type FieldsetRootStyleProps, type FieldsetStyleSystem, type FormProps, type FormRecipeInput, type FormRecipeLayout, type FormRecipeSelection, type FormStyleProps, type FormStyleSystem, type GridAlign, type GridJustify, type GridProps, type GridRecipeColumns, type GridRecipeGap, type GridRecipeInput, type GridRecipeLayout, type GridRecipeSelection, type GridStyleProps, type GridStyleSystem, type IconElement, type IconProps, type IconRecipeInput, type IconRecipeLayout, type IconRecipeSelection, type IconRecipeSize, type IconRecipeTone, type IconRotate, type IconStyleProps, type IconStyleSystem, type InputProps, type InputRecipeInput, type InputRecipeSelection, type InputRecipeSize, type InputRecipeVariant, type InputStyleSystem, type KbdProps, type KbdRecipeInput, type KbdRecipeSize, type KbdStyleSystem, type ListElement, type ListItemProps, type ListProps, type ListRecipeInput, type ListStyleSystem, type ListboxComponents, type ListboxGroupLabelProps, type ListboxGroupProps, type ListboxHighlightChangeDetails, type ListboxHighlightChangeHandler, type ListboxHighlightChangeReason, type ListboxOptionIndicatorProps, type ListboxOptionProps, type ListboxOptionStyleProps, type ListboxOptionTextProps, type ListboxOptions, type ListboxOrientation, type ListboxRecipeCondition, type ListboxRecipeInput, type ListboxRecipeLayout, type ListboxRecipeSelection, type ListboxRecipeSize, type ListboxRecipeSlot, type ListboxRecipeVariant, type ListboxRootMultipleSelectionProps, type ListboxRootProps, type ListboxRootSelectionProps, type ListboxRootSharedProps, type ListboxRootSingleSelectionProps, type ListboxRootStyleProps, type ListboxSelectionMode, type ListboxStyleSystem, type ListboxValueChangeDetails, type ListboxValueChangeHandler, type ListboxValueChangeReason, type ListboxValuesChangeHandler, type MenuCheckboxItemProps, type MenuChecked, type MenuCheckedChangeHandler, type MenuComponents, type MenuGroupLabelProps, type MenuGroupProps, type MenuItemFocusDetails, type MenuItemFocusReason, type MenuItemIndicatorProps, type MenuItemProps, type MenuItemSelectDetails, type MenuItemSelectReason, type MenuItemStyleProps, type MenuOpenChangeDetails, type MenuOpenChangeHandler, type MenuOpenChangeReason, type MenuPopupProps, type MenuPopupStyleProps, type MenuRadioGroupProps, type MenuRadioItemProps, type MenuRadioValueChangeHandler, type MenuRecipeCondition, type MenuRecipeInput, type MenuRecipeLayout, type MenuRecipeSelection, type MenuRecipeSize, type MenuRecipeSlot, type MenuRecipeVariant, type MenuRootProps, type MenuSeparatorProps, type MenuStyleSystem, type MenuTriggerProps, type MenuTriggerStyleProps, type OpenStateName, type PopoverAlign, type PopoverArrowProps, type PopoverCloseProps, type PopoverComponents, type PopoverDescriptionProps, type PopoverOpenChangeDetails, type PopoverOpenChangeHandler, type PopoverOpenChangeReason, type PopoverOptions, type PopoverPopupProps, type PopoverPopupStyleProps, type PopoverRecipeCondition, type PopoverRecipeInput, type PopoverRecipeSize, type PopoverRecipeSlot, type PopoverRootProps, type PopoverSide, type PopoverStyleSystem, type PopoverTitleProps, type PopoverTriggerProps, type ProgressProps, type ProgressRecipeInput, type ProgressRecipeSelection, type ProgressRecipeTone, type ProgressSegment, type ProgressStyleSystem, type RadioGroupComponents, type RadioGroupItemProps, type RadioGroupItemStyleProps, type RadioGroupRecipeCondition, type RadioGroupRecipeInput, type RadioGroupRecipeLayout, type RadioGroupRecipeSelection, type RadioGroupRecipeSize, type RadioGroupRecipeVariant, type RadioGroupRootProps, type RadioGroupRootStyleProps, type RadioGroupStyleSystem, type RadioGroupValueChangeDetails, type RadioGroupValueChangeHandler, type RecipeConditionSelectorMap, type RecipeStyleInput, type RemixComponent, type ResponsiveProps, type SelectComponents, type SelectGroupLabelProps, type SelectGroupProps, type SelectHighlightChangeDetails, type SelectHighlightChangeHandler, type SelectHighlightChangeReason, type SelectIconProps, type SelectListProps, type SelectOpenChangeDetails, type SelectOpenChangeHandler, type SelectOpenChangeReason, type SelectOptionIndicatorProps, type SelectOptionProps, type SelectOptionTextProps, type SelectOptions, type SelectPopupProps, type SelectPopupStyleProps, type SelectProps, type SelectRecipeCondition, type SelectRecipeInput, type SelectRecipePopupLayout, type SelectRecipeSelection, type SelectRecipeSize, type SelectRecipeSlot, type SelectRecipeVariant, type SelectSeparatorProps, type SelectStyleSystem, type SelectTriggerProps, type SelectTriggerStyleProps, type SelectValueChangeDetails, type SelectValueChangeHandler, type SelectValueChangeReason, type SelectValueProps, type SelectionStateName, type SeparatorOrientation, type SeparatorProps, type SeparatorRecipeInput, type SeparatorStyleSystem, type SliderOptions, type SliderProps, type SliderRecipeCondition, type SliderRecipeInput, type SliderRecipeLayout, type SliderRecipeSelection, type SliderRecipeSlot, type SliderStyleProps, type SliderStyleSystem, type SliderStyleTarget, type SliderTargetStyles, type SpinnerProps, type SpinnerRecipeInput, type SpinnerRecipeSelection, type SpinnerRecipeSize, type SpinnerRecipeTone, type SpinnerStyleSystem, type StackAlign, type StackDirection, type StackJustify, type StackOptions, type StackProps, type StackRecipeGap, type StackRecipeInput, type StackRecipeLayout, type StackRecipeSelection, type StackStyleProps, type StackStyleSystem, type StatProps, type StatRecipeInput, type StatRecipeSelection, type StatRecipeValueTone, type StatStyleSystem, type SurfaceRecipeDensity, type SurfaceRecipeInput, type SurfaceRecipeLayout, type SurfaceRecipeVariant, type SurfaceStyleSystem, type SwitchProps, type SwitchRecipeCondition, type SwitchRecipeInput, type SwitchRecipeSelection, type SwitchRecipeSize, type SwitchRecipeVariant, type SwitchStyleSystem, type TableCellProps, type TableCellRole, type TableHeaderCellProps, type TableHeaderCellScope, type TableProps, type TableRecipeCellVariant, type TableRecipeDensity, type TableRecipeInput, type TableRecipeLayout, type TableRecipeRowVariant, type TableRecipeSelection, type TableRowProps, type TableSectionProps, type TableStyleProps, type TableStyleSystem, type TabsComponents, type TabsListProps, type TabsPanelProps, type TabsRecipeCondition, type TabsRecipeInput, type TabsRecipeLayout, type TabsRecipeSelection, type TabsRecipeSize, type TabsRecipeVariant, type TabsRootProps, type TabsRootStyleProps, type TabsStyleSystem, type TabsTriggerProps, type TabsTriggerStyleProps, type TabsValueChangeDetails, type TabsValueChangeHandler, type TextAlign, type TextProps, type TextRecipeInput, type TextRecipeSelection, type TextRecipeTone, type TextRecipeVariant, type TextStyleSystem, type TextareaProps, type TextareaRecipeInput, type TextareaRecipeSelection, type TextareaRecipeSize, type TextareaRecipeVariant, type TextareaStyleSystem, type ToastCloseProps, type ToastComponents, type ToastDescriptionProps, type ToastOpenChangeDetails, type ToastOpenChangeHandler, type ToastRecipeCondition, type ToastRecipeInput, type ToastRecipeSelection, type ToastRecipeTone, type ToastRecipeVariant, type ToastRootProps, type ToastRootStyleProps, type ToastStyleSystem, type ToastTitleProps, type ToastViewportProps, type TooltipComponents, type TooltipOpenChangeDetails, type TooltipOpenChangeHandler, type TooltipPopupProps, type TooltipRecipeCondition, type TooltipRecipeInput, type TooltipRecipeSelection, type TooltipRecipeSize, type TooltipRecipeVariant, type TooltipRootProps, type TooltipStyleProps, type TooltipStyleSystem, type TooltipTriggerProps, type VisuallyHiddenElement, type VisuallyHiddenProps, ariaBoolean, ariaTrue, commonConditions, componentAnatomyAttrs, componentDataAttribute, componentStateAttribute, createAccordion, createAlert, createAlertDialog, createAspectRatio, createBadge, createBox, createButton, createCallout, createCheckbox, createCheckboxGroup, createChip, createCodeBlock, createCollapsible, createComponentAnatomyAttrs, createComponentSlotProps, createComponentStyleTargets, createDescriptionList, createDescriptionListItem, createDialog, createEmptyState, createField, createFieldControlMixin, createFieldDescription, createFieldError, createFieldLabel, createFieldParts, createFieldset, createForm, createGrid, createIcon, createInput, createKbd, createList, createListItem, createListbox, createMenu, createPopover, createProgress, createRadioGroup, createRecipeMix, createRecipeStyle, createResponsiveRecipeStyle, createResponsiveStyle, createSelect, createSeparator, createSlider, createSpinner, createStack, createStat, createSurface, createSwitch, createTable, createTableBody, createTableCell, createTableHead, createTableHeaderCell, createTableRow, createTabs, createText, createTextarea, createToast, createTooltip, createVisuallyHidden, dataFlag, kbdDefaultElement, kbdScope, listboxHighlightChangeReason, listboxValueChangeReason, menuAnatomy, menuItemFocusReason, menuItemSelectReason, menuOpenChangeReason, mergeRecipeConditionSelectors, openState, openStateFromBoolean, popoverAnatomy, selectHighlightChangeReason, selectOpenChangeReason, selectValueChangeReason, selectionState, selectionStateFromBoolean, separatorDecorativeRole, separatorHiddenAttribute, separatorOrientation, separatorOrientationAttribute, separatorRole, sliderProgressVariable, visuallyHiddenDefaultElement, visuallyHiddenFocusableSelector, visuallyHiddenPart, visuallyHiddenScope, visuallyHiddenStyle };
+//# sourceMappingURL=remix.d.ts.map