@hanzo/gui

declare const Accordion: React.ForwardRefExoticComponent<ScopedProps<AccordionMultipleProps | AccordionSingleProps> & React.RefAttributes<AccordionElement>> & {
    Trigger: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps & void, import("@hanzogui/web").StackStyleBase, {
        unstyled?: boolean | undefined;
    }>, GuiElement, import("@hanzogui/web").StackNonStyleProps & void, import("@hanzogui/web").StackStyleBase, {
        unstyled?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>;
    Header: React.ForwardRefExoticComponent<Omit<Omit<import("@hanzogui/web").TextNonStyleProps, "size" | "unstyled" | keyof import("@hanzogui/web").TextStylePropsBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").TextStylePropsBase> & {
        size?: import("@hanzogui/web").FontSizeTokens | undefined;
        unstyled?: boolean | undefined;
    } & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").TextStylePropsBase>> & …

@hanzogui/accordion/types/Accordion.d.ts

type AccordionContentProps = GetProps<typeof AccordionContentFrame>;

@hanzogui/accordion/types/Accordion.d.ts

type AccordionHeaderProps = PrimitiveHeading3Props;

@hanzogui/accordion/types/Accordion.d.ts

interface AccordionItemProps extends Omit<CollapsibleProps, 'open' | 'defaultOpen' | 'onOpenChange'> {
    /**
     * Whether or not an accordion item is disabled from user interaction.
     *
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * A string value for the accordion item. All items within an accordion should use a unique value.
     */
    value: string;
}

@hanzogui/accordion/types/Accordion.d.ts

interface AccordionMultipleProps extends AccordionImplMultipleProps {
    type: 'multiple';
}

@hanzogui/accordion/types/Accordion.d.ts

interface AccordionSingleProps extends AccordionImplSingleProps {
    type: 'single';
}

@hanzogui/accordion/types/Accordion.d.ts

type AccordionTriggerProps = GetProps<typeof AccordionTriggerFrame>;

@hanzogui/accordion/types/Accordion.d.ts

declare enum ACTIONS {
    REGISTER_HOST = 0,
    DEREGISTER_HOST = 1,
    ADD_UPDATE_PORTAL = 2,
    REMOVE_PORTAL = 3
}

@hanzogui/portal/types/GorhomPortal.d.ts

export type ActionTypes = AddUpdatePortalAction | RemovePortalAction | RegisterHostAction | UnregisterHostAction;

@hanzogui/portal/types/GorhomPortal.d.ts

export declare const Adapt: ((props: AdaptProps) => React.JSX.Element) & {
    Contents: typeof AdaptContents;
};

@hanzogui/adapt/types/Adapt.d.ts

export declare function AdaptContents({ scope, ...rest }: {
    scope?: string;
}): React.FunctionComponentElement<any>;
export declare namespace AdaptContents {
    var shouldForwardSpace: boolean;
}

@hanzogui/adapt/types/Adapt.d.ts

export declare const AdaptContext: import("@hanzogui/web").StyledContext<AdaptParentContextI>;

@hanzogui/adapt/types/Adapt.d.ts

export declare const AdaptParent: ({ children, Contents, scope, portal }: AdaptParentProps) => React.JSX.Element;

@hanzogui/adapt/types/Adapt.d.ts

export type AdaptParentContextI = {
    Contents: Component;
    scopeName: string;
    platform: AdaptPlatform;
    setPlatform: (when: AdaptPlatform) => any;
    when: AdaptWhen;
    setWhen: (when: AdaptWhen) => any;
    portalName?: string;
    lastScope?: string;
};

@hanzogui/adapt/types/Adapt.d.ts

export type AdaptPlatform = AllPlatforms | 'touch' | null;

@hanzogui/adapt/types/Adapt.d.ts

export declare const AdaptPortalContents: (props: {
    children: React.ReactNode;
    scope?: string;
    passThrough?: boolean;
}) => React.JSX.Element;

@hanzogui/adapt/types/Adapt.d.ts

export type AdaptProps = {
    scope?: string;
    when?: AdaptWhen;
    platform?: AdaptPlatform;
    children: React.JSX.Element | ((children: React.ReactNode) => React.ReactNode);
};

@hanzogui/adapt/types/Adapt.d.ts

Interfaces

export type AdaptWhen = MediaQueryKeyString | boolean | null;

@hanzogui/adapt/types/Adapt.d.ts

export declare function addTheme(props: {
    name: string;
    theme: Partial<Record<keyof ThemeDefinition, any>>;
    insertCSS?: boolean;
}): {
    themeRaw: ThemeParsed;
    theme: {};
    cssRules: string[];
} | undefined;

@hanzogui/theme/types/addTheme.d.ts

export interface AddUpdatePortalAction {
    type: ACTIONS;
    hostName: string;
    portalName: string;
    node: ReactNode;
}

@hanzogui/portal/types/GorhomPortal.d.ts

declare const AlertDialog: React.FC<AlertDialogProps> & {
    Trigger: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "scope" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/web").StackNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<DialogTriggerProps, "scope"> & {
        scope?: AlertDialogScopes;
    }, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & Omit<DialogTriggerProps, "scope"> & {
        scope?: AlertDialogScopes;
    }, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;
    Portal: React.FC<AlertDialogPortalProps>;
    Overlay: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, …

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogAction: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "displayWhenAdapted" | "scope" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/core").RNGuiViewNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<DialogCloseProps, "scope"> & {
    scope?: AlertDialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & Omit<DialogCloseProps, "scope"> & {
    scope?: AlertDialogScopes;
}, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogActionProps = ScopedProps<DialogCloseProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogCancel: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "displayWhenAdapted" | "scope" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/core").RNGuiViewNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<DialogCloseProps, "scope"> & {
    scope?: AlertDialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & Omit<DialogCloseProps, "scope"> & {
    scope?: AlertDialogScopes;
}, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogCancelProps = ScopedProps<DialogCloseProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<Omit<DialogContentProps, "onInteractOutside" | "onPointerDownOutside">, "scope"> & {
    scope?: AlertDialogScopes;
} & React.RefAttributes<GuiElement>>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogContentProps = ScopedProps<Omit<DialogContentProps, 'onPointerDownOutside' | 'onInteractOutside'>>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogDescription: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | "accessibilityLabelledBy" | "accessibilityLanguage" | "accessibilityLargeContentTitle" | "accessibilityLiveRegion" | "accessibilityRespondsToUserInteraction" | "accessibilityRole" | "accessibilityShowsLargeContentViewer" | "accessibilityState" | "accessibilityValue" | "accessibilityViewIsModal" | "accessible" | "adjustsFontSizeToFit" | "allowFontScaling" | "android_hyphenationFrequency" | "animatedBy" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-hidden" | "aria-label" | "aria-labelledby" | "aria-live" | "aria-modal" | "aria-selected" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "asChild" | "children" | "className" | "componentName" | "dangerouslySetInnerHTML" | "dataDetectorType" | "debug" | "disableClassName" | "disableOptimization" | "disabled" | "dynamicTypeRamp" | …

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogDescriptionProps = ScopedProps<DialogDescriptionProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogDestructive: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "displayWhenAdapted" | "scope" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/core").RNGuiViewNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<DialogCloseProps, "scope"> & {
    scope?: AlertDialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & Omit<DialogCloseProps, "scope"> & {
    scope?: AlertDialogScopes;
}, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogDestructiveProps = ScopedProps<DialogCloseProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogOverlay: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    open?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, "forceMount" | "scope" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/core").RNGuiViewNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/stacks").StackVariants | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<{}, "scope"> & {
    scope?: AlertDialogScopes;
} & {
    forceMount?: boolean;
} & {
    scope?: import("@hanzogui/dialog").DialogScopes;
} & …

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogOverlayProps = AlertDialogOverlayExtraProps & DialogOverlayProps;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogPortal: React.FC<AlertDialogPortalProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogPortalProps = ScopedProps<DialogPortalProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogProps = ScopedProps<DialogProps> & {
    native?: boolean;
};

@hanzogui/alert-dialog/types/AlertDialog.d.ts

export type AlertDialogScopes = string;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogTitle: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | "accessibilityLabelledBy" | "accessibilityLanguage" | "accessibilityLargeContentTitle" | "accessibilityLiveRegion" | "accessibilityRespondsToUserInteraction" | "accessibilityRole" | "accessibilityShowsLargeContentViewer" | "accessibilityState" | "accessibilityValue" | "accessibilityViewIsModal" | "accessible" | "adjustsFontSizeToFit" | "allowFontScaling" | "android_hyphenationFrequency" | "animatedBy" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-hidden" | "aria-label" | "aria-labelledby" | "aria-live" | "aria-modal" | "aria-selected" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "asChild" | "children" | "className" | "componentName" | "dangerouslySetInnerHTML" | "dataDetectorType" | "debug" | "disableClassName" | "disableOptimization" | "disabled" | "dynamicTypeRamp" | "ellipsizeMode" …

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogTitleProps = ScopedProps<DialogTitleProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

declare const AlertDialogTrigger: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "scope" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/web").StackNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<DialogTriggerProps, "scope"> & {
    scope?: AlertDialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & Omit<DialogTriggerProps, "scope"> & {
    scope?: AlertDialogScopes;
}, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

type AlertDialogTriggerProps = ScopedProps<DialogTriggerProps>;

@hanzogui/alert-dialog/types/AlertDialog.d.ts

export declare const allPortalHosts: Map<string, HTMLElement>;

@hanzogui/portal/types/constants.d.ts

export declare const Anchor: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, keyof AnchorExtraProps> & AnchorExtraProps, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps & AnchorExtraProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzo/gui/types/views/Anchor.d.ts

export interface AnchorExtraProps {
    href?: string;
    target?: string;
    rel?: string;
}

@hanzo/gui/types/views/Anchor.d.ts

export type AnchorProps = SizableTextProps & AnchorExtraProps;

@hanzo/gui/types/views/Anchor.d.ts

Because mounting and unmounting children can be expensive, this gives us the option to avoid that. type: 'presence' will act just like AnimatePresence, except you use `present` instead of conditional children. Note that this does avoid reconciling the children even when present={false} so no extra cost to perf over AnimatePresence. type: 'presence' with keepChildrenMounted true *always* render the children so you pay the cost up-front to mount them, but then you avoid the mount cost at the start of the animation. There's no "right way" it just depends on the use case, this component just makes it easier to choose the strategy yourself.

export declare function Animate({ children, lazyMount, type, present, passThrough, ...props }: AnimateProps): React.ReactNode;

@hanzogui/animate/types/Animate.d.ts

export declare const AnimatePresence: FunctionComponent<PropsWithChildren<AnimatePresenceProps>>;

@hanzogui/animate-presence/types/AnimatePresence.d.ts

@public

export interface AnimatePresenceProps {
    /**
     * Determines how to handle entering and exiting elements.
     * - "sync": Default. Elements animate in and out simultaneously.
     * - "wait": Wait for exit to finish before entering.
     *
     * @public
     */
    mode?: 'sync' | 'wait';
    /**
     * By passing `initial={false}`, `AnimatePresence` will disable any initial animations on children
     * that are present when the component is first rendered.
     *
     * ```jsx
     * <AnimatePresence initial={false}>
     *   {isVisible && (
     *     <motion.div
     *       key="modal"
     *       initial={{ opacity: 0 }}
     *       animate={{ opacity: 1 }}
     *       exit={{ opacity: 0 }}
     *     />
     *   )}
     * </AnimatePresence>
     * ```
     *
     * @public
     */
    initial?: boolean;
    /**
     * When a component is removed, there's no longer a chance to update its props directly. So if you need to update
     * a variant for that component as it renders for the exit animation, set `custom` to an object value that
     * is applied to the animating childrens props before they render once more to determine their final exit styles.
     *
     * …

@hanzogui/animate-presence/types/types.d.ts

export type AnimateProps = BaseProps & PresenceProps;

@hanzogui/animate/types/Animate.d.ts

export declare const Article: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

export declare const Aside: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

@summary A component that displays an image or a fallback icon. @see — Docs https://hanzogui.dev/ui/avatar @example ```tsx <Avatar circular size="$10"> <Avatar.Image aria-label="Cam" src="https://images.unsplash.com/photo-1548142813-c348350df52b?&w=150&h=150&dpr=2&q=80" /> <Avatar.Fallback backgroundColor="$blue10" /> </Avatar> ```

declare const Avatar: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "bordered" | "chromeless" | "circular" | "elevate" | "elevation" | "fullscreen" | "size" | "transparent" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    …

@hanzogui/avatar/types/Avatar.d.ts

declare const AvatarFallback: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}>, "__scopeAvatar" | "delayMs"> & AvatarFallbackExtraProps & {
    __scopeAvatar?: Scope;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & AvatarFallbackExtraProps & {
    __scopeAvatar?: Scope;
}, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/avatar/types/Avatar.d.ts

export declare const AvatarFallbackFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/avatar/types/Avatar.d.ts

type AvatarFallbackProps = GetProps<typeof AvatarFallbackFrame> & AvatarFallbackExtraProps;

@hanzogui/avatar/types/Avatar.d.ts

export declare const AvatarFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    memo: true;
}>;

@hanzogui/avatar/types/Avatar.d.ts

declare const AvatarImage: React.ForwardRefExoticComponent<Partial<ImageProps> & {
    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
} & React.RefAttributes<GuiElement>>;

@hanzogui/avatar/types/Avatar.d.ts

type AvatarImageProps = Partial<ImageProps> & {
    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
};

@hanzogui/avatar/types/Avatar.d.ts

type AvatarProps = GetProps<typeof AvatarFrame>;

@hanzogui/avatar/types/Avatar.d.ts

export interface Axis {
    min: number;
    max: number;
}

@hanzogui/animate-presence/types/types.d.ts

export interface Box {
    x: Axis;
    y: Axis;
}

@hanzogui/animate-presence/types/types.d.ts

export type BurntToastOptions = {
    title: string;
    message?: string;
    /**
     * Defaults to `done`.
     */
    preset?: 'done' | 'error' | 'none';
    /**
     * Duration in seconds.
     */
    duration?: number;
    haptic?: 'success' | 'warning' | 'error' | 'none';
    /**
     * Defaults to `true`.
     */
    shouldDismissByDrag?: boolean;
    /**
     * Change the presentation side.
     * @platform ios
     */
    from?: 'top' | 'bottom';
    layout?: BurntLayout;
};

@hanzogui/toast/types/types.d.ts

export declare const Button: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    disabled?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    size?: number | SizeTokens | undefined;
    unstyled?: boolean | undefined;
    variant?: "outlined" | undefined;
}>, "form" | "formAction" | "formEncType" | "formMethod" | "formNoValidate" | "formTarget" | "icon" | "iconAfter" | "iconSize" | "name" | "noTextWrap" | "scaleIcon" | "textProps" | "type" | "value" | keyof TextContextStyles> & TextContextStyles & {
    textProps?: Partial<import("@hanzogui/text").SizableTextProps>;
    noTextWrap?: boolean;
} & {
    icon?: IconProp;
    iconAfter?: IconProp;
    scaleIcon?: number;
    iconSize?: SizeTokens;
    type?: 'submit' | 'reset' | 'button';
    form?: string;
    formAction?: string;
    formEncType?: string;
    formMethod?: string;
    formNoValidate?: boolean;
    formTarget?: string;
    name?: string;
    value?: string | readonly string[] | number;
} & …

@hanzogui/button/types/Button.d.ts

export declare const ButtonContext: import("@hanzogui/web").StyledContext<{
    size?: SizeTokens;
    variant?: ButtonVariant;
    color?: ButtonContextStyles['color'];
}>;

@hanzogui/button/types/Button.d.ts

export declare const ButtonNestingContext: React.Context<boolean>;

@hanzogui/stacks/types/NestingContext.d.ts

export type ButtonProps = GetProps<typeof ButtonComponent>;

@hanzogui/button/types/Button.d.ts

export declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    disabled?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | "accessibilityLabelledBy" | "accessibilityLanguage" | …

@hanzogui/checkbox/types/index.d.ts

export declare const CheckboxContext: React.Context<{
    checked: CheckedState;
    disabled?: boolean;
}>;

@hanzogui/checkbox/types/createCheckbox.d.ts

export declare const CheckboxFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    disabled?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    accept: {
        readonly activeStyle: 'style';
    };
}>;

@hanzogui/checkbox/types/Checkbox.d.ts

export declare const CheckboxIndicatorFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    accept: {
        readonly activeStyle: 'style';
    };
}>;

@hanzogui/checkbox/types/Checkbox.d.ts

export type CheckboxIndicatorProps = CheckboxIndicatorBaseProps & CheckboxIndicatorExtraProps & CheckboxIndicatorActiveStyleProps;

@hanzogui/checkbox/types/createCheckbox.d.ts

export type CheckboxProps = CheckboxBaseProps & CheckboxExtraProps & CheckboxExpectingVariantProps & CheckboxFrameActiveStyleProps;

@hanzogui/checkbox/types/createCheckbox.d.ts

export declare const CheckboxStyledContext: import("@hanzogui/web").StyledContext<{
    size: SizeTokens;
    scaleIcon: number;
    unstyled?: boolean;
    active?: boolean;
    disabled?: boolean;
}>;

@hanzogui/checkbox/types/CheckboxStyledContext.d.ts

export type CheckedState = boolean | 'indeterminate';

@hanzogui/checkbox-headless/types/useCheckbox.d.ts

export declare const Circle: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    memo: true;
}>;

@hanzogui/shapes/types/Circle.d.ts

export type CircleProps = GetProps<typeof Circle>;

@hanzogui/shapes/types/Circle.d.ts

export declare function clamp(value: number, [min, max]: [number, number]): number;

@hanzogui/helpers/types/clamp.d.ts

export declare const closeLastOpenedPopover: () => boolean;

@hanzogui/popover/types/Popover.d.ts

export declare const closeOpenPopovers: () => boolean;

@hanzogui/popover/types/Popover.d.ts

export declare const closeOpenTooltips: () => void;

@hanzogui/tooltip/types/Tooltip.d.ts

declare const Collapsible: React.ForwardRefExoticComponent<CollapsibleProps & {
    __scopeCollapsible?: string;
} & React.RefAttributes<GuiElement>> & {
    Trigger: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, GuiElement, import("@hanzogui/web").StackNonStyleProps & void, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;
    Content: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, keyof CollapsibleContentExtraProps> & CollapsibleContentExtraProps, GuiElement, import("@hanzogui/web").StackNonStyleProps & CollapsibleContentExtraProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;
};

@hanzogui/collapsible/types/Collapsible.d.ts

declare const CollapsibleContent: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, keyof CollapsibleContentExtraProps> & CollapsibleContentExtraProps, GuiElement, import("@hanzogui/web").StackNonStyleProps & CollapsibleContentExtraProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/collapsible/types/Collapsible.d.ts

export interface CollapsibleContentExtraProps extends AnimatePresenceProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

@hanzogui/collapsible/types/Collapsible.d.ts

declare const CollapsibleContentFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/collapsible/types/Collapsible.d.ts

interface CollapsibleContentProps extends CollapsibleContentExtraProps, YStackProps {
}

@hanzogui/collapsible/types/Collapsible.d.ts

interface CollapsibleProps extends ViewProps {
    defaultOpen?: boolean;
    open?: boolean;
    disabled?: boolean;
    onOpenChange?(open: boolean): void;
}

@hanzogui/collapsible/types/Collapsible.d.ts

declare const CollapsibleTrigger: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, GuiElement, import("@hanzogui/web").StackNonStyleProps & void, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/collapsible/types/Collapsible.d.ts

declare const CollapsibleTriggerFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/collapsible/types/Collapsible.d.ts

type CollapsibleTriggerProps = GetProps<typeof View>;

@hanzogui/collapsible/types/Collapsible.d.ts

export type ColorProp = UnionableString | Variable | ColorTokens | TextStyle['color'] | undefined;

@hanzogui/component-helpers/types/useCurrentColor.d.ts

export declare function composeEventHandlers<E extends Events>(og?: EventHandler<E> | null, next?: EventHandler<E> | null, { checkDefaultPrevented }?: {
    checkDefaultPrevented?: boolean | undefined;
}): EventHandler<E> | undefined;

@hanzogui/helpers/types/composeEventHandlers.d.ts

A utility to compose multiple refs together Accepts callback refs and RefObject(s)

export declare function composeRefs<T>(...refs: PossibleRef<T>[]): (node: T) => void;

@hanzogui/compose-refs/types/compose-refs.d.ts

export declare function configureInitialWindowDimensions(next: WindowSize): void;

@hanzogui/use-window-dimensions/types/initialValue.d.ts

export declare const ContextMenu: import("react").FC<import("./createNonNativeContextMenu.tsx").ContextMenuProps & {
    scope?: string;
} & Partial<Omit<import("@hanzogui/create-menu").NativeMenuProps, keyof import("./createNonNativeContextMenu.tsx").ContextMenuProps>>> & {
    Trigger: import("react").FC<Omit<import("@hanzogui/web").ViewProps, "scope" | keyof import("./createNonNativeContextMenu.tsx").ContextMenuTriggerProps> & import("./createNonNativeContextMenu.tsx").ContextMenuTriggerProps & {
        scope?: string;
    } & import("react").RefAttributes<import("@hanzogui/web").GuiElement> & Partial<Omit<import("@hanzogui/create-menu").MenuTriggerProps, "scope" | keyof import("./createNonNativeContextMenu.tsx").ContextMenuTriggerProps | keyof import("react").RefAttributes<import("@hanzogui/web").GuiElement>>>>;
    Portal: import("react").FC<import("@hanzogui/create-menu").MenuPortalProps & {
        scope?: string;
    } & {
        scope?: string;
    } & Partial<Omit<import("react").FragmentProps, "scope" | keyof import("@hanzogui/create-menu").MenuPortalProps>>>;
    Content: import("react").FC<import("./createNonNativeContextMenu.tsx").ContextMenuContentProps & {
        …

@hanzogui/context-menu/types/index.d.ts

export type ContextMenuPreviewProps = {
    children: React.ReactNode | (() => React.ReactNode);
    /**
     * Size of the preview
     * @platform ios
     */
    size?: {
        width?: number;
        height?: number;
    };
    /**
     * Called when the preview is pressed
     * @platform ios
     */
    onPress?: () => void;
    /**
     * Background color of the preview
     * @platform ios
     */
    backgroundColor?: string;
    /**
     * Border radius of the preview
     * @platform ios
     */
    borderRadius?: number;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

declare const createAvatarScope: import("@hanzogui/create-context").CreateScope;

@hanzogui/avatar/types/Avatar.d.ts

export declare function createBaseMenu({ Item: _Item, Title: _Title, SubTitle: _SubTitle, Image: _Image, Icon: _Icon, Indicator: _Indicator, Separator: _Separator, MenuGroup: _MenuGroup, Label: _Label, }: CreateBaseMenuProps): {
    Menu: {
        (props: ScopedProps<MenuBaseProps>): React.JSX.Element;
        displayName: string;
    } & {
        Anchor: {
            (props: MenuAnchorProps): React.JSX.Element;
            displayName: string;
        };
        Portal: {
            (props: ScopedProps<MenuPortalProps>): React.JSX.Element;
            displayName: string;
        };
        Content: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
            elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
            fullscreen?: boolean | undefined;
            size?: import("@hanzogui/web").SizeTokens | undefined;
            unstyled?: boolean | undefined;
        }>, keyof MenuContentProps> & MenuContentProps & {
            scope?: string;
        }, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & MenuContentProps & …

@hanzogui/create-menu/types/createBaseMenu.d.ts

export type CreateBaseMenuProps = {
    Item?: typeof MenuPredefined.MenuItem;
    MenuGroup?: typeof MenuPredefined.MenuGroup;
    Title?: typeof MenuPredefined.Title;
    SubTitle?: typeof MenuPredefined.SubTitle;
    Image?: React.ElementType;
    Icon?: typeof MenuPredefined.MenuIcon;
    Indicator?: typeof MenuPredefined.MenuIndicator;
    Separator?: typeof MenuPredefined.MenuSeparator;
    Label?: typeof MenuPredefined.MenuLabel;
};

@hanzogui/create-menu/types/createBaseMenu.d.ts

export declare function createCheckbox<F extends CheckboxComponent, T extends CheckboxIndicatorComponent>(createProps: {
    Frame?: F;
    Indicator?: T;
}): React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    disabled?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | …

@hanzogui/checkbox/types/createCheckbox.d.ts

export declare function createContext<ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType): readonly [
    (props: ContextValueType & {
        children: React.ReactNode;
    }) => React.JSX.Element,
    (consumerName: string) => Exclude<ContextValueType | undefined, undefined>
];

@hanzogui/create-context/types/create-context.d.ts

export declare function createContextScope(scopeName: string, createContextScopeDeps?: CreateScope[]): readonly [
    <ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType) => readonly [
        (props: ContextValueType & {
            scope: Scope<ContextValueType>;
            children: React.ReactNode;
        }) => import('react/jsx-runtime').JSX.Element,
        (consumerName: string, scope: Scope<ContextValueType | undefined>, options?: {
            warn?: boolean;
            fallback?: Partial<ContextValueType>;
        }) => ContextValueType
    ],
    CreateScope
];

@hanzogui/create-context/types/create-context.d.ts

declare const createGroupScope: import("@hanzogui/create-context").CreateScope;

@hanzogui/group/types/Group.d.ts

Adds some helpful validation at dev time only for `hanzogui` specifically

export declare const createGui: typeof createGuiCore;

@hanzo/gui/types/createGui.d.ts

Create a custom Image component with a pluggable underlying implementation. @example Using with expo-image import { Image as ExpoImage } from 'expo-image' import { createImage } from '@hanzogui/image' export const Image = createImage({ Component: ExpoImage, resizeModePropName: 'contentFit', objectPositionPropName: 'contentPosition', }) Now you get all expo-image props (transition, placeholder, etc.) plus Gui's unified API (src, objectFit, objectPosition) <Image src="https://example.com/photo.jpg" objectFit="cover" transition={300} placeholder={blurhash} />

export declare function createImage<C extends ComponentType<any>>(options: CreateImageOptions<C>): import("react").FC<Partial<ImageProps>> & {
    getSize: typeof import("react-native").Image.getSize;
    getSizeWithHeaders: typeof import("react-native").Image.getSizeWithHeaders;
    prefetch: typeof import("react-native").Image.prefetch;
    prefetchWithMetadata: typeof import("react-native").Image.prefetchWithMetadata;
    abortPrefetch: typeof import("react-native").Image.abortPrefetch | undefined;
    queryCache: typeof import("react-native").Image.queryCache | undefined;
} & import("react").FC<import("@hanzogui/web").StackNonStyleProps & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>> & …

@hanzogui/image/types/createImage.d.ts

export type CreateImageOptions<C extends ComponentType<any>> = {
    /**
     * The underlying image component to use.
     * Can be React Native Image, expo-image, react-native-fast-image, or any compatible component.
     */
    Component: C;
    /**
     * Map objectFit CSS values to the component's resize mode prop.
     * Default maps to React Native's resizeMode.
     */
    mapObjectFitToResizeMode?: (objectFit: string) => string;
    /**
     * The prop name used for resize mode.
     * Default: 'resizeMode' (React Native)
     * expo-image uses: 'contentFit'
     */
    resizeModePropName?: string;
    /**
     * The prop name used for object position.
     * Default: undefined (React Native doesn't support it)
     * expo-image uses: 'contentPosition'
     */
    objectPositionPropName?: string;
    /**
     * Custom source transformation.
     * Useful for expo-image which has a different source format.
     */
    transformSource?: (props: {
        src?: string | number;
        source?: any;
        width?: any;
        height?: any;
    }) => any;
};

@hanzogui/image/types/createImage.d.ts

@deprecated you no longer need to call createMedia or import @hanzogui/react-native-media-driver at all. Gui now automatically handles setting this up, you can just pass a plain object to createGui.

export declare function createMedia<A extends {
    [key: string]: MediaQueryObject;
}>(media: A): A;

@hanzogui/react-native-media-driver/types/createMedia.d.ts

export declare const createNativeMenu: (MenuType: 'ContextMenu' | 'Menu') => NativeMenuComponents;

@hanzogui/create-menu/types/createNativeMenu/createNativeMenu.d.ts

export interface CreateNativeToastOptions {
    /**
     * Body of the toast
     */
    message?: BurntToastOptions['message'];
    /**
     * Duration of toast in ms
     *
     * @example 1000
     */
    duration?: BurntToastOptions['duration'];
    /**
     * Options for the burnt package if you're using native toasts on mobile
     */
    burntOptions?: Omit<BurntToastOptions, 'title' | 'message' | 'duration'>;
    /**
     * Options for the notification API if you're using native toasts on web
     */
    notificationOptions?: NotificationOptions;
}

@hanzogui/toast/types/types.d.ts

declare const createProgressScope: import("@hanzogui/create-context").CreateScope;

@hanzogui/progress/types/Progress.d.ts

export declare function createRadioGroup<F extends RadioGroupComponent, D extends RadioGroupIndicatorComponent, I extends RadioGroupItemComponent>(createProps: {
    disableActiveTheme?: boolean;
    Frame?: F;
    Indicator?: D;
    Item?: I;
}): React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
}>, "accentColor" | "defaultValue" | "elevation" | "fullscreen" | "name" | "native" | "onValueChange" | "orientation" | "required" | "value" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/core").RNGuiViewNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
} & …

@hanzogui/radio-group/types/createRadioGroup.d.ts

export interface CreateScope {
    scopeName: string;
    (): ScopeHook;
}

@hanzogui/create-context/types/create-context.d.ts

export declare function createSheet<H extends GuiComponent | SheetStyledComponent, F extends GuiComponent | SheetStyledComponent, O extends GuiComponent | SheetStyledComponent>({ Handle, Frame, Overlay }: {
    Handle: H;
    Frame: F;
    Overlay: O;
}): ForwardRefExoticComponent<{
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: import("react").Dispatch<import("react").SetStateAction<boolean>> | ((open: boolean) => void);
    position?: number;
    defaultPosition?: number;
    snapPoints?: (string | number)[];
    snapPointsMode?: import("./types.tsx").SnapPointsMode;
    onPositionChange?: import("./types.tsx").PositionChangeHandler;
    children?: import("react").ReactNode;
    dismissOnOverlayPress?: boolean;
    dismissOnSnapToBottom?: boolean;
    disableRemoveScroll?: boolean;
    forceRemoveScrollEnabled?: boolean;
    transitionConfig?: import("@hanzogui/web").AnimatedNumberStrategy;
    preferAdaptParentOpenState?: boolean;
    unmountChildrenWhenHidden?: boolean;
    disableTransparencyHide?: boolean;
    native?: 'ios'[] | boolean;
    transition?: import("@hanzogui/web").TransitionProp;
    handleDisableScroll?: boolean;
    disableDrag?: boolean;
   …

@hanzogui/sheet/types/createSheet.d.ts

export declare const createSheetContext: <ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType) => readonly [(props: ContextValueType & {
    scope: import("@hanzogui/create-context").Scope<ContextValueType>;
    children: React.ReactNode;
}) => import("react").JSX.Element, (consumerName: string, scope: import("@hanzogui/create-context").Scope<ContextValueType | undefined>, options?: {
    warn?: boolean;
    fallback?: Partial<ContextValueType>;
}) => ContextValueType], createSheetScope: import("@hanzogui/create-context").CreateScope;

@hanzogui/sheet/types/SheetContext.d.ts

export declare function createSwitch<F extends SwitchComponent, T extends SwitchThumbComponent>(createProps: {
    Frame?: F;
    Thumb?: T;
}): React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | …

@hanzogui/switch/types/createSwitch.d.ts

export declare function createTabs<C extends TabsComponent, T extends TabComponent, F extends ContentComponent>(createProps: {
    ContentFrame: F;
    TabFrame: T;
    TabsFrame: C;
}): React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, keyof TabsExtraProps<string>> & TabsExtraProps<string> & React.RefAttributes<GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: …

@hanzogui/tabs/types/createTabs.d.ts

export declare const cssShorthandLonghands: {
    borderWidth: boolean;
    borderStyle: boolean;
    borderColor: boolean;
    borderTopWidth: boolean;
    borderTopStyle: boolean;
    borderTopColor: boolean;
    borderRightWidth: boolean;
    borderRightStyle: boolean;
    borderRightColor: boolean;
    borderBottomWidth: boolean;
    borderBottomStyle: boolean;
    borderBottomColor: boolean;
    borderLeftWidth: boolean;
    borderLeftStyle: boolean;
    borderLeftColor: boolean;
    outlineWidth: boolean;
    outlineStyle: boolean;
    outlineColor: boolean;
    outlineOffset: boolean;
};

@hanzogui/helpers/types/validStyleProps.d.ts

export type { CustomData, ToastActionProps, ToastCloseProps, ToastDescriptionProps, NativePlatform as ToastNativePlatform, NativeValue as ToastNativeValue, ToastProps, ToastProviderProps, ToastTitleProps, ToastViewportProps, };

@hanzogui/toast/types/Toast.d.ts

export declare function debounce<A extends Function>(func: A, wait?: number, leading?: boolean): A & {
    cancel: () => void;
};

@hanzogui/use-debounce/types/index.d.ts

declare const Dialog: React.ForwardRefExoticComponent<{
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    /**
     * When true, children never un-mount, otherwise they mount on open.
     *
     * @default false
     */
    keepChildrenMounted?: boolean;
    onOpenChange?(open: boolean): void;
    modal?: boolean;
    /**
     * Used to disable the remove scroll functionality when open
     */
    disableRemoveScroll?: boolean;
    /**
     * Called when the dialog open/close animation completes.
     */
    onAnimationComplete?: (info: {
        open: boolean;
    }) => void;
} & {
    scope?: DialogScopes;
} & React.RefAttributes<{
    open: (val: boolean) => void;
}>> & {
    Trigger: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "scope"> & {
        scope?: DialogScopes;
    }, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & {
        scope?: DialogScopes;
    }, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;
    Portal: …

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogClose: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "displayWhenAdapted" | "scope"> & {
    displayWhenAdapted?: boolean;
} & {
    scope?: DialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & {
    displayWhenAdapted?: boolean;
} & {
    scope?: DialogScopes;
}, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

export type DialogCloseExtraProps = ScopedProps<{
    displayWhenAdapted?: boolean;
}>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogCloseProps = GetProps<typeof DialogCloseFrame> & DialogCloseExtraProps;

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogContent: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | "accessibilityLabelledBy" | "accessibilityLanguage" | "accessibilityLargeContentTitle" | "accessibilityLiveRegion" | "accessibilityRespondsToUserInteraction" | "accessibilityRole" | "accessibilityShowsLargeContentViewer" | "accessibilityState" | "accessibilityValue" | "accessibilityViewIsModal" | "accessible" | "animatedBy" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-hidden" | "aria-label" | "aria-labelledby" | "aria-live" | …

@hanzogui/dialog/types/Dialog.d.ts

type DialogContentProps = DialogContentFrameProps & DialogContentExtraProps;

@hanzogui/dialog/types/Dialog.d.ts

export declare const DialogContext: import("@hanzogui/web").StyledContext<DialogContextValue>;

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogDescription: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "scope"> & {
    scope?: DialogScopes;
}, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps & {
    scope?: DialogScopes;
}, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogDescriptionProps = DialogDescriptionExtraProps & GetProps<typeof DialogDescriptionFrame>;

@hanzogui/dialog/types/Dialog.d.ts

export type DialogHandle = {
    open: (val: boolean) => void;
};

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogOverlay: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    open?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, "forceMount" | "scope"> & {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
} & {
    scope?: DialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
} & {
    scope?: DialogScopes;
}, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    open?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

export type DialogOverlayExtraProps = ScopedProps<{
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}>;

@hanzogui/dialog/types/Dialog.d.ts

exported for internal use with extractable()

export declare const DialogOverlayFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    open?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogOverlayProps = YStackProps & DialogOverlayExtraProps;

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogPortal: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}>, keyof import("@hanzogui/stacks").StackVariants> & import("@hanzogui/stacks").StackVariants & {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
} & {
    scope?: DialogScopes;
} & React.RefAttributes<GuiElement>>;

@hanzogui/dialog/types/Dialog.d.ts

export declare const DialogPortalFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogPortalProps = ScopedProps<YStackProps & {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogProps = ScopedProps<{
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    /**
     * When true, children never un-mount, otherwise they mount on open.
     *
     * @default false
     */
    keepChildrenMounted?: boolean;
    onOpenChange?(open: boolean): void;
    modal?: boolean;
    /**
     * Used to disable the remove scroll functionality when open
     */
    disableRemoveScroll?: boolean;
    /**
     * Called when the dialog open/close animation completes.
     */
    onAnimationComplete?: (info: {
        open: boolean;
    }) => void;
}>;

@hanzogui/dialog/types/Dialog.d.ts

export declare const useDialogContext: (scope?: string) => DialogContextValue, DialogProvider: React.Provider<DialogContextValue> & React.ProviderExoticComponent<Partial<DialogContextValue> & {
    children?: React.ReactNode;
    scope?: string;
}>;

@hanzogui/dialog/types/Dialog.d.ts

export type DialogScopes = string;

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogTitle: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "scope"> & {
    scope?: DialogScopes;
}, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps & {
    scope?: DialogScopes;
}, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogTitleProps = DialogTitleExtraProps & GetProps<typeof DialogTitleFrame>;

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogTrigger: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, "scope"> & {
    scope?: DialogScopes;
}, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & {
    scope?: DialogScopes;
}, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/dialog/types/Dialog.d.ts

type DialogTriggerProps = ScopedProps<ViewProps>;

@hanzogui/dialog/types/Dialog.d.ts

declare const DialogWarningProvider: (props: {
    contentName: string;
    titleName: string;
    docsSlug: string;
} & {
    children: React.ReactNode;
}) => React.JSX.Element;

@hanzogui/dialog/types/Dialog.d.ts

export declare const Em: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Emphasis.d.ts

export type EmitterSubscriber<Val> = (cb: (val: Val) => void) => DisposeFn;

@hanzogui/select/types/types.d.ts

export declare const EnsureFlexed: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/core").RNGuiTextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzo/gui/types/views/EnsureFlexed.d.ts

export type EventHandler<E extends Events> = (event: E) => void;

@hanzogui/helpers/types/composeEventHandlers.d.ts

export type ExplicitNativePlatform = Exclude<NativePlatform, 'mobile'>;

@hanzogui/helpers/types/shouldRenderNativePlatform.d.ts

export declare const Fieldset: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    horizontal?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzo/gui/types/views/Fieldset.d.ts

export type FieldsetProps = GetProps<typeof Fieldset>;

@hanzo/gui/types/views/Fieldset.d.ts

export declare const Footer: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

export declare const Form: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, keyof FormExtraProps> & FormExtraProps & import("react").RefAttributes<import("@hanzogui/web").GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, keyof FormExtraProps> & FormExtraProps, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & FormExtraProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic> & Omit<import("@hanzogui/web").StaticConfigPublic, "staticConfig" | "styleable"> & {
    __tama: [Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, keyof FormExtraProps> & FormExtraProps, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & FormExtraProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic];
} & …

@hanzogui/form/types/Form.d.ts

export declare const FormContext: import("@hanzogui/web").StyledContext<FormContextValue>;

@hanzogui/form/types/Form.d.ts

export declare const FormFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/form/types/Form.d.ts

export type FormProps = ViewProps & FormExtraProps;

@hanzogui/form/types/Form.d.ts

export declare const useFormContext: (scope?: string) => FormContextValue, FormProvider: import("react").Provider<FormContextValue> & import("react").ProviderExoticComponent<Partial<FormContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>;

@hanzogui/form/types/Form.d.ts

export declare const FormTrigger: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}>, keyof FormTriggerProps> & FormTriggerProps, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & FormTriggerProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/form/types/Form.d.ts

export interface FormTriggerProps extends ViewProps {
    scope?: string;
}

@hanzogui/form/types/Form.d.ts

export declare const ForwardSelectContext: ({ context, itemContext, children, }: {
    children?: any;
    context: SelectContextValue;
    itemContext: SelectItemParentContextValue;
}) => any;

@hanzogui/select/types/context.d.ts

export declare const Frame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/sheet/types/Sheet.d.ts

export declare const fullscreenStyle: {
    readonly position: 'absolute';
    readonly inset: 0;
};

@hanzogui/stacks/types/Stacks.d.ts

export declare const getElevation: SizeVariantSpreadFunction<ViewProps>;

@hanzogui/stacks/types/getElevation.d.ts

export declare const getFontSize: (inSize: FontSizeTokens | null | undefined, opts?: GetFontSizeOpts) => number;

@hanzogui/font-size/types/getFontSize.d.ts

export declare const getFontSizeToken: (inSize: FontSizeTokens | null | undefined, opts?: GetFontSizeOpts) => FontSizeTokens | null;

@hanzogui/font-size/types/getFontSize.d.ts

export declare const getFontSizeVariable: (inSize: FontSizeTokens | null | undefined, opts?: GetFontSizeOpts) => FontSizeTokens | Variable<string> | null | undefined;

@hanzogui/font-size/types/getFontSize.d.ts

export declare const getIcon: (el: any, props: {
    size?: number;
    color?: string;
    style?: Record<string, any>;
}) => any;

@hanzogui/component-helpers/types/getIcon.d.ts

export declare function getNativeSheet(platform: SheetNativePlatforms): FunctionComponent<SheetProps> | null;

@hanzogui/sheet/types/nativeSheet.d.ts

export declare const getShapeSize: SizeVariantSpreadFunction<SizableStackProps>;

@hanzogui/shapes/types/getShapeSize.d.ts

export declare const getSizedElevation: (val: SizeTokens | number | boolean, { theme, tokens }: VariantSpreadExtras<any>) => {
    shadowColor: import("@hanzogui/web").Variable<any> | import("@hanzogui/web").Variable<undefined> | import("@hanzogui/web").Variable<string> | undefined;
    shadowRadius: number;
    shadowOffset: {
        height: number;
        width: number;
    };
    elevationAndroid?: number | undefined;
} | undefined;

@hanzogui/stacks/types/getElevation.d.ts

Narrows a GuiElement to an HTMLElement, with optional generic for further casting. Throws if the element is not an instanceof HTMLElement. @example ```tsx const el = getWebElement(ref.current) // HTMLElement const input = getWebElement<HTMLInputElement>(ref.current) // HTMLInputElement ```

export declare function getWebElement<T extends HTMLElement = HTMLElement>(element: GuiElement | null | undefined): T;

@hanzogui/element/types/getWebElement.d.ts

export declare const gridProps: {
    gridAutoColumns: boolean;
    gridAutoRows: boolean;
    gridTemplateColumns: boolean;
    gridTemplateRows: boolean;
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
};

@hanzogui/helpers/types/webOnlyStyleProps.d.ts

export declare const gridUnitless: {
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
};

@hanzogui/helpers/types/webOnlyStyleProps.d.ts

export declare const Group: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}>, "__scopeGroup" | keyof GroupExtraProps> & GroupExtraProps & {
    __scopeGroup?: Scope;
} & React.RefAttributes<import("@hanzogui/web").GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}>, "__scopeGroup" | keyof GroupExtraProps> & GroupExtraProps & {
    __scopeGroup?: Scope;
}, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & GroupExtraProps & {
    __scopeGroup?: Scope;
}, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
 …

@hanzogui/group/types/Group.d.ts

export type GroupExtraProps = {
    orientation?: 'horizontal' | 'vertical';
    disabled?: boolean;
};

@hanzogui/group/types/Group.d.ts

export declare const GroupFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/group/types/Group.d.ts

export type GroupItemProps = {
    children: React.ReactNode;
    /**
     * forces the item to be a starting, center or ending item and gets the respective styles
     */
    forcePlacement?: 'first' | 'center' | 'last';
};

@hanzogui/group/types/Group.d.ts

export type GroupProps = GetProps<typeof GroupFrame> & GroupExtraProps;

@hanzogui/group/types/Group.d.ts

export type GuiElement = (HTMLElement & GuiElementMethods) | View;

@hanzogui/element/types/types.d.ts

Methods added to element refs that work across web and native. On web these are added at runtime to HTMLElements. On native these exist on View already.

export interface GuiElementMethods {
    measure(callback: MeasureOnSuccessCallback): void;
    measureInWindow(callback: MeasureInWindowOnSuccessCallback): void;
    measureLayout(relativeToNativeNode: View | HTMLElement, onSuccess: MeasureLayoutOnSuccessCallback, onFail?: () => void): void;
    focus(): void;
    blur(): void;
}

@hanzogui/element/types/types.d.ts

Native-specific element type (View). Use this when you need a View ref in native-only code.

export type GuiNativeElement = View;

@hanzogui/element/types/types.d.ts

export declare const GuiProvider: ({ children, telemetry, ...props }: GuiProviderProps) => import("react").JSX.Element;

@hanzo/gui/types/views/GuiProvider.d.ts

An intersection, not `interface … extends`: the core props are a mapped `Omit<…> &` type, and extending that loses members (`children` among them).

export type GuiProviderProps = CoreGuiProviderProps & {
    /** See {@link GuiTelemetry}. Defaults to on. */
    telemetry?: GuiTelemetry;
};

@hanzo/gui/types/views/GuiProvider.d.ts

Telemetry posture for a gui app. Omit it and you get telemetry: pageviews, unhandled errors, React render errors and interaction capture, POSTed to the one Hanzo endpoint (`api.hanzo.ai/v1/event`), with the product name inferred from the runtime and the publishable ingest key read from the environment. Nothing to wire, on web, on desktop and on native alike. Pass an object to shape it (`product`, `ingestKey`, `host`, `consent`, `replay`, …), or `false` to mount nothing at all.

export type GuiTelemetry = boolean | TelemetryConfig;

@hanzo/gui/types/views/GuiProvider.d.ts

Web-specific element type that extends HTMLElement with Gui methods. Use this when you need an HTMLElement ref in web-only code.

export type GuiWebElement<T extends HTMLElement = HTMLElement> = T & GuiElementMethods;

@hanzogui/element/types/types.d.ts

export declare const H1: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export declare const H2: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export declare const H3: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export declare const H4: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export declare const H5: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export declare const H6: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export declare const Handle: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    open?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/sheet/types/Sheet.d.ts

export declare const hasOpenPopovers: () => boolean;

@hanzogui/popover/types/Popover.d.ts

export declare const Header: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

export declare const Heading: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Headings.d.ts

export type HeadingProps = GetProps<typeof Heading>;

@hanzogui/text/types/Headings.d.ts

export declare const Image: ImageType;

@hanzogui/image/types/Image.d.ts

export type ImageProps = ViewProps & Omit<RNImageProps, KeyofViewProps | 'source' | 'resizeMode' | 'style'> & {
    /**
     * The image source URL or require() result.
     * Preferred over `source` for better web alignment.
     */
    src?: string | number;
    /**
     * @deprecated
     * use src instead
     */
    source?: ImageSourcePropType;
    /**
     * @deprecated
     * use objectFit instead
     */
    resizeMode?: ImageResizeMode;
    /**
     * How the image should be resized to fit its container.
     * Maps to CSS object-fit on web and resizeMode on native.
     */
    objectFit?: React.CSSProperties['objectFit'];
    /**
     * How the image should be positioned within its container.
     * Maps to CSS object-position on web.
     * On native, requires expo-image or similar for full support.
     */
    objectPosition?: React.CSSProperties['objectPosition'];
} & Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'width' | 'height' | KeyofViewProps | 'src'> & Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'width' | 'height' | 'style' | 'src'>;

@hanzogui/image/types/types.d.ts

export type ImageType = React.FC<Partial<ImageProps>> & {
    getSize: RNImageType['getSize'];
    getSizeWithHeaders: RNImageType['getSizeWithHeaders'];
    prefetch: RNImageType['prefetch'];
    prefetchWithMetadata: RNImageType['prefetchWithMetadata'];
    abortPrefetch: RNImageType['abortPrefetch'];
    queryCache: RNImageType['queryCache'];
};

@hanzogui/image/types/types.d.ts

declare const INITIAL_STATE: {};

@hanzogui/portal/types/GorhomPortal.d.ts

A web-aligned input component. @see — Docs https://hanzogui.dev/ui/inputs#input

export declare const Input: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & import("@hanzogui/web").TextStylePropsBase & {
    readonly placeholderTextColor?: import("@hanzogui/web").ColorTokens | undefined;
    readonly selectionColor?: import("@hanzogui/web").ColorTokens | undefined;
    readonly cursorColor?: import("@hanzogui/web").ColorTokens | undefined;
    readonly selectionHandleColor?: import("@hanzogui/web").ColorTokens | undefined;
    readonly underlineColorAndroid?: import("@hanzogui/web").ColorTokens | undefined;
}, {
    disabled?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "about" | "accept" | "accessKey" | "allowFontScaling" | "alt" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-braillelabel" | "aria-brailleroledescription" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colindextext" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-description" | "aria-details" | "aria-disabled" | …

@hanzogui/input/types/Input.d.ts

Android-specific props for Input/TextArea These have no web equivalent and are ignored on web.

export interface InputAndroidProps {
    /**
     * The color of the cursor (caret) in the component.
     * Unlike `selectionColor`, this only affects the cursor, not the selection highlight.
     * @platform android
     */
    cursorColor?: ColorTokens | (string & {});
    /**
     * The color of the selection handles when highlighting text.
     * Unlike `selectionColor`, this only affects the handles, not the selection highlight.
     * @platform android
     */
    selectionHandleColor?: ColorTokens | (string & {});
    /**
     * The color of the TextInput underline.
     * Set to "transparent" to remove it.
     * @platform android
     */
    underlineColorAndroid?: ColorTokens | (string & {});
    /**
     * Determines whether the field should be included in autofill.
     * @default 'auto'
     * @platform android
     */
    importantForAutofill?: 'auto' | 'no' | 'noExcludeDescendants' | 'yes' | 'yesExcludeDescendants';
    /**
     * When false, if there is a small amount of space available around a text input
     * (e.g. landscape orientation on a phone), the OS may choose to have the user
     * edit the text inside of a full screen text input mode.
     * When …

@hanzogui/input/types/InputNativeProps.d.ts

export type InputDataDetectorTypes = 'phoneNumber' | 'link' | 'address' | 'calendarEvent' | 'trackingNumber' | 'flightNumber' | 'lookupSuggestion' | 'none' | 'all';

@hanzogui/input/types/InputNativeProps.d.ts

export type InputExtraProps = Omit<HTMLInputProps, 'size' | 'color' | 'style' | 'children' | 'className' | keyof InputTextStyleProps | OverlappingNativeProps> & InputTextStyleProps & Omit<InputNativeProps, OverlappingNativeProps> & {
    /**
     * Controls automatic spelling correction.
     *
     * Cross-platform values:
     * - `true` or `'on'` - Enable auto-correction
     * - `false` or `'off'` - Disable auto-correction
     *
     * @example
     * ```tsx
     * <Input autoCorrect={false} />
     * <Input autoCorrect="off" />
     * ```
     */
    autoCorrect?: boolean | 'on' | 'off';
    /**
     * Controls automatic text capitalization.
     *
     * Native values (work on all platforms):
     * - `'none'` - No automatic capitalization
     * - `'sentences'` - Capitalize first letter of sentences
     * - `'words'` - Capitalize first letter of each word
     * - `'characters'` - Capitalize all characters
     *
     * Web compatibility values (mapped on native):
     * - `'off'` - Maps to `'none'` on native
     * - `'on'` - Maps to `'sentences'` on native
     *
     * @example
     * ```tsx
     * <Input autoCapitalize="none" />
     * <Input autoCapitalize="words" />
 …

@hanzogui/input/types/types.d.ts

iOS-specific props for Input/TextArea These have no web equivalent and are ignored on web.

export interface InputIOSProps {
    /**
     * Determines the color of the keyboard.
     * @platform ios
     */
    keyboardAppearance?: 'default' | 'light' | 'dark';
    /**
     * When the clear button should appear on the right side of the text view.
     * @platform ios
     */
    clearButtonMode?: 'never' | 'while-editing' | 'unless-editing' | 'always';
    /**
     * If true, clears the text field automatically when editing begins.
     * @platform ios
     */
    clearTextOnFocus?: boolean;
    /**
     * If true, the keyboard disables the return key when there is no text.
     * Automatically enables it when there is text.
     * @default false
     * @platform ios
     */
    enablesReturnKeyAutomatically?: boolean;
    /**
     * Determines the types of data converted to clickable URLs in the text input.
     * Only valid if `multiline={true}` and `editable={false}`.
     * @platform ios
     */
    dataDetectorTypes?: InputDataDetectorTypes | InputDataDetectorTypes[];
    /**
     * If false, scrolling of the text view will be disabled.
     * Only works with `multiline={true}`.
     * @default true
     * @platform ios
     */
    scrollEnabled?: boolean;
    /**
   …

@hanzogui/input/types/InputNativeProps.d.ts

export type InputKeyboardType = 'default' | 'number-pad' | 'decimal-pad' | 'numeric' | 'email-address' | 'phone-pad' | 'url' | 'ascii-capable' | 'numbers-and-punctuation' | 'name-phone-pad' | 'twitter' | 'web-search' | 'visible-password';

@hanzogui/input/types/InputNativeProps.d.ts

Cross-platform native-only props for Input/TextArea These work on both iOS and Android but have no web equivalent.

export interface InputNativeProps extends InputIOSProps, InputAndroidProps {
    /**
     * Determines how the return key should look.
     *
     * Cross-platform values: 'done' | 'go' | 'next' | 'search' | 'send'
     * iOS only: 'default' | 'google' | 'join' | 'route' | 'yahoo' | 'emergency-call'
     * Android only: 'none' | 'previous'
     *
     * Note: `enterKeyHint` is the web-standard prop and takes precedence.
     * Use `returnKeyType` for RN-specific values not available in `enterKeyHint`.
     * @platform native
     */
    returnKeyType?: InputReturnKeyType;
    /**
     * Determines what happens when the return key is pressed.
     *
     * - `'submit'` - sends submit event only, does not blur
     * - `'blurAndSubmit'` - blurs the input and sends submit event (single-line default)
     * - `'newline'` - inserts a newline (multiline default)
     *
     * Replaces the deprecated `blurOnSubmit` prop.
     * @platform native
     */
    submitBehavior?: 'submit' | 'blurAndSubmit' | 'newline';
    /**
     * If true, the text field will blur when submitted.
     * For single-line fields, default is true. For multiline, default is false.
     *
     * @deprecated Use …

@hanzogui/input/types/InputNativeProps.d.ts

export type InputProps = GetProps<typeof Input>;

@hanzogui/input/types/Input.d.ts

Cross-platform ref type for Input. On web: HTMLInputElement with Gui methods (measure, focus, blur). On native: TextInput.

export type InputRef = (HTMLInputElement & GuiElementMethods) | TextInput;

@hanzogui/input/types/types.d.ts

export type InputReturnKeyType = 'done' | 'go' | 'next' | 'search' | 'send' | 'default' | 'google' | 'join' | 'route' | 'yahoo' | 'emergency-call' | 'none' | 'previous';

@hanzogui/input/types/InputNativeProps.d.ts

export declare const inputSizeVariant: SizeVariantSpreadFunction<any>;

@hanzogui/input/types/shared.d.ts

iOS text content types for autofill

export type InputTextContentType = 'none' | 'URL' | 'addressCity' | 'addressCityAndState' | 'addressState' | 'countryName' | 'creditCardNumber' | 'creditCardExpiration' | 'creditCardExpirationMonth' | 'creditCardExpirationYear' | 'creditCardSecurityCode' | 'creditCardType' | 'creditCardName' | 'creditCardGivenName' | 'creditCardMiddleName' | 'creditCardFamilyName' | 'emailAddress' | 'familyName' | 'fullStreetAddress' | 'givenName' | 'jobTitle' | 'location' | 'middleName' | 'name' | 'namePrefix' | 'nameSuffix' | 'nickname' | 'organizationName' | 'postalCode' | 'streetAddressLine1' | 'streetAddressLine2' | 'sublocality' | 'telephoneNumber' | 'username' | 'password' | 'newPassword' | 'oneTimeCode' | 'birthdate' | 'birthdateDay' | 'birthdateMonth' | 'birthdateYear' | 'cellularEID' | 'cellularIMEI' | 'dateTime' | 'flightNumber' | 'shipmentTrackingNumber';

@hanzogui/input/types/types.d.ts

export declare function isPresent(context: PresenceContextProps | null): boolean;

@hanzogui/use-presence/types/usePresence.d.ts

export declare const isServerSide: boolean;

@hanzogui/use-force-update/types/index.d.ts

Check if teleport is enabled (best portal option - preserves React context)

export declare const isTeleportEnabled: () => boolean;

@hanzogui/portal/types/constants.d.ts

export declare function isUnspaced(child: React.ReactNode): any;

@hanzogui/spacer/types/Unspaced.d.ts

export interface KeyboardControllerSheetOptions {
    /**
     * Whether keyboard handling is enabled.
     * When false, the hook is a no-op.
     */
    enabled: boolean;
}

@hanzogui/sheet/types/types.d.ts

export interface KeyboardControllerSheetResult {
    /**
     * Whether keyboard-controller is available and enabled.
     */
    keyboardControllerEnabled: boolean;
    /**
     * Current keyboard height (0 when hidden).
     * On web or when keyboard-controller is not available, always 0.
     */
    keyboardHeight: number;
    /**
     * Whether the keyboard is currently visible.
     */
    isKeyboardVisible: boolean;
    /**
     * Dismiss the keyboard programmatically.
     * Called when sheet closes to dismiss the keyboard.
     */
    dismissKeyboard: () => void;
    /**
     * Ref to pause keyboard hide state updates (action-sheet pattern).
     * When true, keyboard hide events are ignored — keeps isKeyboardVisible=true
     * and keyboardHeight at their last values during drag.
     */
    pauseKeyboardHandler: React.RefObject<boolean>;
    /**
     * Flush any keyboard hide event that was suppressed while paused.
     * Call after drag ends to reconcile actual keyboard state.
     */
    flushPendingHide: () => void;
}

@hanzogui/sheet/types/types.d.ts

export declare const Label: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: FontSizeTokens | import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps & void, import("@hanzogui/web").TextStylePropsBase, {
    size?: FontSizeTokens | import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/label/types/Label.d.ts

export declare const LabelFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: FontSizeTokens | import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/label/types/Label.d.ts

export type LabelProps = GetProps<typeof LabelFrame> & {
    htmlFor?: string;
};

@hanzogui/label/types/Label.d.ts

export declare const ListItem: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    active?: boolean | undefined;
    disabled?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
    variant?: "outlined" | undefined;
}>, keyof ListItemExtraProps> & ListItemExtraProps & import("react").RefAttributes<import("@hanzogui/web").GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    active?: boolean | undefined;
    disabled?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
    variant?: "outlined" | undefined;
}>, keyof ListItemExtraProps> & ListItemExtraProps, import("@hanzogui/web").GuiElement, import("@hanzogui/web").StackNonStyleProps & ListItemExtraProps, import("@hanzogui/web").StackStyleBase, {
    active?: boolean | undefined;
    disabled?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
    …

@hanzogui/list-item/types/ListItem.d.ts

export type ListItemExtraProps = {
    icon?: IconProp;
    iconAfter?: IconProp;
    scaleIcon?: number;
    title?: ReactNode;
    subTitle?: ReactNode;
    iconSize?: SizeTokens;
};

@hanzogui/list-item/types/ListItem.d.ts

export type ListItemProps = GetProps<typeof ListItemFrame> & ListItemExtraProps;

@hanzogui/list-item/types/ListItem.d.ts

export declare const Main: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

export declare const matchMedia: MatchMedia;

@hanzogui/react-native-media-driver/types/matchMedia.d.ts

export type MediaStyleObject = Omit<StyleObject, 'value'>;

@hanzogui/helpers/types/types.d.ts

export declare const Menu: import("react").FC<import("./createNonNativeMenu.tsx").MenuProps & {
    scope?: string;
} & Partial<Omit<import("@hanzogui/create-menu").NativeMenuProps, keyof import("./createNonNativeMenu.tsx").MenuProps>>> & {
    readonly Trigger: import("react").FC<Omit<import("@hanzogui/web").ViewProps, "scope" | keyof import("./createNonNativeMenu.tsx").MenuTriggerProps> & import("./createNonNativeMenu.tsx").MenuTriggerProps & {
        scope?: string;
    } & import("react").RefAttributes<import("@hanzogui/web").GuiElement> & Partial<Omit<import("@hanzogui/create-menu").MenuTriggerProps, "scope" | keyof import("./createNonNativeMenu.tsx").MenuTriggerProps | keyof import("react").RefAttributes<import("@hanzogui/web").GuiElement>>>>;
    readonly Portal: import("react").FC<import("@hanzogui/create-menu").MenuPortalProps & {
        scope?: string;
    } & Partial<Omit<import("react").FragmentProps, "scope" | keyof import("@hanzogui/create-menu").MenuPortalProps>>>;
    readonly Content: import("react").FC<import("./createNonNativeMenu.tsx").MenuContentProps & {
        scope?: string;
    } & import("react").RefAttributes<import("@hanzogui/web").GuiElement> & …

@hanzogui/menu/types/index.d.ts

interface MenuAnchorProps extends PopperAnchorProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuArrowProps extends PopperArrowProps {
    unstyled?: boolean;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuCheckboxItemProps extends MenuItemProps {
    checked?: CheckedState;
    onCheckedChange?: (checked: boolean) => void;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

We purposefully don't union MenuRootContent and MenuSubContent props here because they have conflicting prop types. We agreed that we would allow MenuSubContent to accept props that it would just ignore.

interface MenuContentProps extends MenuRootContentTypeProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuGroupProps extends ViewProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

type MenuItemIconProps = ViewProps;

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuItemIndicatorProps extends PrimitiveSpanProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuItemProps extends Omit<MenuItemImplProps, 'onSelect'> {
    onSelect?: (event: Event) => void;
    unstyled?: boolean;
    /**
     * Prevents the menu from closing when this item is selected.
     * Useful for toggle items or multi-select scenarios.
     */
    preventCloseOnSelect?: boolean;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuItemSubTitleProps extends TextProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuItemTitleProps extends TextProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuLabelProps extends ViewProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuPortalProps {
    children?: React.ReactNode;
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
    zIndex?: number;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

export declare const MenuPredefined: {
    MenuIcon: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        unstyled?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>;
    MenuImage: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, unknown, import("@hanzogui/web").GuiComponentPropsBaseBase & Partial<import("@hanzogui/image").ImageProps>, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;
    MenuIndicator: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        unstyled?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>;
    MenuItem: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        unstyled?: boolean | undefined;
    }, …

@hanzogui/create-menu/types/MenuPredefined.d.ts

interface MenuBaseProps extends PopperPrimitive.PopperProps {
    children?: React.ReactNode;
    open?: boolean;
    onOpenChange?(open: boolean): void;
    dir?: Direction;
    modal?: boolean;
    native?: boolean;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuRadioGroupProps extends MenuGroupProps {
    value?: string;
    onValueChange?: (value: string) => void;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuRadioItemProps extends MenuItemProps {
    value: string;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuSeparatorProps extends ViewProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

export type MenuSubContentElement = MenuContentImplElement;

@hanzogui/create-menu/types/createBaseMenu.d.ts

export interface MenuSubContentProps extends Omit<MenuContentImplProps, keyof MenuContentImplPrivateProps | 'onCloseAutoFocus' | 'onEntryFocus' | 'side' | 'align'> {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

export interface MenuSubProps extends PopperPrimitive.PopperProps {
    children?: React.ReactNode;
    open?: boolean;
    onOpenChange?(open: boolean): void;
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

interface MenuSubTriggerProps extends MenuItemImplProps {
}

@hanzogui/create-menu/types/createBaseMenu.d.ts

export type MenuTriggerProps = {
    children: React.ReactElement;
    asChild?: boolean;
    /**
     * Determine whether the menu should open on `press` or `longPress`. Defaults to `press` for `Menu` and `longPress` for `ContextMenu`.
     *
     * Only applies for `ios` and `android`.
     */
    action?: 'press' | 'longPress';
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type MutateOneThemeProps = {
    name: string;
    theme: PartialTheme;
};

@hanzogui/theme/types/_mutateTheme.d.ts

export declare function mutateThemes({ themes, batch, insertCSS, ...props }: Omit<MutateThemeOptions, 'mutationType'> & {
    themes: MutateOneThemeProps[];
    batch?: Batch;
}): {
    themes: Record<string, ThemeParsed>;
    themesRaw: Record<string, ThemeParsed>;
    cssRules: string[];
};

@hanzogui/theme/types/_mutateTheme.d.ts

Props for the auxiliary view that can be shown alongside a context menu on iOS @platform ios

export type NativeContextMenuAuxiliaryProps = {
    height?: number;
    width?: number;
    anchorPosition?: 'top' | 'bottom' | 'automatic';
    children: React.ReactNode | ((options: {
        dismissMenu: () => void;
    }) => React.ReactNode);
    onDidShow?: () => void;
    marginWithScreenEdge?: number;
    onWillShow?: () => void;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeContextMenuContentProps = NativeMenuContentProps;

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeContextMenuSubContentProps = NativeContextMenuContentProps;

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuArrowProps = {};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuCheckboxItemProps = Omit<NativeMenuItemProps, 'onSelect'> & {
    /**
     * The controlled checked state of the checkbox item.
     * Use this with `onCheckedChange` for the web-style API.
     */
    checked?: boolean;
    /**
     * Callback when the checked state changes.
     * Use this with `checked` for the web-style API.
     */
    onCheckedChange?: (checked: boolean) => void;
    /**
     * The controlled value state for native platforms.
     * Use this with `onValueChange` for the native-style API.
     * @platform ios, android
     */
    value?: 'mixed' | 'on' | 'off' | boolean;
    /**
     * Callback when the value changes on native platforms.
     * Use this with `value` for the native-style API.
     * @platform ios, android
     */
    onValueChange?: (state: 'mixed' | 'on' | 'off', prevState: 'mixed' | 'on' | 'off') => void;
    key: string;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuComponents = {
    Menu: FC<NativeMenuProps> & {
        Trigger: FC<MenuTriggerProps>;
        Content: FC<NativeMenuContentProps>;
        Item: FC<NativeMenuItemProps>;
        ItemTitle: FC<NativeMenuItemTitleProps>;
        ItemSubtitle: FC<NativeMenuItemSubtitleProps>;
        SubTrigger: FC<NativeMenuSubTriggerProps>;
        Group: FC<NativeMenuGroupProps>;
        ItemIcon: FC<NativeMenuItemIconProps>;
        Separator: FC<NativeMenuSeparatorProps>;
        CheckboxItem: FC<NativeMenuCheckboxItemProps>;
        ItemIndicator: FC<NativeMenuItemIndicatorProps>;
        ItemImage: FC<NativeMenuItemImageProps>;
        Label: FC<NativeMenuLabelProps>;
        Arrow: FC<NativeMenuArrowProps>;
        Sub: FC<NativeMenuSubProps>;
        SubContent: FC<NativeMenuSubContentProps>;
        Preview: FC<ContextMenuPreviewProps>;
        Portal: FC<{
            children: React.ReactNode;
        }>;
        RadioGroup: FC<{
            children: React.ReactNode;
        }>;
        RadioItem: FC<{
            children: React.ReactNode;
        }>;
        Auxiliary: FC<NativeContextMenuAuxiliaryProps>;
    };
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenu.d.ts

export type NativeMenuContentProps = {
    children: React.ReactNode;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuGroupProps = {
    children: React.ReactNode;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export interface NativeMenuItemCommonProps {
    /**
     * React elements to render as fallback icon (typically for web)
     */
    children?: React.ReactNode;
    /**
     * The name of an iOS-only SF Symbol. For a full list, see https://developer.apple.com/sf-symbols/.
     * @deprecated Please use the `name` inside of the `ios` prop instead.
     * @platform ios
     */
    iosIconName?: string;
    /**
     * Icon configuration to be used on iOS. You can pass a SF Symbol icon using the `name` prop.
     * Additionally, you can configure the SF Symbol's features like weight, scale, color etc. by passing
     * the corresponding props. Note that some of those features require iOS 15+.
     *
     * @platform ios
     */
    ios?: {
        name: SFSymbol;
        weight?: 'ultraLight' | 'thin' | 'light' | 'regular' | 'medium' | 'semibold' | 'bold' | 'heavy' | 'black';
        scale?: 'small' | 'medium' | 'large';
        hierarchicalColor?: string;
        paletteColors?: string[];
    };
    /**
     * The name of an android-only resource drawable. For a full list, see https://developer.android.com/reference/android/R.drawable.html.
     *
     * @platform android
     */
    …

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuItemIconProps = NativeMenuItemCommonProps;

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuItemImageProps = NativeMenuItemCommonProps & {
    /**
     * `source={require('path/to/image')}`
     */
    source: ImageProps['source'];
    ios?: {
        style?: ImageOptions;
        lazy?: boolean;
    };
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuItemIndicatorProps = {
    children?: React.ReactNode;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuItemProps = {
    children: React.ReactNode;
    /**
     * If you want to pass a React text node to `<ItemTitle />`, then you need to use this prop. This gets used on iOS and Android.
     */
    textValue?: string;
    /**
     * Callback when the item is selected
     */
    onSelect?: (event?: Event) => void;
} & {
    disabled?: boolean;
    hidden?: boolean;
    destructive?: boolean;
    key: string;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuItemSubtitleProps = {
    children: string;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuItemTitleProps = {
    children: string | React.ReactNode;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuLabelProps = {
    children: string;
    /**
     * If you want to pass a React text node to `<Lable />`, then you need to use this prop. This gets used on iOS and Android.
     */
    textValue?: string;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuProps = {
    children: React.ReactNode;
    native?: boolean;
    onOpenChange?: (isOpen: boolean) => void;
    /**
     * Callback function indicating that the menu intends to open or close. Passes a `willOpen` boolean argument indicating whether it is opening or closing.
     * Unlike `onOpenChange`, this is called before the animation begins.
     * @platform `ios`
     */
    onOpenWillChange?: (willOpen: boolean) => void;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuSeparatorProps = {};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuSubContentProps = {
    children: React.ReactNode;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuSubProps = {
    children?: React.ReactNode;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativeMenuSubTriggerProps = NativeMenuItemProps & {
    key: string;
};

@hanzogui/create-menu/types/createNativeMenu/createNativeMenuTypes.d.ts

export type NativePlatform = 'web' | 'mobile' | 'android' | 'ios';

@hanzogui/helpers/types/shouldRenderNativePlatform.d.ts

export interface NativeToastRef {
    /**
     * Used to close web notifications
     */
    close: () => void;
}

@hanzogui/toast/types/types.d.ts

export type NativeValue<Platform extends NativePlatform = NativePlatform> = boolean | Platform | Platform[];

@hanzogui/helpers/types/shouldRenderNativePlatform.d.ts

export declare const Nav: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

Check if we need to manually re-propagate React context through portals. When teleport is enabled, context is automatically preserved. Otherwise, on native platforms we need to manually forward context.

export declare const needsPortalRepropagation: () => boolean;

@hanzogui/portal/types/constants.d.ts

export declare const nonAnimatableStyleProps: {
    gridAutoColumns: boolean;
    gridAutoRows: boolean;
    gridTemplateColumns: boolean;
    gridTemplateRows: boolean;
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
    backgroundAttachment?: boolean | undefined;
    backgroundBlendMode?: boolean | undefined;
    backgroundClip?: boolean | undefined;
    backgroundOrigin?: boolean | undefined;
    backgroundRepeat?: boolean | undefined;
    borderBottomStyle?: boolean | undefined;
    borderLeftStyle?: boolean | undefined;
    borderRightStyle?: boolean | undefined;
    borderTopStyle?: boolean | undefined;
    contain?: boolean | undefined;
    containerType?: boolean | undefined;
    content?: boolean | undefined;
    float?: boolean | undefined;
    maskBorderMode?: boolean | undefined;
    maskBorderRepeat?: boolean …

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const nonAnimatableWebTextProps: {
    whiteSpace: boolean;
    wordWrap: boolean;
    textOverflow: boolean;
    WebkitBoxOrient: boolean;
};

@hanzogui/helpers/types/webOnlyStyleProps.d.ts

export declare const nonAnimatableWebViewProps: {
    backgroundAttachment: boolean;
    backgroundBlendMode: boolean;
    backgroundClip: boolean;
    backgroundOrigin: boolean;
    backgroundRepeat: boolean;
    borderBottomStyle: boolean;
    borderLeftStyle: boolean;
    borderRightStyle: boolean;
    borderTopStyle: boolean;
    contain: boolean;
    containerType: boolean;
    content: boolean;
    float: boolean;
    maskBorderMode: boolean;
    maskBorderRepeat: boolean;
    maskClip: boolean;
    maskComposite: boolean;
    maskMode: boolean;
    maskOrigin: boolean;
    maskRepeat: boolean;
    maskType: boolean;
    objectFit: boolean;
    overflowBlock: boolean;
    overflowInline: boolean;
    overflowX: boolean;
    overflowY: boolean;
    pointerEvents: boolean;
    scrollbarWidth: boolean;
    textWrap: boolean;
    touchAction: boolean;
    transformStyle: boolean;
    willChange: boolean;
};

@hanzogui/helpers/types/webOnlyStyleProps.d.ts

export declare const Overlay: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    open?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/sheet/types/Sheet.d.ts

export declare const Paragraph: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Paragraph.d.ts

export type ParagraphProps = GetProps<typeof Paragraph>;

@hanzogui/text/types/Paragraph.d.ts

export declare const ParentSheetContext: React.Context<{
    zIndex: number;
}>;

@hanzogui/sheet/types/contexts.d.ts

export type Popover = {
    anchorTo: (rect: Rect) => void;
    toggle: () => void;
    open: () => void;
    close: () => void;
    setOpen: (open: boolean) => void;
};

@hanzogui/popover/types/Popover.d.ts

export declare const Popover: React.ForwardRefExoticComponent<Omit<PopperProps, "scope"> & {
    scope?: PopoverScopes;
} & {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean, via?: PopoverVia) => void;
    /**
     * When true, children never un-mount, otherwise they mount on open.
     * When "lazy", they mount inside a startTransition after first render.
     *
     * @default false
     */
    keepChildrenMounted?: boolean | 'lazy';
    /**
     * Enable staying open while mouseover
     */
    hoverable?: boolean | UseHoverProps;
    /**
     * Disable focusing behavior on open
     */
    disableFocus?: boolean;
    /**
     * Disable the dismissable layer (escape key, outside click handling).
     * Useful for popovers that stay mounted but are visually hidden.
     */
    disableDismissable?: boolean;
    /**
     * z-index for the popover portal. Use this when popovers need to appear
     * above other portaled content like dialogs or fixed headers.
     *
     * By default, Gui automatically stacks overlays - later-opened content
     * appears above earlier content, and nested content appears above its parent.
     * Only set this if you …

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverAnchor: React.NamedExoticComponent<Omit<YStackProps, "scope"> & {
    scope?: PopoverScopes;
} & React.RefAttributes<GuiElement>>;

@hanzogui/popover/types/Popover.d.ts

export type PopoverAnchorProps = ScopedPopoverProps<YStackProps>;

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverArrow: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, keyof PopperArrowExtraProps> & PopperArrowExtraProps, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & PopperArrowExtraProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/popover/types/Popover.d.ts

export type PopoverArrowProps = PopperArrowProps;

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverClose: React.ForwardRefExoticComponent<Omit<YStackProps, "scope"> & {
    scope?: PopoverScopes;
} & React.RefAttributes<GuiElement>>;

@hanzogui/popover/types/Popover.d.ts

export type PopoverCloseProps = ScopedPopoverProps<YStackProps>;

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverContent: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, keyof PopoverContentTypeProps> & PopoverContentTypeProps, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & PopoverContentTypeProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/popover/types/Popover.d.ts

export type PopoverContentImplProps = PopperContentProps & Omit<DismissableProps, 'onDismiss' | 'children' | 'onPointerDownCapture'> & {
    /**
     * Rather than mount the content immediately, mounts it in a useEffect
     * inside a startTransition to clear the main thread
     */
    lazyMount?: boolean;
    /**
     * Whether focus should be trapped within the `Popover`
     * @default false
     */
    trapFocus?: FocusScopeProps['trapped'];
    /**
     * Whether popover should not focus contents on open
     * @default false
     */
    disableFocusScope?: boolean;
    /**
     * Event handler called when auto-focusing on open. Can be prevented.
     */
    onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
    /**
     * Event handler called when auto-focusing on close. Can be prevented.
     */
    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'] | false;
    enableRemoveScroll?: boolean;
    freezeContentsWhenHidden?: boolean;
    /**
     * Performance - if never going to use feature can permanently disable
     */
    alwaysDisable?: {
        focus?: boolean;
        'remove-scroll'?: boolean;
        dismiss?: boolean;
    };
};

@hanzogui/popover/types/Popover.d.ts

export type PopoverContentProps = PopoverContentTypeProps;

@hanzogui/popover/types/Popover.d.ts

export interface PopoverContentTypeProps extends Omit<PopoverContentImplProps, 'disableOutsidePointerEvents'> {
    /**
     * Enable smooth animation when the content position changes (e.g., when flipping sides)
     */
    animatePosition?: boolean | 'even-when-repositioning';
    /** @deprecated Use `animatePosition` instead */
    enableAnimationForPositionChange?: boolean;
}

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverContext: import("@hanzogui/web").StyledContext<PopoverContextValue>;

@hanzogui/popover/types/Popover.d.ts

Provider that sets up both PopoverContext and PopoverTriggerContext. Use this in Tooltip or other components that need popover trigger behavior.

export declare const PopoverContextProvider: React.MemoExoticComponent<({ scope, children, open, onOpenChange, onOpenToggle, triggerRef, id, contentId, hasCustomAnchor, onCustomAnchorAdd, onCustomAnchorRemove, anchorTo, adaptScope, breakpointActive, keepChildrenMounted, disableDismissable, hoverable, }: PopoverContextProviderProps) => React.JSX.Element>;

@hanzogui/popover/types/Popover.d.ts

export type PopoverContextProviderProps = {
    scope: string;
    children: React.ReactNode;
    open: boolean;
    onOpenChange(open: boolean, via?: 'hover' | 'press'): void;
    onOpenToggle(): void;
    triggerRef: React.RefObject<any>;
    id?: string;
    contentId?: string;
    hasCustomAnchor?: boolean;
    onCustomAnchorAdd?: () => void;
    onCustomAnchorRemove?: () => void;
    anchorTo?: Rect;
    adaptScope?: string;
    breakpointActive?: boolean;
    keepChildrenMounted?: boolean | 'lazy';
    disableDismissable?: boolean;
    hoverable?: boolean | object;
};

@hanzogui/popover/types/Popover.d.ts

export type PopoverProps = ScopedPopoverProps<PopperProps> & {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean, via?: PopoverVia) => void;
    /**
     * When true, children never un-mount, otherwise they mount on open.
     * When "lazy", they mount inside a startTransition after first render.
     *
     * @default false
     */
    keepChildrenMounted?: boolean | 'lazy';
    /**
     * Enable staying open while mouseover
     */
    hoverable?: boolean | UseHoverProps;
    /**
     * Disable focusing behavior on open
     */
    disableFocus?: boolean;
    /**
     * Disable the dismissable layer (escape key, outside click handling).
     * Useful for popovers that stay mounted but are visually hidden.
     */
    disableDismissable?: boolean;
    /**
     * z-index for the popover portal. Use this when popovers need to appear
     * above other portaled content like dialogs or fixed headers.
     *
     * By default, Gui automatically stacks overlays - later-opened content
     * appears above earlier content, and nested content appears above its parent.
     * Only set this if you need to override the automatic stacking behavior.
     *
     * …

@hanzogui/popover/types/Popover.d.ts

export type PopoverScopes = string;

@hanzogui/popover/types/Popover.d.ts

export type PopoverScrollViewProps = ScrollViewProps & {
    scope?: string;
};

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverTrigger: React.NamedExoticComponent<Omit<import("@hanzogui/web").StackNonStyleProps & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>> & import("@hanzogui/web").WithMediaProps<import("@hanzogui/web").WithThemeShorthandsAndPseudos<import("@hanzogui/web").StackStyleBase, {}>> & {
    /**
     * When true, disables the built-in click-to-toggle behavior on the trigger.
     * Useful for hoverable popovers where you want to control open/close
     * entirely through hover or your own handlers.
     */
    disablePressTrigger?: boolean;
}, "scope"> & {
    scope?: PopoverScopes;
} & React.RefAttributes<GuiElement>>;

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverTriggerContext: import("@hanzogui/web").StyledContext<PopoverTriggerContextValue>;

@hanzogui/popover/types/Popover.d.ts

export type PopoverTriggerProps = ScopedPopoverProps<ViewProps & {
    /**
     * When true, disables the built-in click-to-toggle behavior on the trigger.
     * Useful for hoverable popovers where you want to control open/close
     * entirely through hover or your own handlers.
     */
    disablePressTrigger?: boolean;
}>;

@hanzogui/popover/types/Popover.d.ts

export declare const PopoverZIndexContext: React.Context<number | undefined>;

@hanzogui/popover/types/Popover.d.ts

export declare function Popper(props: PopperProps): React.JSX.Element;

@hanzogui/popper/types/Popper.d.ts

export declare const PopperAnchor: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}>, keyof PopperAnchorExtraProps> & PopperAnchorExtraProps, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & PopperAnchorExtraProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/popper/types/Popper.d.ts

export type PopperAnchorExtraProps = {
    virtualRef?: React.RefObject<any>;
    scope?: string;
};

@hanzogui/popper/types/Popper.d.ts

export type PopperAnchorProps = YStackProps;

@hanzogui/popper/types/Popper.d.ts

export declare const PopperArrow: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}>, keyof import("@hanzogui/stacks").StackVariants> & import("@hanzogui/stacks").StackVariants & PopperArrowExtraProps & React.RefAttributes<GuiElement>>;

@hanzogui/popper/types/Popper.d.ts

export type PopperArrowExtraProps = {
    offset?: number;
    size?: SizeTokens;
    scope?: string;
    /**
     * Enable smooth animation when the arrow position changes
     */
    animatePosition?: boolean;
};

@hanzogui/popper/types/Popper.d.ts

export declare const PopperArrowFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/popper/types/Popper.d.ts

export type PopperArrowProps = YStackProps & PopperArrowExtraProps;

@hanzogui/popper/types/Popper.d.ts

export declare const PopperContent: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "bordered" | "chromeless" | "circular" | "elevate" | "elevation" | "fullscreen" | "size" | "transparent" | "unstyled" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | …

@hanzogui/popper/types/Popper.d.ts

export declare const PopperContentFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/popper/types/Popper.d.ts

export type PopperContentProps = SizableStackProps & {
    scope?: string;
    /**
     * Enable smooth animation when the content position changes (e.g., when flipping sides)
     */
    animatePosition?: boolean | 'even-when-repositioning';
    /** @deprecated Use `animatePosition` instead */
    enableAnimationForPositionChange?: boolean | 'even-when-repositioning';
    passThrough?: boolean;
};

@hanzogui/popper/types/Popper.d.ts

export declare const PopperContextFast: import("@hanzogui/web").StyledContext<PopperContextValue>;

@hanzogui/popper/types/Popper.d.ts

export type PopperContextShared = {
    open: boolean;
    size?: SizeTokens;
    hasFloating: boolean;
    arrowStyle?: Partial<Coords> & {
        centerOffset: number;
    };
    placement?: Placement;
    arrowRef: any;
    onArrowSize?: (val: number) => void;
    transformOrigin?: {
        x: string;
        y: string;
    };
};

@hanzogui/popper/types/Popper.d.ts

export declare const PopperContextSlow: import("@hanzogui/web").StyledContext<PopperContextSlowValue>;

@hanzogui/popper/types/Popper.d.ts

export type PopperContextSlowValue = Pick<UseFloatingReturn, 'getReferenceProps' | 'update' | 'refs'> & {
    onHoverReference?: (event: any) => void;
    onLeaveReference?: () => void;
    triggerElements?: PopupTriggerMap;
};

@hanzogui/popper/types/Popper.d.ts

export type PopperContextValue = UseFloatingReturn & PopperContextShared;

@hanzogui/popper/types/Popper.d.ts

export declare const PopperPositionContext: <VariantProps extends Record<string, any>>(defaultValues?: VariantProps, namespace?: string) => import("@hanzogui/web").StyledContext<VariantProps>;

@hanzogui/popper/types/Popper.d.ts

export type PopperProps = {
    /**
     * Popper is a component used by other components to create interfaces, so scope is required
     * For example Popover uses it internally and sets a default "POPOVER_SCOPE".
     */
    scope?: string;
    /**
     * Optional, will disable measuring updates when open is false for better performance
     * */
    open?: boolean;
    size?: SizeTokens;
    children?: React.ReactNode;
    /**
     * Determine the preferred placement of the content in relation to the trigger
     */
    placement?: Placement;
    /**
     * Shifts content horizontally to stay within viewport.
     * Pass an object to override shift options (mainAxis, crossAxis, padding, etc).
     * Defaults: { mainAxis: true, crossAxis: false, padding: 10 }
     * @see https://floating-ui.com/docs/shift
     */
    stayInFrame?: ShiftProps | boolean;
    /**
     * Allows content to switch sides when space is limited.
     * @see https://floating-ui.com/docs/flip
     */
    allowFlip?: FlipProps | boolean;
    /**
     * Resizes the content to fix inside the screen when space is limited
     * @see https://floating-ui.com/docs/size
     */
    resize?: boolean | …

@hanzogui/popper/types/Popper.d.ts

export declare const PopperProvider: ({ scope, children, ...context }: PopperContextValue & {
    scope?: string;
    children?: React.ReactNode;
}) => React.JSX.Element;

@hanzogui/popper/types/Popper.d.ts

export declare const usePopperContext: (scope?: string) => PopperContextValue, PopperProviderFast: React.Provider<PopperContextValue> & React.ProviderExoticComponent<Partial<PopperContextValue> & {
    children?: React.ReactNode;
    scope?: string;
}>;

@hanzogui/popper/types/Popper.d.ts

export declare const usePopperContextSlow: (scope?: string) => PopperContextSlowValue, PopperProviderSlow: React.Provider<PopperContextSlowValue> & React.ProviderExoticComponent<Partial<PopperContextSlowValue> & {
    children?: React.ReactNode;
    scope?: string;
}>;

@hanzogui/popper/types/Popper.d.ts

export type PopperSetupOptions = {
    disableRTL?: boolean;
};

@hanzogui/popper/types/Popper.d.ts

export declare const Portal: React.MemoExoticComponent<(propsIn: PortalProps) => React.ReactNode>;

@hanzogui/portal/types/Portal.d.ts

export declare const PortalHost: React.MemoExoticComponent<(props: PortalHostProps) => React.JSX.Element>;

@hanzogui/portal/types/GorhomPortal.d.ts

export interface PortalHostProps {
    /**
     * Host's key or name to be used as an identifier.
     * @type string
     */
    name: string;
    forwardProps?: Record<string, any>;
    /**
     * Useful when trying to animate children with AnimatePresence.
     *
     * Not a part of gorhom/react-native-portal
     */
    render?: (children: React.ReactNode) => React.ReactElement;
}

@hanzogui/portal/types/GorhomPortal.d.ts

export declare const GorhomPortalItem: (props: PortalItemProps) => import("react").ReactNode;

@hanzogui/portal/types/GorhomPortalItem.d.ts

export declare const portalListeners: Record<string, Set<Function>>;

@hanzogui/portal/types/constants.d.ts

export type PortalProps = {
    zIndex?: ViewProps['zIndex'];
    passThrough?: boolean;
    stackZIndex?: StackZIndexProp;
    children?: ReactNode;
    style?: CSSProperties;
    /**
     * Optional property just to indicate open and enable pointer-events
     */
    open?: boolean;
};

@hanzogui/portal/types/PortalProps.d.ts

export declare const PortalProvider: React.MemoExoticComponent<typeof PortalProviderComponent>;

@hanzogui/portal/types/GorhomPortal.d.ts

export interface PortalProviderProps {
    /**
     * Defines whether to add a default root host or not.
     *
     * @default true
     * @type boolean
     */
    shouldAddRootHost?: boolean;
    /**
     * Defines the root portal host name.
     *
     * @default "root"
     * @type string
     */
    rootHostName?: string;
    children: ReactNode | ReactNode[];
}

@hanzogui/portal/types/GorhomPortal.d.ts

export type PositionChangeHandler = (position: number) => void;

@hanzogui/sheet/types/types.d.ts

export declare const PresenceChild: React.MemoExoticComponent<({ children, initial, isPresent, onExitComplete, exitVariant, enterVariant, enterExitVariant, presenceAffectsLayout, custom, }: PresenceChildProps) => React.JSX.Element>;

@hanzogui/animate-presence/types/PresenceChild.d.ts

export declare const PresenceContext: React.Context<PresenceContextProps | null>;

@hanzogui/use-presence/types/PresenceContext.d.ts

export declare const prevent: (e: any) => any[];

@hanzogui/component-helpers/types/prevent.d.ts

declare const Progress: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, keyof ProgressExtraProps> & ProgressExtraProps & import("react").RefAttributes<import("@hanzogui/web").GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, keyof ProgressExtraProps> & ProgressExtraProps, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & ProgressExtraProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    …

@hanzogui/progress/types/Progress.d.ts

export interface ProgressExtraProps {
    value?: number | null | undefined;
    max?: number;
    getValueLabel?(value: number, max: number): string;
}

@hanzogui/progress/types/Progress.d.ts

export declare const ProgressFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/progress/types/Progress.d.ts

declare const ProgressIndicator: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & void, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/progress/types/Progress.d.ts

export declare const ProgressIndicatorFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/progress/types/Progress.d.ts

export type ProgressIndicatorProps = GetProps<typeof ProgressIndicatorFrame>;

@hanzogui/progress/types/Progress.d.ts

export type ProgressProps = GetProps<typeof ProgressFrame> & ProgressExtraProps;

@hanzogui/progress/types/Progress.d.ts

export declare const ProvideAdaptContext: ({ children, ...context }: AdaptParentContextI & {
    children: any;
}) => React.JSX.Element;

@hanzogui/adapt/types/Adapt.d.ts

export declare const RadioGroup: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
}>, "accentColor" | "defaultValue" | "elevation" | "fullscreen" | "name" | "native" | "onValueChange" | "orientation" | "required" | "value" | `$${string}` | `$${number}` | import("@hanzogui/web").GroupMediaKeys | keyof import("@hanzogui/core").RNGuiViewNonStyleProps | keyof import("@hanzogui/web").StackStyleBase | keyof import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>>> & Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "elevation" | "fullscreen" …

@hanzogui/radio-group/types/index.d.ts

export declare const RadioGroupFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/radio-group/types/RadioGroup.d.ts

export declare const RadioGroupIndicatorFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/radio-group/types/RadioGroup.d.ts

export declare const RadioGroupItemFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    disabled?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/radio-group/types/RadioGroup.d.ts

export type RadioGroupItemProps = GetProps<typeof RadioGroupItemFrame> & {
    value: string;
    id?: string;
    labelledBy?: string;
    disabled?: boolean;
};

@hanzogui/radio-group/types/createRadioGroup.d.ts

export type RadioGroupProps = GetProps<typeof RadioGroupFrame> & {
    value?: string;
    defaultValue?: string;
    onValueChange?: (value: string) => void;
    required?: boolean;
    disabled?: boolean;
    name?: string;
    native?: boolean;
    accentColor?: string;
};

@hanzogui/radio-group/types/createRadioGroup.d.ts

export declare const RadioGroupStyledContext: import("@hanzogui/web").StyledContext<{
    size: SizeTokens;
    scaleIcon: number;
}>;

@hanzogui/radio-group/types/RadioGroupStyledContext.d.ts

declare const Range: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "elevation" | "fullscreen" | "orientation" | "size" | "unstyled" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>> & …

@hanzogui/slider/types/Slider.d.ts

export interface RegisterHostAction {
    type: ACTIONS;
    hostName: string;
}

@hanzogui/portal/types/GorhomPortal.d.ts

export interface RemovePortalAction {
    type: ACTIONS;
    hostName: string;
    portalName: string;
}

@hanzogui/portal/types/GorhomPortal.d.ts

export type RemoveScrollProps = React.ComponentProps<typeof RemoveScroll>;

@hanzogui/sheet/types/types.d.ts

export declare function replaceTheme({ name, theme, }: {
    name: string;
    theme: Partial<Record<keyof ThemeDefinition, any>>;
}): {
    themeRaw: import("@hanzogui/web").ThemeParsed;
    theme: {};
    cssRules: string[];
} | undefined;

@hanzogui/theme/types/replaceTheme.d.ts

export declare const ResetPresence: (props: {
    children?: React.ReactNode;
    disable?: boolean;
}) => React.ReactNode;

@hanzogui/use-presence/types/PresenceContext.d.ts

export declare const resolveViewZIndex: (zIndex: ViewProps['zIndex']) => any;

@hanzogui/portal/types/helpers.d.ts

export type Scope<C = any> = {
    [scopeName: string]: React.Context<C>[];
} | undefined;

@hanzogui/create-context/types/create-context.d.ts

export type ScopedProps<P, K extends string> = P & {
    [Key in `__scope${K}`]?: Scope;
};

@hanzogui/create-context/types/create-context.d.ts

export type ScrollBridge = {
    enabled: boolean;
    y: number;
    paneY: number;
    paneMinY: number;
    scrollStartY: number;
    hasScrollableContent: boolean;
    drag: (dy: number) => void;
    release: (state: {
        dragAt: number;
        vy: number;
    }) => void;
    scrollLock: boolean;
    isParentDragging: boolean;
    onParentDragging: (props: (val: boolean) => void) => () => void;
    setParentDragging: (val: boolean) => void;
    onFinishAnimate?: () => void;
    blockPan?: boolean;
    initialPosition?: number;
    isScrollablePositionLocked?: boolean;
    setScrollEnabled?: (enabled: boolean, lockTo?: number) => void;
    _lastTouchY?: number;
    scrollLockY?: number;
    lockScrollAtTop?: boolean;
    forceScrollTo?: (y: number) => void;
    isAtTop?: boolean;
    snapToPosition?: (positionIndex: number) => void;
    startPanDrag?: () => void;
    scrollNodeTouched?: boolean;
};

@hanzogui/sheet/types/types.d.ts

export type ScrollView = GetRef<typeof ScrollView>;

@hanzogui/scroll-view/types/ScrollView.d.ts

export declare const ScrollView: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, ScrollViewNative, import("@hanzogui/web").GuiComponentPropsBaseBase & import("react-native").ScrollViewProps, import("@hanzogui/web").StackStyleBase & {
    readonly contentContainerStyle?: Partial<import("@hanzogui/web").InferStyleProps<typeof ScrollViewNative, {
        accept: {
            readonly contentContainerStyle: 'style';
        };
    }>> | undefined;
}, {
    fullscreen?: boolean | undefined;
}, {
    accept: {
        readonly contentContainerStyle: 'style';
    };
}>;

@hanzogui/scroll-view/types/ScrollView.d.ts

export type ScrollViewProps = GetProps<typeof ScrollView>;

@hanzogui/scroll-view/types/ScrollView.d.ts

export declare const Section: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/elements/types/index.d.ts

export declare const Select: (<Value extends string = string>(props: SelectScopedProps<SelectProps<Value>>) => React.JSX.Element) & {
    Adapt: ((props: import("@hanzogui/adapt").AdaptProps) => React.JSX.Element) & {
        Contents: typeof import("@hanzogui/adapt").AdaptContents;
    };
    Content: typeof SelectContent;
    Group: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "elevation" | "fullscreen" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
        elevation?: number | SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    } & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
        elevation?: number | SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    } & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>> & …

@hanzogui/select/types/Select.d.ts

export type SelectContentProps = SelectScopedProps<{
    children?: React.ReactNode;
}>;

@hanzogui/select/types/types.d.ts

export interface SelectContextValue {
    dir?: SelectDirection;
    scopeName: string;
    adaptScope: string;
    value: any;
    selectedIndex: number;
    /** current active index state - use for rendering, may lag behind ref */
    activeIndex: number | null;
    /** ref to current active index - always up to date, use for reads */
    activeIndexRef: MutableRefObject<number | null>;
    /** slow setter: updates ref + emits + triggers re-render */
    setActiveIndex: (index: number | null) => void;
    open: boolean;
    valueNode: Element | null;
    onValueNodeChange(node: HTMLElement): void;
    forceUpdate: DispatchWithoutAction;
    isInSheet?: boolean;
    fallback: boolean;
    blockSelection: boolean;
    upArrowRef?: MutableRefObject<HTMLDivElement | null>;
    downArrowRef?: MutableRefObject<HTMLDivElement | null>;
    setScrollTop?: Function;
    setInnerOffset?: Function;
    controlledScrolling?: boolean;
    canScrollUp?: boolean;
    canScrollDown?: boolean;
    floatingContext?: FloatingContext<ReferenceType>;
    native?: NativeValue;
    disablePreventBodyScroll?: boolean;
    /** update floating-ui to recalculate */
    update?: () => void;
    /** Render …

@hanzogui/select/types/types.d.ts

export type SelectDirection = 'ltr' | 'rtl';

@hanzogui/select/types/types.d.ts

export declare const SelectGroupFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/select/types/Select.d.ts

export declare const SelectIcon: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/select/types/Select.d.ts

export type SelectImplProps = SelectScopedProps<SelectProps> & {
    activeIndexRef: any;
    selectedIndexRef: any;
    listContentRef: any;
    /** fast setter: updates ref + emits to subscribers (no re-render) - use for hover/navigation */
    setActiveIndexFast: (index: number | null) => void;
};

@hanzogui/select/types/types.d.ts

export type SelectIndicatorProps = GetProps<typeof SelectIndicatorFrame>;

@hanzogui/select/types/Select.d.ts

export interface SelectItemExtraProps {
    value: string;
    index: number;
    disabled?: boolean;
    textValue?: string;
}

@hanzogui/select/types/SelectItem.d.ts

export interface SelectItemParentContextValue {
    adaptScope: string;
    scopeName: string;
    id?: string;
    initialValue?: any;
    setSelectedIndex: (index: number) => void;
    listRef?: MutableRefObject<Array<HTMLElement | null>>;
    setOpen: (open: boolean) => void;
    onChange: (value: string) => void;
    onActiveChange: (value: string, index: number) => void;
    activeIndexSubscribe: EmitterSubscriber<number>;
    activeIndexRef?: MutableRefObject<number | null>;
    valueSubscribe: EmitterSubscriber<any>;
    allowSelectRef?: MutableRefObject<boolean>;
    allowMouseUpRef?: MutableRefObject<boolean>;
    setValueAtIndex: (index: number, value: string) => void;
    selectTimeoutRef?: MutableRefObject<any>;
    dataRef?: MutableRefObject<ContextData>;
    interactions?: {
        getReferenceProps: (userProps?: HTMLProps<Element> | undefined) => any;
        getFloatingProps: (userProps?: HTMLProps<HTMLElement> | undefined) => any;
        getItemProps: (userProps?: HTMLProps<HTMLElement> | undefined) => any;
    };
    shouldRenderWebNative?: boolean;
    size?: SizeTokens;
    /** fast setter: updates ref + emits to subscribers (no re-render) - use for keyboard …

@hanzogui/select/types/types.d.ts

export declare const SelectItemParentProvider: import("react").Provider<SelectItemParentContextValue> & import("react").ProviderExoticComponent<Partial<SelectItemParentContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>, useSelectItemParentContext: (scope?: string) => SelectItemParentContextValue;

@hanzogui/select/types/context.d.ts

export interface SelectItemProps extends Omit<ListItemProps, keyof SelectItemExtraProps>, SelectItemExtraProps {
}

@hanzogui/select/types/SelectItem.d.ts

export type SelectLabelProps = SelectScopedProps<GetProps<typeof SelectLabelFrame>>;

@hanzogui/select/types/Select.d.ts

export interface SelectProps<Value extends string = string> {
    id?: string;
    children?: ReactNode;
    value?: Value;
    defaultValue?: Value;
    onValueChange?(value: Value): void;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
    dir?: SelectDirection;
    name?: string;
    autoComplete?: string;
    size?: SizeTokens;
    /**
     * If passed, will render a native component instead of the custom one. Currently only `web` is supported.
     */
    native?: NativeValue<'web'>;
    /**
     * When true, avoids removing the scrollbar from the body when open
     */
    disablePreventBodyScroll?: boolean;
    /**
     * Called when an item is hovered by mouse or navigated to by keyboard.
     */
    onActiveChange?(value: string, index: number): void;
    /**
     * Render function for the selected value. Use this for SSR support.
     * When provided, this is called synchronously during render to display
     * the selected value, avoiding hydration mismatches.
     *
     * @example
     * ```tsx
     * <Select
     *   defaultValue="apple"
     *   renderValue={(value) => ({ apple: 'Apple', orange: 'Orange' }[value])}
     * >
     …

@hanzogui/select/types/types.d.ts

export declare const SelectProvider: import("react").Provider<SelectContextValue> & import("react").ProviderExoticComponent<Partial<SelectContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>, useSelectContext: (scope?: string) => SelectContextValue;

@hanzogui/select/types/context.d.ts

export type SelectScopedProps<P> = P & {
    scope?: SelectScopes;
};

@hanzogui/select/types/types.d.ts

export type SelectScopes = string;

@hanzogui/select/types/types.d.ts

export type SelectScrollButtonImplProps = YStackProps & SelectScopedProps<{
    dir: 'up' | 'down';
    componentName: string;
}>;

@hanzogui/select/types/types.d.ts

export interface SelectScrollButtonProps extends Omit<SelectScrollButtonImplProps, 'dir' | 'componentName'> {
}

@hanzogui/select/types/types.d.ts

export declare const SelectSeparator: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    unstyled?: boolean | undefined;
    vertical?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/select/types/Select.d.ts

export type SelectTriggerProps = SelectScopedProps<ListItemProps>;

@hanzogui/select/types/SelectTrigger.d.ts

export type SelectValueExtraProps = SelectScopedProps<{
    placeholder?: React.ReactNode;
}>;

@hanzogui/select/types/Select.d.ts

export type SelectValueProps = GetProps<typeof SelectValueFrame> & SelectValueExtraProps;

@hanzogui/select/types/Select.d.ts

export type SelectViewportExtraProps = SelectScopedProps<{
    size?: SizeTokens;
    disableScroll?: boolean;
    unstyled?: boolean;
}>;

@hanzogui/select/types/types.d.ts

export type SelectViewportProps = YStackProps & SelectViewportExtraProps;

@hanzogui/select/types/types.d.ts

export declare const SelectZIndexContext: import("react").Context<number | undefined>;

@hanzogui/select/types/context.d.ts

export declare const Separator: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    unstyled?: boolean | undefined;
    vertical?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/separator/types/Separator.d.ts

Set a given ref to a given value This utility takes care of different types of refs: callback refs and RefObject(s)

export declare function setRef<T>(ref: PossibleRef<T>, value: T): void;

@hanzogui/compose-refs/types/compose-refs.d.ts

export declare function setupNativeSheet(platform: SheetNativePlatforms, RNIOSModal: {
    ModalSheetView: any;
    ModalSheetViewMainContent: any;
}): void;

@hanzogui/sheet/types/nativeSheet.d.ts

export declare function setupPopper(options?: PopperSetupOptions): void;

@hanzogui/popper/types/Popper.d.ts

export declare const Sheet: import("react").ForwardRefExoticComponent<{
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: import("react").Dispatch<import("react").SetStateAction<boolean>> | ((open: boolean) => void);
    position?: number;
    defaultPosition?: number;
    snapPoints?: (string | number)[];
    snapPointsMode?: import("./types.tsx").SnapPointsMode;
    onPositionChange?: import("./types.tsx").PositionChangeHandler;
    children?: import("react").ReactNode;
    dismissOnOverlayPress?: boolean;
    dismissOnSnapToBottom?: boolean;
    disableRemoveScroll?: boolean;
    forceRemoveScrollEnabled?: boolean;
    transitionConfig?: import("@hanzogui/web").AnimatedNumberStrategy;
    preferAdaptParentOpenState?: boolean;
    unmountChildrenWhenHidden?: boolean;
    disableTransparencyHide?: boolean;
    native?: 'ios'[] | boolean;
    transition?: import("@hanzogui/web").TransitionProp;
    handleDisableScroll?: boolean;
    disableDrag?: boolean;
    modal?: boolean;
    zIndex?: number;
    portalProps?: import("@hanzogui/portal").PortalProps;
    moveOnKeyboardChange?: boolean;
    containerComponent?: React.ComponentType<any>;
    onAnimationComplete?: …

@hanzogui/sheet/types/Sheet.d.ts

export declare const SheetController: ({ children, onOpenChange: onOpenChangeProp, onAnimationComplete: onAnimationCompleteProp, open, hidden, disableDrag, }: Partial<SheetControllerContextValue> & {
    children?: ReactNode;
}) => React.JSX.Element;

@hanzogui/sheet/types/SheetController.d.ts

export declare const SheetControllerContext: React.Context<SheetControllerContextValue | null>;

@hanzogui/sheet/types/useSheetController.d.ts

export type SheetControllerContextValue = {
    id?: string;
    disableDrag?: boolean;
    open?: boolean;
    hidden?: boolean;
    onOpenChange?: React.Dispatch<React.SetStateAction<boolean>> | ((val: boolean) => void);
    onAnimationComplete?: (state: {
        open: boolean;
    }) => void;
    skipNextAnimation?: boolean;
};

@hanzogui/sheet/types/useSheetController.d.ts

export declare const SheetInsideSheetContext: React.Context<((hasChild: boolean) => void) | null>;

@hanzogui/sheet/types/contexts.d.ts

export type SheetOpenState = ReturnType<typeof useSheetOpenState>;

@hanzogui/sheet/types/useSheetOpenState.d.ts

export type SheetProps = ScopedProps<{
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: OpenChangeHandler;
    /**
     * Control the index of the position in the `snapPoints` array
     */
    position?: number;
    /**
     * Initial position from the `snapPoints` array
     */
    defaultPosition?: number;
    /**
     * Array of pixels or percents the Sheet will attempt to move to when dragged.
     * The first is the topmost and default when first opened via open prop.
     */
    snapPoints?: (string | number)[];
    snapPointsMode?: SnapPointsMode;
    onPositionChange?: PositionChangeHandler;
    children?: ReactNode;
    dismissOnOverlayPress?: boolean;
    dismissOnSnapToBottom?: boolean;
    /**
     * Disables the RemoveScroll behavior that prevents body scrolling while sheet is open.
     * By default, RemoveScroll is enabled when the sheet is open and modal.
     */
    disableRemoveScroll?: boolean;
    /**
     * @deprecated Use `disableRemoveScroll` instead. This prop will be removed in a future version.
     * Note: `disableRemoveScroll={true}` is equivalent to `forceRemoveScrollEnabled={false}`
     */
    forceRemoveScrollEnabled?: boolean;
    …

@hanzogui/sheet/types/types.d.ts

export type SheetScopedProps<A> = ScopedProps<A, 'Sheet'>;

@hanzogui/sheet/types/types.d.ts

export declare const SheetScrollView: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GuiComponentPropsBaseBase & import("react-native").ScrollViewProps, "contentContainerStyle" | "fullscreen" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase & {
    readonly contentContainerStyle?: Partial<import("@hanzogui/web").InferStyleProps<typeof RNScrollView, {
        accept: {
            readonly contentContainerStyle: 'style';
        };
    }>> | undefined;
}> & {
    fullscreen?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase & {
    readonly contentContainerStyle?: Partial<import("@hanzogui/web").InferStyleProps<typeof RNScrollView, {
        accept: {
            readonly contentContainerStyle: 'style';
        };
    }>> | undefined;
}>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase & {
    readonly contentContainerStyle?: Partial<import("@hanzogui/web").InferStyleProps<typeof RNScrollView, {
        accept: {
            …

@hanzogui/sheet/types/SheetScrollView.d.ts

export type ShorthandTextStyleProps = ShorthandViewStyleProps & {
    ta?: TextStyle['textAlign'];
    fs?: TextStyle['fontSize'];
    lh?: TextStyle['lineHeight'];
};

@hanzo/gui/types/viewTypes.d.ts

export type ShorthandViewStyleProps = {
    w?: ViewStyle['width'];
    h?: ViewStyle['height'];
    p?: ViewStyle['padding'];
    pt?: ViewStyle['paddingTop'];
    pb?: ViewStyle['paddingBottom'];
    pl?: ViewStyle['paddingLeft'];
    pr?: ViewStyle['paddingRight'];
    px?: ViewStyle['paddingHorizontal'];
    py?: ViewStyle['paddingVertical'];
    m?: ViewStyle['margin'];
    mt?: ViewStyle['marginTop'];
    mb?: ViewStyle['marginBottom'];
    ml?: ViewStyle['marginLeft'];
    mr?: ViewStyle['marginRight'];
    mx?: ViewStyle['marginHorizontal'];
    my?: ViewStyle['marginVertical'];
    f?: ViewStyle['flex'];
    fd?: ViewStyle['flexDirection'];
    fw?: ViewStyle['flexWrap'];
    fg?: ViewStyle['flexGrow'];
    fs?: ViewStyle['flexShrink'];
    fb?: ViewStyle['flexBasis'];
    ai?: ViewStyle['alignItems'];
    ac?: ViewStyle['alignContent'];
    jc?: ViewStyle['justifyContent'];
    als?: ViewStyle['alignSelf'];
    bc?: ViewStyle['backgroundColor'];
    br?: ViewStyle['borderRadius'];
    btrr?: ViewStyle['borderTopRightRadius'];
    bbrr?: ViewStyle['borderBottomRightRadius'];
    bblr?: ViewStyle['borderBottomLeftRadius'];
    btlr?: ViewStyle['borderTopLeftRadius'];
    …

@hanzo/gui/types/viewTypes.d.ts

takes in what user has inputted the native-supporting component and returns the name of the native platform we should render @example ['android'] => 'android' (when current platform is android) @example ['android'] => null (when current platform is not android) @example ['mobile'] => 'ios' (when current platform is ios) @param supportedSpecificNativeValues the platforms your component/system supports @param nativeProp the platforms your user is requesting you to use @returns

export declare function shouldRenderNativePlatform(nativeProp?: NativeValue): ExplicitNativePlatform | null;

@hanzogui/helpers/types/shouldRenderNativePlatform.d.ts

export declare const simpleHash: (strIn: string, hashMin?: number | 'strict') => string;

@hanzogui/simple-hash/types/index.d.ts

export declare const SizableStack: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/stacks/types/SizableStack.d.ts

export type SizableStackProps = GetProps<typeof SizableStack>;

@hanzogui/stacks/types/SizableStack.d.ts

export declare const SizableText: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    size?: import("@hanzogui/web").FontSizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/SizableText.d.ts

export type SizableTextProps = GetProps<typeof SizableText>;

@hanzogui/text/types/SizableText.d.ts

declare const Slider: React.ForwardRefExoticComponent<SliderProps & {
    __scopeSlider?: string;
} & React.RefAttributes<unknown>> & {
    Track: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "bordered" | "chromeless" | "circular" | "elevate" | "elevation" | "fullscreen" | "size" | "transparent" | "unstyled" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
        bordered?: boolean | undefined;
        chromeless?: "all" | boolean | undefined;
        circular?: boolean | undefined;
        elevate?: boolean | undefined;
        elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
        fullscreen?: boolean | undefined;
        size?: import("@hanzogui/web").SizeTokens | undefined;
        transparent?: boolean | undefined;
        unstyled?: boolean | undefined;
    } & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
        bordered?: boolean …

@hanzogui/slider/types/Slider.d.ts

declare const SliderActive: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "elevation" | "fullscreen" | "orientation" | "size" | "unstyled" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>>> & …

@hanzogui/slider/types/Slider.d.ts

export declare const SliderActiveFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/slider/types/Slider.d.ts

type SliderActiveProps = GetProps<typeof SliderActiveFrame>;

@hanzogui/slider/types/Slider.d.ts

export declare const SliderContext: import("@hanzogui/web").StyledContext<SliderContextValue>;

@hanzogui/slider/types/constants.d.ts

export declare const SliderFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/slider/types/SliderImpl.d.ts

export interface SliderHorizontalProps extends SliderOrientationProps {
    dir?: Direction;
}

@hanzogui/slider/types/types.d.ts

export interface SliderProps extends Omit<SliderHorizontalProps, keyof SliderOrientationPrivateProps | 'defaultValue'>, SliderEventProps {
    size?: SizeTokens;
    name?: string;
    disabled?: boolean;
    orientation?: React.AriaAttributes['aria-orientation'];
    dir?: Direction;
    min?: number;
    max?: number;
    step?: number;
    minStepsBetweenThumbs?: number;
    value?: number[];
    defaultValue?: number[];
    onValueChange?(value: number[]): void;
}

@hanzogui/slider/types/types.d.ts

declare const SliderThumb: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, "index"> & SliderThumbExtraProps, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & SliderThumbExtraProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/slider/types/Slider.d.ts

export interface SliderThumbExtraProps {
    index?: number;
}

@hanzogui/slider/types/Slider.d.ts

export declare const SliderThumbFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/slider/types/Slider.d.ts

export interface SliderThumbProps extends SizableStackProps, SliderThumbExtraProps {
}

@hanzogui/slider/types/Slider.d.ts

declare const SliderTrack: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "bordered" | "chromeless" | "circular" | "elevate" | "elevation" | "fullscreen" | "size" | "transparent" | "unstyled" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | …

@hanzogui/slider/types/Slider.d.ts

export declare const SliderTrackFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    orientation?: "horizontal" | "vertical" | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/slider/types/Slider.d.ts

export type SliderTrackProps = SizableStackProps;

@hanzogui/slider/types/types.d.ts

export interface SliderVerticalProps extends SliderOrientationProps {
    dir?: Direction;
}

@hanzogui/slider/types/types.d.ts

export type SnapPointsMode = 'percent' | 'constant' | 'fit' | 'mixed';

@hanzogui/sheet/types/types.d.ts

export declare function spacedChildren(props: SpacedChildrenProps): React.ReactNode;

@hanzogui/spacer/types/spacedChildren.d.ts

export type SpacedChildrenProps = {
    isZStack?: boolean;
    children?: React.ReactNode;
    space?: SpaceValue;
    spaceFlex?: boolean | number;
    direction?: SpaceDirection;
    separator?: React.ReactNode;
    ensureKeys?: boolean;
    debug?: DebugProp;
};

@hanzogui/spacer/types/types.d.ts

export type SpaceDirection = 'vertical' | 'horizontal' | 'both';

@hanzogui/spacer/types/types.d.ts

export type SpaceProps = {
    space?: SpaceTokens | number;
    spaceDirection?: SpaceDirection;
    separator?: React.ReactNode;
    flex?: SpaceTokens | number | boolean;
};

@hanzogui/spacer/types/types.d.ts

export declare const Spacer: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    direction?: "both" | "horizontal" | "vertical" | undefined;
    size?: `$${string}` | `$${number}` | SizeTokens | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/spacer/types/Spacer.d.ts

export declare const Span: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Emphasis.d.ts

export declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<any>>;

@hanzogui/spinner/types/Spinner.d.ts

export type SpinnerProps = Omit<YStackProps, 'children'> & {
    size?: 'small' | 'large';
    color?: (ColorTokens | ThemeTokens | (string & {})) | null;
};

@hanzogui/spinner/types/Spinner.d.ts

export declare const Square: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    memo: true;
}>;

@hanzogui/shapes/types/Square.d.ts

export type SquareProps = GetProps<typeof Square>;

@hanzogui/shapes/types/Square.d.ts

export interface StackVariants {
    /**
     * @deprecated use `inset: 0, position: 'absolute'` instead
     */
    fullscreen?: boolean;
    elevation?: number | SizeTokens;
}

@hanzogui/stacks/types/Stacks.d.ts

export declare const Strong: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/web").TextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/text/types/Emphasis.d.ts

export type StyleObject = [
    property: string,
    value: any,
    identifier: string,
    pseudo: 'hover' | 'focus' | 'focus-visible' | 'focus-within' | 'active' | undefined,
    rules: string[]
];

@hanzogui/helpers/types/types.d.ts

export declare const StyleObjectIdentifier = 2;

@hanzogui/helpers/types/types.d.ts

export declare const StyleObjectProperty = 0;

@hanzogui/helpers/types/types.d.ts

export declare const StyleObjectPseudo = 3;

@hanzogui/helpers/types/types.d.ts

export declare const StyleObjectRules = 4;

@hanzogui/helpers/types/types.d.ts

export declare const StyleObjectValue = 1;

@hanzogui/helpers/types/types.d.ts

export declare const stylePropsAll: {
    gridAutoColumns: boolean;
    gridAutoRows: boolean;
    gridTemplateColumns: boolean;
    gridTemplateRows: boolean;
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
    backgroundAttachment?: boolean | undefined;
    backgroundBlendMode?: boolean | undefined;
    backgroundClip?: boolean | undefined;
    backgroundOrigin?: boolean | undefined;
    backgroundRepeat?: boolean | undefined;
    borderBottomStyle?: boolean | undefined;
    borderLeftStyle?: boolean | undefined;
    borderRightStyle?: boolean | undefined;
    borderTopStyle?: boolean | undefined;
    contain?: boolean | undefined;
    containerType?: boolean | undefined;
    content?: boolean | undefined;
    float?: boolean | undefined;
    maskBorderMode?: boolean | undefined;
    maskBorderRepeat?: boolean | …

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const stylePropsText: {
    gridAutoColumns: boolean;
    gridAutoRows: boolean;
    gridTemplateColumns: boolean;
    gridTemplateRows: boolean;
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
    backgroundAttachment?: boolean | undefined;
    backgroundBlendMode?: boolean | undefined;
    backgroundClip?: boolean | undefined;
    backgroundOrigin?: boolean | undefined;
    backgroundRepeat?: boolean | undefined;
    borderBottomStyle?: boolean | undefined;
    borderLeftStyle?: boolean | undefined;
    borderRightStyle?: boolean | undefined;
    borderTopStyle?: boolean | undefined;
    contain?: boolean | undefined;
    containerType?: boolean | undefined;
    content?: boolean | undefined;
    float?: boolean | undefined;
    maskBorderMode?: boolean | undefined;
    maskBorderRepeat?: boolean | …

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const stylePropsTextOnly: {
    whiteSpace?: boolean | undefined;
    wordWrap?: boolean | undefined;
    textOverflow?: boolean | undefined;
    WebkitBoxOrient?: boolean | undefined;
    textDecorationDistance?: boolean | undefined;
    WebkitLineClamp?: boolean | undefined;
    color: boolean;
    textDecorationColor: boolean;
    textShadowColor: boolean;
    fontFamily: boolean;
    fontStyle: boolean;
    fontVariant: boolean;
    textTransform: boolean;
    textAlign: boolean;
    textDecorationLine: boolean;
    textDecorationStyle: boolean;
    userSelect: boolean;
    fontSize: boolean;
    fontWeight: boolean;
    letterSpacing: boolean;
    lineHeight: boolean;
    textShadow: boolean;
    textShadowOffset: boolean;
    textShadowRadius: boolean;
    verticalAlign: boolean;
};

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const stylePropsTransform: {
    x: boolean;
    y: boolean;
    scale: boolean;
    perspective: boolean;
    scaleX: boolean;
    scaleY: boolean;
    skewX: boolean;
    skewY: boolean;
    matrix: boolean;
    rotate: boolean;
    rotateY: boolean;
    rotateX: boolean;
    rotateZ: boolean;
};

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const stylePropsUnitless: {
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
    WebkitLineClamp: boolean;
    lineClamp: boolean;
    animationIterationCount: boolean;
    aspectRatio: boolean;
    borderImageOutset: boolean;
    borderImageSlice: boolean;
    borderImageWidth: boolean;
    columnCount: boolean;
    flex: boolean;
    flexGrow: boolean;
    flexOrder: boolean;
    flexPositive: boolean;
    flexShrink: boolean;
    flexNegative: boolean;
    fontWeight: boolean;
    opacity: boolean;
    order: boolean;
    orphans: boolean;
    tabSize: boolean;
    widows: boolean;
    zIndex: boolean;
    zoom: boolean;
    scale: boolean;
    scaleX: boolean;
    scaleY: boolean;
    scaleZ: boolean;
    shadowOpacity: boolean;
};

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const stylePropsView: {
    gridAutoColumns: boolean;
    gridAutoRows: boolean;
    gridTemplateColumns: boolean;
    gridTemplateRows: boolean;
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
    backgroundAttachment?: boolean | undefined;
    backgroundBlendMode?: boolean | undefined;
    backgroundClip?: boolean | undefined;
    backgroundOrigin?: boolean | undefined;
    backgroundRepeat?: boolean | undefined;
    borderBottomStyle?: boolean | undefined;
    borderLeftStyle?: boolean | undefined;
    borderRightStyle?: boolean | undefined;
    borderTopStyle?: boolean | undefined;
    contain?: boolean | undefined;
    containerType?: boolean | undefined;
    content?: boolean | undefined;
    float?: boolean | undefined;
    maskBorderMode?: boolean | undefined;
    maskBorderRepeat?: boolean | …

@hanzogui/helpers/types/validStyleProps.d.ts

export type SwipeDirection = 'vertical' | 'up' | 'down' | 'horizontal' | 'left' | 'right' | 'auto';

@hanzogui/toast/types/ToastProvider.d.ts

@summary A component that displays a switch that can be used to toggle between two states. @see — Docs https://hanzogui.dev/ui/switch @example ```tsx <Switch id={id} size={props.size} defaultChecked={props.defaultChecked}> <Switch.Thumb transition="quicker" /> </Switch> ```

export declare const Switch: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    unstyled?: boolean | undefined;
}>, "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | "accessibilityLabelledBy" | "accessibilityLanguage" | "accessibilityLargeContentTitle" | …

@hanzogui/switch/types/index.d.ts

export type SwitchBaseProps = ViewProps & SwitchSharedProps;

@hanzogui/switch/types/types.d.ts

export type SwitchComponent = (props: any) => any;

@hanzogui/switch/types/types.d.ts

export type { SwitchExtraProps, SwitchProps, SwitchThumbProps };

@hanzogui/switch/types/createSwitch.d.ts

export declare const SwitchFrame: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    accept: {
        readonly activeStyle: 'style';
    };
}>;

@hanzogui/switch/types/Switch.d.ts

export type SwitchFrameActiveStyleProps = {
    activeStyle?: ViewStyle;
    activeTheme?: string | null;
};

@hanzogui/switch/types/types.d.ts

export type { SwitchExtraProps, SwitchProps, SwitchThumbProps };

@hanzogui/switch/types/createSwitch.d.ts

export type SwitchSharedProps = {
    size?: SizeTokens | number;
    unstyled?: boolean;
};

@hanzogui/switch/types/types.d.ts

export declare const SwitchStyledContext: import("@hanzogui/web").StyledContext<{
    active?: boolean;
    disabled?: boolean;
    frameWidth?: number;
    size?: SizeTokens;
    unstyled?: boolean;
}>;

@hanzogui/switch/types/StyledContext.d.ts

export declare const SwitchThumb: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase & {
    readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }, import("@hanzogui/web").StaticConfigPublic>, {
        accept: {
            readonly activeStyle: 'style';
        };
    }>> | undefined;
}, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: SizeTokens | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    accept: {
        readonly activeStyle: 'style';
    };
}>;

@hanzogui/switch/types/Switch.d.ts

export type SwitchThumbActiveStyleProps = {
    activeStyle?: GetProps<typeof SwitchThumb>;
};

@hanzogui/switch/types/types.d.ts

export type SwitchThumbBaseProps = ViewProps;

@hanzogui/switch/types/types.d.ts

export type SwitchThumbComponent = (props: any) => any;

@hanzogui/switch/types/types.d.ts

export type { SwitchExtraProps, SwitchProps, SwitchThumbProps };

@hanzogui/switch/types/createSwitch.d.ts

type TabLayout = LayoutRectangle;

@hanzogui/tabs/types/createTabs.d.ts

export declare const Tabs: import("react").ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, keyof {
    value?: string;
    defaultValue?: string | undefined;
    onValueChange?: ((value: string) => void) | undefined;
    orientation?: import("@hanzogui/roving-focus").RovingFocusGroupProps['orientation'];
    dir?: import("@hanzogui/roving-focus").RovingFocusGroupProps['dir'];
    activationMode?: 'automatic' | 'manual';
}> & {
    value?: string;
    defaultValue?: string | undefined;
    onValueChange?: ((value: string) => void) | undefined;
    orientation?: import("@hanzogui/roving-focus").RovingFocusGroupProps['orientation'];
    dir?: …

@hanzogui/tabs/types/index.d.ts

type TabsContentProps = TabsContentFrameProps & TabsContentExtraProps;

@hanzogui/tabs/types/createTabs.d.ts

export type TabsContextValue = {
    baseId: string;
    value?: string;
    onChange: (value: string) => void;
    orientation?: TabsProps['orientation'];
    dir?: TabsProps['dir'];
    activationMode?: TabsProps['activationMode'];
    size: SizeTokens;
    registerTrigger: () => void;
    unregisterTrigger: () => void;
    triggersCount: number;
};

@hanzogui/tabs/types/StyledContext.d.ts

type TabsListProps = TabsListFrameProps & {
    /**
     * Whether to loop over after reaching the end or start of the items
     * @default true
     */
    loop?: boolean;
};

@hanzogui/tabs/types/createTabs.d.ts

type TabsProps<Tab = string> = TabsFrameProps & TabsExtraProps<Tab>;

@hanzogui/tabs/types/createTabs.d.ts

export declare const TabsProvider: import("react").Provider<TabsContextValue> & import("react").ProviderExoticComponent<Partial<TabsContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>, useTabsContext: (scope?: string) => TabsContextValue;

@hanzogui/tabs/types/StyledContext.d.ts

type TabsTabProps = TabsTriggerProps;

@hanzogui/tabs/types/createTabs.d.ts

type TabsTriggerLayout = LayoutRectangle;

@hanzogui/tabs/types/createTabs.d.ts

@deprecated use `TabTabsProps` instead

type TabsTriggerProps = TabsTriggerFrameProps & {
    /** The value for the tabs state to be changed to after activation of the trigger */
    value: string;
    /** Used for making custom indicators when trigger interacted with */
    onInteraction?: (type: InteractionType, layout: TabLayout | null) => void;
    /** Custom styles to apply when tab is active */
    activeStyle?: TabsTriggerFrameProps;
    /** Theme to apply when tab is active (use null for no theme) */
    activeTheme?: string | null;
};

@hanzogui/tabs/types/createTabs.d.ts

export declare const Text: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiTextElement, import("@hanzogui/core").RNGuiTextNonStyleProps, import("@hanzogui/web").TextStylePropsBase, {
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzo/gui/types/views/Text.d.ts

A web-aligned textarea component (multi-line input). @see — Docs https://hanzogui.dev/ui/inputs#textarea

export declare const TextArea: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & Omit<import("react").InputHTMLAttributes<HTMLInputElement>, "children" | "className" | "color" | "fontFamily" | "fontSize" | "fontStyle" | "fontWeight" | "letterSpacing" | "size" | "style" | "textAlign" | "textTransform" | ("autoCapitalize" | "autoCorrect" | "spellCheck")> & {
    color?: "unset" | import("@hanzogui/web").GetThemeValueForKey<"color"> | import("react-native").OpaqueColorValue | undefined;
    fontFamily?: "unset" | import("@hanzogui/web").GetThemeValueForKey<"fontFamily"> | undefined;
    fontSize?: "unset" | import("@hanzogui/web").GetThemeValueForKey<"fontSize"> | undefined;
    fontStyle?: "italic" | "normal" | "unset" | undefined;
    fontWeight?: "unset" | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | import("@hanzogui/web").GetThemeValueForKey<"fontWeight"> | undefined;
    letterSpacing?: "unset" | import("@hanzogui/web").GetThemeValueForKey<"letterSpacing"> | undefined;
    textAlign?: "auto" | "center" | "justify" | "left" | "right" | "unset" | undefined;
    …

@hanzogui/input/types/TextArea.d.ts

export type TextAreaProps = GetProps<typeof TextArea>;

@hanzogui/input/types/TextArea.d.ts

export declare const textAreaSizeVariant: SizeVariantSpreadFunction<any>;

@hanzogui/input/types/shared.d.ts

export type TextContextStyles = {
    color?: SizableTextProps['color'];
    fontWeight?: SizableTextProps['fontWeight'];
    fontSize?: SizableTextProps['fontSize'];
    fontFamily?: SizableTextProps['fontFamily'];
    fontStyle?: SizableTextProps['fontStyle'];
    letterSpacing?: SizableTextProps['letterSpacing'];
    textAlign?: SizableTextProps['textAlign'];
    ellipsis?: SizableTextProps['ellipsis'];
    maxFontSizeMultiplier?: number;
};

@hanzogui/text/types/types.d.ts

export type TextParentStyles = TextContextStyles & {
    textProps?: Partial<SizableTextProps>;
    noTextWrap?: boolean;
};

@hanzogui/text/types/types.d.ts

export declare const ThemeableStack: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    transparent?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/stacks/types/ThemeableStack.d.ts

export type ThemeableStackProps = GetProps<typeof ThemeableStack>;

@hanzogui/stacks/types/ThemeableStack.d.ts

export declare const themeableVariants: {
    readonly circular: {
        true: (_: any, { props, tokens }: {
            props: any;
            tokens: any;
        }) => {
            borderRadius: number;
            padding: number;
        } | {
            borderRadius: number;
            padding: number;
            width: any;
            height: any;
            maxWidth: any;
            maxHeight: any;
            minWidth: any;
            minHeight: any;
        };
    };
    readonly elevate: {
        true: (_: boolean, extras: any) => any;
    };
    readonly bordered: {
        readonly true: typeof bordered;
    };
    readonly transparent: {
        readonly true: {
            readonly backgroundColor: 'transparent';
        };
    };
    readonly chromeless: {
        readonly true: {
            backgroundColor: string;
            borderColor: string;
            shadowColor: string;
            hoverStyle: {
                borderColor: string;
            };
        };
        readonly all: {
            readonly backgroundColor: string;
            readonly borderColor: string;
            readonly shadowColor: string;
            readonly hoverStyle: …

@hanzogui/stacks/types/ThemeableStack.d.ts

declare const Thumb: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, "index"> & SliderThumbExtraProps, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & SliderThumbExtraProps, import("@hanzogui/web").StackStyleBase, {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: number | SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/slider/types/Slider.d.ts

declare const Toast: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, keyof ToastExtraProps> & ToastExtraProps & React.RefAttributes<GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}>, keyof ToastExtraProps> & ToastExtraProps, GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & ToastExtraProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    unstyled?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic> & Omit<import("@hanzogui/web").StaticConfigPublic, "staticConfig" | "styleable"> & {
    __tama: …

@hanzogui/toast/types/Toast.d.ts

type ToastActionProps = ScopedProps<ToastCloseProps & {
    /**
     * A short description for an alternate way to carry out the action. For screen reader users
     * who will not be able to navigate to the button easily/quickly.
     * @example <ToastAction altText="Goto account settings to updgrade">Upgrade</ToastAction>
     * @example <ToastAction altText="Undo (Alt+U)">Undo</ToastAction>
     */
    altText: string;
}>;

@hanzogui/toast/types/Toast.d.ts

type ToastCloseProps = ScopedProps<ToastCloseFrameProps & {}>;

@hanzogui/toast/types/Toast.d.ts

type ToastDescriptionProps = GetProps<typeof ToastDescription>;

@hanzogui/toast/types/Toast.d.ts

export type { CustomData, ToastActionProps, ToastCloseProps, ToastDescriptionProps, NativePlatform as ToastNativePlatform, NativeValue as ToastNativeValue, ToastProps, ToastProviderProps, ToastTitleProps, ToastViewportProps, };

@hanzogui/toast/types/Toast.d.ts

export type { CustomData, ToastActionProps, ToastCloseProps, ToastDescriptionProps, NativePlatform as ToastNativePlatform, NativeValue as ToastNativeValue, ToastProps, ToastProviderProps, ToastTitleProps, ToastViewportProps, };

@hanzogui/toast/types/Toast.d.ts

export type { CustomData, ToastActionProps, ToastCloseProps, ToastDescriptionProps, NativePlatform as ToastNativePlatform, NativeValue as ToastNativeValue, ToastProps, ToastProviderProps, ToastTitleProps, ToastViewportProps, };

@hanzogui/toast/types/Toast.d.ts

export { Toast, ToastProvider, ToastViewport, useToast, useToastController, useToastState, };

@hanzogui/toast/types/Toast.d.ts

export type { CustomData, ToastActionProps, ToastCloseProps, ToastDescriptionProps, NativePlatform as ToastNativePlatform, NativeValue as ToastNativeValue, ToastProps, ToastProviderProps, ToastTitleProps, ToastViewportProps, };

@hanzogui/toast/types/Toast.d.ts

type ToastTitleProps = GetProps<typeof ToastTitle>;

@hanzogui/toast/types/Toast.d.ts

export { Toast, ToastProvider, ToastViewport, useToast, useToastController, useToastState, };

@hanzogui/toast/types/Toast.d.ts

export type { CustomData, ToastActionProps, ToastCloseProps, ToastDescriptionProps, NativePlatform as ToastNativePlatform, NativeValue as ToastNativeValue, ToastProps, ToastProviderProps, ToastTitleProps, ToastViewportProps, };

@hanzogui/toast/types/Toast.d.ts

declare const ToggleGroup: React.ForwardRefExoticComponent<ScopedProps<ToggleGroupProps> & React.RefAttributes<GuiElement>> & {
    Item: import("@hanzogui/web").GuiComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase & {
        readonly activeStyle?: Partial<import("@hanzogui/web").InferStyleProps<import("@hanzogui/web").GuiComponent<import("@hanzogui/web").ViewProps, GuiElement, import("@hanzogui/web").StackNonStyleProps, import("@hanzogui/web").StackStyleBase, {}, {}>, {
            accept: {
                readonly activeStyle: 'style';
            };
        }>> | undefined;
    }, {
        defaultActiveStyle?: boolean | undefined;
        size?: number | import("@hanzogui/web").SizeTokens | undefined;
        unstyled?: boolean | undefined;
    }>, "__scopeToggleGroup" | "accessibilityActions" | "accessibilityElementsHidden" | "accessibilityHint" | "accessibilityIgnoresInvertColors" | "accessibilityLabel" | "accessibilityLabelledBy" | "accessibilityLanguage" | "accessibilityLargeContentTitle" | "accessibilityLiveRegion" | "accessibilityRespondsToUserInteraction" | "accessibilityRole" | …

@hanzogui/toggle-group/types/ToggleGroup.d.ts

type ToggleGroupItemProps = GetProps<typeof ToggleFrame> & {
    value: string;
    id?: string;
    disabled?: boolean;
};

@hanzogui/toggle-group/types/ToggleGroup.d.ts

interface ToggleGroupMultipleProps extends ToggleGroupImplMultipleProps {
    type: 'multiple';
}

@hanzogui/toggle-group/types/ToggleGroup.d.ts

type ToggleGroupProps = ToggleGroupSingleProps | ToggleGroupMultipleProps;

@hanzogui/toggle-group/types/ToggleGroup.d.ts

interface ToggleGroupSingleProps extends ToggleGroupImplSingleProps {
    type: 'single';
}

@hanzogui/toggle-group/types/ToggleGroup.d.ts

export declare const tokenCategories: {
    radius: {
        borderRadius: boolean;
        borderTopLeftRadius: boolean;
        borderTopRightRadius: boolean;
        borderBottomLeftRadius: boolean;
        borderBottomRightRadius: boolean;
        borderStartStartRadius: boolean;
        borderStartEndRadius: boolean;
        borderEndStartRadius: boolean;
        borderEndEndRadius: boolean;
    };
    size: {
        width: boolean;
        height: boolean;
        minWidth: boolean;
        minHeight: boolean;
        maxWidth: boolean;
        maxHeight: boolean;
        blockSize: boolean;
        minBlockSize: boolean;
        maxBlockSize: boolean;
        inlineSize: boolean;
        minInlineSize: boolean;
        maxInlineSize: boolean;
    };
    zIndex: {
        zIndex: boolean;
    };
    color: {
        color: boolean;
        textDecorationColor: boolean;
        textShadowColor: boolean;
        backgroundColor: boolean;
        borderColor: boolean;
        borderBlockStartColor: boolean;
        borderBlockEndColor: boolean;
        borderBlockColor: boolean;
        borderBottomColor: boolean;
        borderInlineColor: boolean;
        …

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const Tooltip: React.ForwardRefExoticComponent<Omit<PopperProps & {
    open?: boolean;
    unstyled?: boolean;
    children?: React.ReactNode;
    onOpenChange?: (open: boolean) => void;
    focus?: {
        enabled?: boolean;
        visibleOnly?: boolean;
    };
    groupId?: string;
    restMs?: number;
    delay?: number | {
        open?: number;
        close?: number;
    };
    disableAutoCloseOnScroll?: boolean;
    /**
     * z-index for the tooltip portal. Use this when tooltips need to appear
     * above other portaled content like dialogs.
     */
    zIndex?: number;
}, "scope"> & {
    scope?: TooltipScopes;
} & React.RefAttributes<unknown>> & {
    Anchor: React.ForwardRefExoticComponent<Omit<PopoverAnchorProps, "scope"> & {
        scope?: TooltipScopes;
    } & React.RefAttributes<unknown>>;
    Arrow: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
        elevation?: number | SizeTokens | undefined;
        fullscreen?: boolean | undefined;
    }>, keyof import("@hanzogui/stacks").StackVariants> & …

@hanzogui/tooltip/types/Tooltip.d.ts

export type TooltipContentProps = ScopedProps<PopoverContentProps>;

@hanzogui/tooltip/types/Tooltip.d.ts

export declare const TooltipGroup: ({ children, delay, preventAnimation, timeoutMs, }: {
    children?: any;
    delay: Delay;
    preventAnimation?: boolean;
    timeoutMs?: number;
}) => React.JSX.Element;

@hanzogui/tooltip/types/Tooltip.d.ts

export type TooltipProps = ScopedProps<PopperProps & {
    open?: boolean;
    unstyled?: boolean;
    children?: React.ReactNode;
    onOpenChange?: (open: boolean) => void;
    focus?: {
        enabled?: boolean;
        visibleOnly?: boolean;
    };
    groupId?: string;
    restMs?: number;
    delay?: number | {
        open?: number;
        close?: number;
    };
    disableAutoCloseOnScroll?: boolean;
    /**
     * z-index for the tooltip portal. Use this when tooltips need to appear
     * above other portaled content like dialogs.
     */
    zIndex?: number;
}>;

@hanzogui/tooltip/types/Tooltip.d.ts

export type TooltipScopes = string;

@hanzogui/tooltip/types/Tooltip.d.ts

export declare const TooltipSimple: React.FC<TooltipSimpleProps>;

@hanzogui/tooltip/types/TooltipSimple.d.ts

export type TooltipSimpleProps = TooltipProps & {
    disabled?: boolean;
    label?: React.ReactNode;
    children?: React.ReactNode;
    contentProps?: SizableStackProps;
};

@hanzogui/tooltip/types/TooltipSimple.d.ts

declare const Track: React.ForwardRefExoticComponent<Omit<import("@hanzogui/core").RNGuiViewNonStyleProps, "bordered" | "chromeless" | "circular" | "elevate" | "elevation" | "fullscreen" | "size" | "transparent" | "unstyled" | keyof import("@hanzogui/web").StackStyleBase> & import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: import("@hanzogui/web").SizeTokens | undefined;
    transparent?: boolean | undefined;
    unstyled?: boolean | undefined;
} & import("@hanzogui/web").WithShorthands<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase>> & import("@hanzogui/web").WithPseudoProps<import("@hanzogui/web").WithThemeValues<import("@hanzogui/web").StackStyleBase> & {
    bordered?: boolean | undefined;
    chromeless?: "all" | boolean | undefined;
    circular?: boolean | undefined;
    elevate?: boolean | undefined;
    elevation?: number | …

@hanzogui/slider/types/Slider.d.ts

export interface UnregisterHostAction {
    type: ACTIONS;
    hostName: string;
}

@hanzogui/portal/types/GorhomPortal.d.ts

export declare function Unspaced(props: {
    children?: any;
}): any;
export declare namespace Unspaced {
    var _a: boolean;
    export { _a as isUnspaced };
}

@hanzogui/spacer/types/Unspaced.d.ts

export declare function getGestureHandlerState(): GestureState;

@hanzogui/sheet/types/gestureState.d.ts

export declare function isGestureHandlerEnabled(): boolean;

@hanzogui/sheet/types/gestureState.d.ts

export declare function updateTheme({ name, theme, }: {
    name: ThemeName | (string & {});
    theme: Partial<Record<keyof ThemeDefinition, any>>;
}): {
    themeRaw: import("@hanzogui/web").ThemeParsed;
    theme: {};
    cssRules: string[];
} | undefined;

@hanzogui/theme/types/updateTheme.d.ts

export declare const useAdaptContext: (scope?: string) => AdaptParentContextI;

@hanzogui/adapt/types/Adapt.d.ts

export declare const useAdaptIsActive: (scope?: string) => boolean;

@hanzogui/adapt/types/Adapt.d.ts

A custom hook that composes multiple refs Accepts callback refs and RefObject(s)

export declare function useComposedRefs<T>(...refs: PossibleRef<T>[]): (node: T) => void;

@hanzogui/compose-refs/types/compose-refs.d.ts

export declare function useControllableState<T>({ prop, defaultProp, onChange, strategy, preventUpdate, transition, }: {
    prop?: T | undefined;
    defaultProp: T;
    onChange?: ChangeCb<T>;
    strategy?: 'prop-wins' | 'most-recent-wins';
    preventUpdate?: boolean;
    transition?: boolean;
}): [T, React.Dispatch<React.SetStateAction<T>>];

@hanzogui/use-controllable-state/types/useControllableState.d.ts

export declare const useCurrentColor: (colorProp: ColorProp) => any;

@hanzogui/component-helpers/types/useCurrentColor.d.ts

export declare function useDebounce<A extends (...args: any) => any | undefined | null, DebouncedFn extends A & {
    cancel: () => void;
}>(fn: A, wait: number, options?: DebounceSettings, mountArgs?: any[]): DebouncedFn;

@hanzogui/use-debounce/types/index.d.ts

Returns a value once it stops changing after "amt" time. Note: you may need to memo or this will keep re-rendering

export declare function useDebounceValue<A>(val: A, amt?: number): A;

@hanzogui/use-debounce/types/index.d.ts

export declare const useDialogContext: (scope?: string) => DialogContextValue, DialogProvider: React.Provider<DialogContextValue> & React.ProviderExoticComponent<Partial<DialogContextValue> & {
    children?: React.ReactNode;
    scope?: string;
}>;

@hanzogui/dialog/types/Dialog.d.ts

export declare const useFloatingContext: ({ open, setOpen, disable, disableFocus, hoverable, role: roleProp, focus: focusProp, groupId, delay: delayProp, restMs: restMsProp, }: UseFloatingContextOptions) => (props?: UseFloatingOptions) => any;

@hanzogui/popover/types/useFloatingContext.d.ts

export type UseFloatingContextOptions = {
    open: boolean;
    setOpen: (val: boolean, type?: string) => void;
    disable?: boolean;
    disableFocus?: boolean;
    hoverable?: boolean | Record<string, any>;
    role?: 'dialog' | 'tooltip';
    focus?: Record<string, any>;
    groupId?: string;
    delay?: Delay;
    restMs?: number;
};

@hanzogui/popover/types/useFloatingContext.d.ts

export declare function useForceUpdate(): () => void;

@hanzogui/use-force-update/types/index.d.ts

export declare const useFormContext: (scope?: string) => FormContextValue, FormProvider: import("react").Provider<FormContextValue> & import("react").ProviderExoticComponent<Partial<FormContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>;

@hanzogui/form/types/Form.d.ts

export declare const useGetThemedIcon: (props: {
    color: ColorProp;
    size: number;
}) => (el: any) => any;

@hanzogui/component-helpers/types/useGetThemedIcon.d.ts

export declare const useGroupItem: (childrenProps: {
    disabled?: boolean;
}, forcePlacement?: GroupItemProps['forcePlacement'], __scopeGroup?: Scope) => {
    disabled: boolean | undefined;
    borderTopLeftRadius?: number | undefined;
    borderTopRightRadius?: number | undefined;
    borderBottomLeftRadius?: number | undefined;
    borderBottomRightRadius?: number | undefined;
};

@hanzogui/group/types/Group.d.ts

Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present. There is no `safeToRemove` function.

export declare function useIsPresent(): boolean;

@hanzogui/use-presence/types/usePresence.d.ts

export declare const useLabelContext: (element?: HTMLElement | null) => string | undefined;

@hanzogui/label/types/Label.d.ts

Creates a ref for native TextInput components. Returns both ref and composedRef for component usage. @example ```tsx const { ref, composedRef } = useNativeInputRef(forwardedRef) // ref.current is typed as TextInput ```

export declare function useNativeInputRef(forwardedRef?: React.ForwardedRef<any>): {
    ref: React.RefObject<TextInput | null>;
    composedRef: (node: TextInput | null) => void;
};

@hanzogui/element/types/useNativeRef.d.ts

Creates a ref for native-only code that properly types to View. Returns both ref and composedRef for component usage. @example ```tsx const { ref, composedRef } = useNativeRef(forwardedRef) // ref.current is typed as View ```

export declare function useNativeRef(forwardedRef?: React.ForwardedRef<any>): {
    ref: React.RefObject<import("react-native").View | null>;
    composedRef: (node: import("react-native").View | null) => void;
};

@hanzogui/element/types/useNativeRef.d.ts

export declare const usePopoverContext: (scope?: string) => PopoverContextValue;

@hanzogui/popover/types/Popover.d.ts

Read reactive popover open state from the popover context.

export declare function usePopoverOpen(scope?: string): boolean;

@hanzogui/popover/types/Popover.d.ts

export declare const usePopoverTriggerContext: (scope?: string) => PopoverTriggerContextValue;

@hanzogui/popover/types/Popover.d.ts

Hook to set up trigger registration/isolation logic. Used internally by Popover and can be used by Tooltip.

export declare function usePopoverTriggerSetup(open: boolean): {
    setActiveTrigger: (id: string | null) => void;
    registerTrigger: (id: string, setOpenState: PopoverTriggerStateSetter) => void;
    unregisterTrigger: (id: string) => void;
};

@hanzogui/popover/types/Popover.d.ts

export declare const usePopperContext: (scope?: string) => PopperContextValue, PopperProviderFast: React.Provider<PopperContextValue> & React.ProviderExoticComponent<Partial<PopperContextValue> & {
    children?: React.ReactNode;
    scope?: string;
}>;

@hanzogui/popper/types/Popper.d.ts

export declare const usePopperContextSlow: (scope?: string) => PopperContextSlowValue, PopperProviderSlow: React.Provider<PopperContextSlowValue> & React.ProviderExoticComponent<Partial<PopperContextSlowValue> & {
    children?: React.ReactNode;
    scope?: string;
}>;

@hanzogui/popper/types/Popper.d.ts

export declare const usePortal: (hostName?: string) => {
    registerHost: () => void;
    deregisterHost: () => void;
    addPortal: (name: string, node: ReactNode) => void;
    updatePortal: (name: string, node: ReactNode) => void;
    removePortal: (name: string) => void;
};

@hanzogui/portal/types/GorhomPortal.d.ts

export declare function usePresence(): UsePresenceResult;

@hanzogui/use-presence/types/usePresence.d.ts

export declare const SelectProvider: import("react").Provider<SelectContextValue> & import("react").ProviderExoticComponent<Partial<SelectContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>, useSelectContext: (scope?: string) => SelectContextValue;

@hanzogui/select/types/context.d.ts

export declare const SelectItemParentProvider: import("react").Provider<SelectItemParentContextValue> & import("react").ProviderExoticComponent<Partial<SelectItemParentContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>, useSelectItemParentContext: (scope?: string) => SelectItemParentContextValue;

@hanzogui/select/types/context.d.ts

export declare const useSheet: () => import("./useSheetProviderProps.tsx").SheetContextValue;

@hanzogui/sheet/types/useSheet.d.ts

export declare const useSheetController: () => {
    controller: SheetControllerContextValue | null;
    isHidden: boolean | undefined;
    isShowingNonSheet: boolean | undefined;
    disableDrag: boolean | undefined;
};

@hanzogui/sheet/types/useSheetController.d.ts

export declare const useSheetOffscreenSize: ({ snapPoints, position, screenSize, frameSize, snapPointsMode, }: SheetContextValue) => number;

@hanzogui/sheet/types/useSheetOffscreenSize.d.ts

export declare const useSheetOpenState: (props: SheetProps) => {
    open: boolean;
    setOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
    isHidden: boolean | undefined;
    controller: import("./useSheetController.tsx").SheetControllerContextValue | null;
};

@hanzogui/sheet/types/useSheetOpenState.d.ts

web version - no-op, native switch logic handled in .native.ts

export declare function useSwitchNative(_props: UseSwitchNativeProps): React.ReactNode | null;

@hanzogui/switch/types/useSwitchNative.d.ts

export type UseSwitchNativeProps = {
    id?: string;
    disabled?: boolean;
    native?: NativeValue<'mobile' | 'ios' | 'android'>;
    nativeProps?: NativeSwitchProps;
    checked: boolean;
    setChecked: (value: boolean | ((prev: boolean) => boolean)) => void;
};

@hanzogui/switch/types/types.d.ts

export declare const TabsProvider: import("react").Provider<TabsContextValue> & import("react").ProviderExoticComponent<Partial<TabsContextValue> & {
    children?: import("react").ReactNode;
    scope?: string;
}>, useTabsContext: (scope?: string) => TabsContextValue;

@hanzogui/tabs/types/StyledContext.d.ts

export { Toast, ToastProvider, ToastViewport, useToast, useToastController, useToastState, };

@hanzogui/toast/types/Toast.d.ts

export { Toast, ToastProvider, ToastViewport, useToast, useToastController, useToastState, };

@hanzogui/toast/types/Toast.d.ts

export { Toast, ToastProvider, ToastViewport, useToast, useToastController, useToastState, };

@hanzogui/toast/types/Toast.d.ts

export declare const useToggleGroupItem: () => {
    color: string;
    active: boolean;
};

@hanzogui/toggle-group/types/context.d.ts

Creates a ref for web-only code that properly types to HTMLElement. Useful when you need to access HTMLElement-specific properties (like selectionStart) that aren't available on the cross-platform GuiElement type. @example ```tsx const { ref, composedRef } = useWebRef<HTMLInputElement>(forwardedRef) // ref.current is typed as HTMLInputElement // composedRef is for passing to components ```

export declare function useWebRef<T extends GuiElement | HTMLElement>(forwardedRef?: React.ForwardedRef<any>): {
    ref: React.RefObject<T | null>;
    composedRef: (node: T | null) => void;
};

@hanzogui/element/types/useWebRef.d.ts

export declare function useWindowDimensions({ serverValue, }?: {
    serverValue?: WindowSize;
}): WindowSize;

@hanzogui/use-window-dimensions/types/index.d.ts

export declare const validPseudoKeys: {
    enterStyle: boolean;
    exitStyle: boolean;
    hoverStyle: boolean;
    pressStyle: boolean;
    focusStyle: boolean;
    disabledStyle: boolean;
    focusWithinStyle: boolean;
    focusVisibleStyle?: boolean | undefined;
};

@hanzogui/helpers/types/validStyleProps.d.ts

export declare const validStyles: {
    gridAutoColumns: boolean;
    gridAutoRows: boolean;
    gridTemplateColumns: boolean;
    gridTemplateRows: boolean;
    grid: boolean;
    gridArea: boolean;
    gridAutoFlow: boolean;
    gridColumn: boolean;
    gridColumnEnd: boolean;
    gridColumnStart: boolean;
    gridRow: boolean;
    gridRowEnd: boolean;
    gridRowStart: boolean;
    gridTemplate: boolean;
    gridTemplateAreas: boolean;
    justifyItems: boolean;
    justifySelf: boolean;
    placeContent: boolean;
    placeItems: boolean;
    placeSelf: boolean;
    backgroundAttachment?: boolean | undefined;
    backgroundBlendMode?: boolean | undefined;
    backgroundClip?: boolean | undefined;
    backgroundOrigin?: boolean | undefined;
    backgroundRepeat?: boolean | undefined;
    borderBottomStyle?: boolean | undefined;
    borderLeftStyle?: boolean | undefined;
    borderRightStyle?: boolean | undefined;
    borderTopStyle?: boolean | undefined;
    contain?: boolean | undefined;
    containerType?: boolean | undefined;
    content?: boolean | undefined;
    float?: boolean | undefined;
    maskBorderMode?: boolean | undefined;
    maskBorderRepeat?: boolean | …

@hanzogui/helpers/types/validStyleProps.d.ts

export type VariantLabels = string | string[];

@hanzogui/animate-presence/types/types.d.ts

export declare const VisuallyHidden: GuiComponent<TamaDefer, GuiTextElement, TextNonStyleProps, TextStylePropsBase, {
    visible?: boolean | undefined;
    preserveDimensions?: boolean | undefined;
}>;

@hanzogui/visually-hidden/types/VisuallyHidden.d.ts

export declare const webOnlyStylePropsText: {
    whiteSpace: boolean;
    wordWrap: boolean;
    textOverflow: boolean;
    WebkitBoxOrient: boolean;
    textDecorationDistance: boolean;
    WebkitLineClamp: boolean;
};

@hanzogui/helpers/types/webOnlyStyleProps.d.ts

export declare const webOnlyStylePropsView: {
    backgroundAttachment: boolean;
    backgroundBlendMode: boolean;
    backgroundClip: boolean;
    backgroundOrigin: boolean;
    backgroundRepeat: boolean;
    borderBottomStyle: boolean;
    borderLeftStyle: boolean;
    borderRightStyle: boolean;
    borderTopStyle: boolean;
    contain: boolean;
    containerType: boolean;
    content: boolean;
    float: boolean;
    maskBorderMode: boolean;
    maskBorderRepeat: boolean;
    maskClip: boolean;
    maskComposite: boolean;
    maskMode: boolean;
    maskOrigin: boolean;
    maskRepeat: boolean;
    maskType: boolean;
    objectFit: boolean;
    overflowBlock: boolean;
    overflowInline: boolean;
    overflowX: boolean;
    overflowY: boolean;
    pointerEvents: boolean;
    scrollbarWidth: boolean;
    textWrap: boolean;
    touchAction: boolean;
    transformStyle: boolean;
    willChange: boolean;
    transition: boolean;
    backdropFilter: boolean;
    WebkitBackdropFilter: boolean;
    background: boolean;
    borderTop: boolean;
    borderRight: boolean;
    borderBottom: boolean;
    borderLeft: boolean;
    backgroundPosition: boolean;
    backgroundSize: boolean;
    …

@hanzogui/helpers/types/webOnlyStyleProps.d.ts

export declare function withNativeMenu<C extends React.ComponentType<any>, N extends React.ComponentType<any>, CP = GetProps<C>, NP = GetProps<N>>({ Component, NativeComponent, }: {
    Component: C;
    NativeComponent: N;
    scope?: string;
    isRoot?: boolean;
}): React.FC<CP & Partial<Omit<NP, keyof CP>>>;

@hanzogui/create-menu/types/createNativeMenu/withNativeMenu.d.ts

export declare const withStaticProperties: <A extends Function, B extends Record<string, any>>(component: A, staticProps: B) => Combined<A, B>;

@hanzogui/helpers/types/withStaticProperties.d.ts

export declare function wrapChildrenInText(TextComponent: any, propsIn: Props & {
    unstyled?: boolean;
}, extraProps?: Record<string, any>): React.ReactNode[] | (number | bigint | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined>)[];

@hanzogui/text/types/wrapChildrenInText.d.ts

export declare const XGroup: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}>, "__scopeGroup" | keyof GroupExtraProps> & GroupExtraProps & {
    __scopeGroup?: Scope;
} & React.RefAttributes<import("@hanzogui/web").GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}>, "__scopeGroup" | keyof GroupExtraProps> & GroupExtraProps & {
    __scopeGroup?: Scope;
}, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & GroupExtraProps & {
    __scopeGroup?: Scope;
}, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | …

@hanzogui/group/types/Group.d.ts

@summary A view that arranges its children in a horizontal line. @see — Docs https://hanzogui.dev/ui/stacks#xstack-ystack-zstack

export declare const XStack: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/stacks/types/Stacks.d.ts

export type XStackProps = YStackProps;

@hanzogui/stacks/types/Stacks.d.ts

export declare const YGroup: React.ForwardRefExoticComponent<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}>, "__scopeGroup" | keyof GroupExtraProps> & GroupExtraProps & {
    __scopeGroup?: Scope;
} & React.RefAttributes<import("@hanzogui/web").GuiElement>> & import("@hanzogui/web").StaticComponentObject<Omit<import("@hanzogui/web").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | undefined;
    fullscreen?: boolean | undefined;
    size?: any;
    unstyled?: boolean | undefined;
}>, "__scopeGroup" | keyof GroupExtraProps> & GroupExtraProps & {
    __scopeGroup?: Scope;
}, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps & GroupExtraProps & {
    __scopeGroup?: Scope;
}, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | import("@hanzogui/web").SizeTokens | …

@hanzogui/group/types/Group.d.ts

@summary A view that arranges its children in a vertical line. @see — Docs https://hanzogui.dev/ui/stacks#xstack-ystack-zstack

export declare const YStack: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic>;

@hanzogui/stacks/types/Stacks.d.ts

export type YStackProps = Omit<GetProps<typeof YStack>, keyof StackVariants> & StackVariants;

@hanzogui/stacks/types/Stacks.d.ts

@summary A view that stacks its children on top of each other. @see — Docs https://hanzogui.dev/ui/stacks#xstack-ystack-zstack

export declare const ZStack: import("@hanzogui/web").GuiComponent<import("@hanzogui/web").TamaDefer, import("@hanzogui/web").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/web").StackStyleBase, {
    elevation?: number | SizeTokens | undefined;
    fullscreen?: boolean | undefined;
}, import("@hanzogui/web").StaticConfigPublic & {
    neverFlatten: true;
    isZStack: true;
}>;

@hanzogui/stacks/types/Stacks.d.ts

export type ZStackProps = YStackProps;

@hanzogui/stacks/types/Stacks.d.ts