@spark-ui/components 17.2.2 → 17.2.3-beta.1

package/dist/src/select/SelectGroup.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode, Ref } from 'react';
+interface GroupProps {
+    children: ReactNode;
+    className?: string;
+    ref?: Ref<HTMLOptGroupElement>;
+}
+export declare const Group: {
+    ({ children, ref: forwardedRef, ...props }: GroupProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/select/SelectItem.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'react';
+export interface ItemProps {
+    disabled?: boolean;
+    value: string;
+    children: string;
+    ref?: Ref<HTMLOptionElement>;
+}
+export declare const Item: {
+    ({ disabled, value, children, ref: forwardedRef }: ItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/select/SelectItems.d.ts

@@ -0,0 +1,10 @@
+import { ComponentPropsWithRef, PropsWithChildren } from 'react';
+export declare const styles: (props?: ({
+    state?: "undefined" | "alert" | "error" | "success" | null | undefined;
+    disabled?: boolean | null | undefined;
+    readOnly?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const Items: {
+    ({ children, className, ref, ...rest }: PropsWithChildren<ComponentPropsWithRef<"select">>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/select/SelectItemsGroupContext.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+export interface SelectContextState {
+    groupLabel: string;
+    setGroupLabel: (label: string) => void;
+}
+type SelectContextProps = PropsWithChildren;
+export declare const SelectGroupProvider: ({ children }: SelectContextProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useSelectGroupContext: () => SelectContextState;
+export {};

package/dist/src/select/SelectLabel.d.ts

@@ -0,0 +1,8 @@
+interface LabelProps {
+    children: string;
+}
+export declare const Label: {
+    ({ children }: LabelProps): null;
+    displayName: string;
+};
+export {};

package/dist/src/select/SelectLeadingIcon.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+export declare const LeadingIcon: {
+    ({ children }: {
+        children: ReactElement;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/select/SelectPlaceholder.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'react';
+export interface PlaceholderProps {
+    disabled?: boolean;
+    children: string;
+    ref?: Ref<HTMLOptionElement>;
+}
+export declare const Placeholder: {
+    ({ disabled, children, ref: forwardedRef, }: PlaceholderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/select/SelectTrigger.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode, Ref } from 'react';
+interface TriggerProps {
+    'aria-label'?: string;
+    children: ReactNode;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * This trigger acts as a fake button for the `select` tag.
+ * It is not interactive.
+ */
+export declare const Trigger: {
+    ({ "aria-label": ariaLabel, children, className, ref: forwardedRef, }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/select/SelectTrigger.styles.d.ts

@@ -0,0 +1,5 @@
+export declare const styles: (props?: ({
+    state?: "undefined" | "alert" | "error" | "success" | null | undefined;
+    disabled?: boolean | null | undefined;
+    readOnly?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/src/select/SelectValue.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, Ref } from 'react';
+export interface ValueProps {
+    children?: ReactNode;
+    className?: string;
+    /**
+     * Optional placeholder value for the trigger.
+     * If not specified, the value inside `Select.Placeholder` item will be used.
+     */
+    placeholder?: string;
+    ref?: Ref<HTMLSpanElement>;
+}
+export declare const Value: {
+    ({ children, className, placeholder: customPlaceholder, ref: forwardedRef, }: ValueProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/select/index.d.mts

@@ -0,0 +1,21 @@
+import { Select as Root } from './Select';
+import { SelectProvider, useSelectContext } from './SelectContext';
+import { Group } from './SelectGroup';
+import { Item } from './SelectItem';
+import { Items } from './SelectItems';
+import { Label } from './SelectLabel';
+import { LeadingIcon } from './SelectLeadingIcon';
+import { Placeholder } from './SelectPlaceholder';
+import { Trigger } from './SelectTrigger';
+import { Value } from './SelectValue';
+export { useSelectContext, SelectProvider };
+export declare const Select: typeof Root & {
+    Group: typeof Group;
+    Item: typeof Item;
+    Items: typeof Items;
+    Placeholder: typeof Placeholder;
+    Label: typeof Label;
+    Trigger: typeof Trigger;
+    Value: typeof Value;
+    LeadingIcon: typeof LeadingIcon;
+};

package/dist/src/select/index.d.ts

@@ -0,0 +1,21 @@
+import { Select as Root } from './Select';
+import { SelectProvider, useSelectContext } from './SelectContext';
+import { Group } from './SelectGroup';
+import { Item } from './SelectItem';
+import { Items } from './SelectItems';
+import { Label } from './SelectLabel';
+import { LeadingIcon } from './SelectLeadingIcon';
+import { Placeholder } from './SelectPlaceholder';
+import { Trigger } from './SelectTrigger';
+import { Value } from './SelectValue';
+export { useSelectContext, SelectProvider };
+export declare const Select: typeof Root & {
+    Group: typeof Group;
+    Item: typeof Item;
+    Items: typeof Items;
+    Placeholder: typeof Placeholder;
+    Label: typeof Label;
+    Trigger: typeof Trigger;
+    Value: typeof Value;
+    LeadingIcon: typeof LeadingIcon;
+};

package/dist/src/select/types.d.ts

@@ -0,0 +1,6 @@
+export interface SelectItem {
+    disabled: boolean;
+    value: string;
+    text: string;
+}
+export type ItemsMap = Map<string, SelectItem>;

package/dist/src/select/utils.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement, ReactNode } from 'react';
+import { ItemsMap } from './types';
+export declare const findElement: (children: ReactNode) => (name: string) => ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | undefined;
+export declare const getItemsFromChildren: (children: ReactNode) => ItemsMap;

package/dist/src/skeleton/Skeleton.d.ts

@@ -0,0 +1,17 @@
+import { ComponentPropsWithRef, PropsWithChildren } from 'react';
+import { SkeletonStyleProps } from './Skeleton.styles';
+export interface SkeletonProps extends ComponentPropsWithRef<'div'>, SkeletonStyleProps {
+    /**
+     * Displays an animated light effect.
+     * @default true
+     */
+    isAnimated?: boolean;
+    /**
+     * Adds an accessible fallback label.
+     */
+    label?: string;
+}
+export declare const Skeleton: {
+    ({ isAnimated, label, className, children, ref: forwardedRef, ...rest }: PropsWithChildren<SkeletonProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/skeleton/Skeleton.styles.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const skeletonStyles: (props?: ({
+    isAnimated?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SkeletonStyleProps = ExcludeNull<VariantProps<typeof skeletonStyles>>;

package/dist/src/skeleton/SkeletonItem.d.ts

@@ -0,0 +1,31 @@
+import { ComponentPropsWithRef } from 'react';
+import { SkeletonItemStyleProps } from './SkeletonItem.styles';
+interface SkeletonItemProps extends ComponentPropsWithRef<'div'>, SkeletonItemStyleProps {
+}
+export type SkeletonRectangleProps = Omit<SkeletonItemProps, 'shape'> & {
+    width?: string | number;
+    height?: string | number;
+};
+export type SkeletonCircleProps = Omit<SkeletonItemProps, 'shape'> & {
+    size: string | number;
+};
+export type SkeletonLineProps = Omit<SkeletonItemProps, 'shape'> & {
+    lines?: number;
+    /**
+     * Sets the gaps between group items.
+     */
+    gap?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+};
+export declare const SkeletonRectangle: {
+    ({ width, height, ...rest }: SkeletonRectangleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const SkeletonCircle: {
+    ({ size, ...rest }: SkeletonCircleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const SkeletonLine: {
+    ({ lines, gap: gapProp, className, ...rest }: SkeletonLineProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/skeleton/SkeletonItem.styles.d.ts

@@ -0,0 +1,8 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const skeletonItemStyles: (props?: ({
+    shape?: "circle" | "line" | "rectangle" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const skeletonLineStyles: (props?: ({
+    gap?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SkeletonItemStyleProps = ExcludeNull<VariantProps<typeof skeletonItemStyles>>;

package/dist/src/skeleton/index.d.mts

@@ -0,0 +1,8 @@
+import { Skeleton as Root } from './Skeleton';
+import { SkeletonCircle as Circle, SkeletonLine as Line, SkeletonRectangle as Rectangle } from './SkeletonItem';
+export declare const Skeleton: typeof Root & {
+    Circle: typeof Circle;
+    Line: typeof Line;
+    Rectangle: typeof Rectangle;
+};
+export type { SkeletonProps } from './Skeleton';

package/dist/src/skeleton/index.d.ts

@@ -0,0 +1,8 @@
+import { Skeleton as Root } from './Skeleton';
+import { SkeletonCircle as Circle, SkeletonLine as Line, SkeletonRectangle as Rectangle } from './SkeletonItem';
+export declare const Skeleton: typeof Root & {
+    Circle: typeof Circle;
+    Line: typeof Line;
+    Rectangle: typeof Rectangle;
+};
+export type { SkeletonProps } from './Skeleton';

package/dist/src/slider/Slider.d.ts

@@ -0,0 +1,55 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import { ComponentProps, PropsWithChildren, Ref } from 'react';
+import { SliderRangeVariantsProps } from './SliderTrack.styles';
+export interface SliderProps extends Omit<ComponentProps<typeof BaseSlider.Root>, 'render' | 'orientation' | 'onValueChange' | 'onValueCommitted'>, PropsWithChildren<SliderRangeVariantsProps> {
+    /**
+     * The value of the slider when initially rendered. Use when you do not need to control the state of the slider.
+     */
+    defaultValue?: number;
+    /**
+     * The controlled value of the slider. Must be used in conjunction with `onValueChange`.
+     */
+    value?: number;
+    /**
+     * Event handler called when the value changes.
+     */
+    onValueChange?: (value: number) => void;
+    /**
+     * Event handler called when the value changes at the end of an interaction. Useful when you only need to capture a final value e.g. to update a backend service.
+     */
+    onValueCommit?: (value: number) => void;
+    /**
+     * The name of the slider. Submitted with its owning form as part of a name/value pair.
+     * If wrapped with a FormField with a name, will be inherited from it.
+     */
+    name?: string;
+    /**
+     * When `true`, prevents the user from interacting with the slider.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Sets the slider as interactive or not.
+     */
+    readOnly?: boolean;
+    /**
+     * The minimum value for the range.
+     * @default 0
+     */
+    min?: number;
+    /**
+     * The maximum value for the range.
+     * @default 100
+     */
+    max?: number;
+    /**
+     * The stepping interval.
+     * @default 1
+     */
+    step?: number;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const Slider: {
+    ({ intent, children, className, ref, value: valueProp, defaultValue: defaultValueProp, disabled: disabledProp, readOnly: readOnlyProp, name: nameProp, onValueChange, onValueCommit, min, max, ...rest }: SliderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/Slider.styles.d.ts

@@ -0,0 +1 @@
+export declare const rootStyles: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;

package/dist/src/slider/SliderContext.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+import { SliderProps } from './Slider';
+export type SliderContextInterface = Pick<SliderProps, 'intent' | 'min' | 'max'> & {
+    fieldLabelId?: string;
+    fieldId?: string;
+    onLabelId?: (id: string | undefined) => void;
+    hasValueInThumb: boolean;
+    registerValueInThumb: () => () => void;
+    controlRef: RefObject<HTMLElement | null>;
+    thumbRef: RefObject<HTMLElement | null>;
+};
+export declare const SliderContext: import('react').Context<SliderContextInterface>;
+export declare const useSliderContext: () => SliderContextInterface;

package/dist/src/slider/SliderControl.d.ts

@@ -0,0 +1,7 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import { ComponentProps } from 'react';
+export type SliderControlProps = Omit<ComponentProps<typeof BaseSlider.Control>, 'render'>;
+export declare const SliderControl: {
+    ({ className, ref, ...rest }: SliderControlProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/SliderIndicator.d.ts

@@ -0,0 +1,7 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import { ComponentProps } from 'react';
+export type SliderIndicatorProps = Omit<ComponentProps<typeof BaseSlider.Indicator>, 'render'>;
+export declare const SliderIndicator: {
+    ({ className, ref, ...rest }: SliderIndicatorProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/SliderLabel.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode, Ref } from 'react';
+import { LabelProps } from '../label';
+export interface SliderLabelProps extends LabelProps {
+    /**
+     * Element shown when the input is required inside the label.
+     */
+    requiredIndicator?: ReactNode;
+    ref?: Ref<HTMLLabelElement>;
+}
+export declare const SliderLabel: {
+    ({ htmlFor: htmlForProp, id: idProp, className, children, requiredIndicator, asChild, ref, ...others }: SliderLabelProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/SliderMaxValue.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export interface SliderMaxValueProps {
+    className?: string;
+    children?: (value: number) => ReactNode;
+}
+export declare const SliderMaxValue: import('react').ForwardRefExoticComponent<SliderMaxValueProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/slider/SliderMinValue.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export interface SliderMinValueProps {
+    className?: string;
+    children?: (value: number) => ReactNode;
+}
+export declare const SliderMinValue: import('react').ForwardRefExoticComponent<SliderMinValueProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/src/slider/SliderThumb.d.ts

@@ -0,0 +1,7 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import { ComponentProps, PropsWithChildren } from 'react';
+export type SliderThumbProps = Omit<ComponentProps<typeof BaseSlider.Thumb>, 'render' | 'index'> & PropsWithChildren;
+export declare const SliderThumb: {
+    ({ className, ref: forwardedRef, children, ...rest }: SliderThumbProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/SliderThumb.styles.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const thumbVariants: (props?: ({
+    intent?: "main" | "alert" | "error" | "support" | "accent" | "success" | "info" | "neutral" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SliderThumbVariantsProps = VariantProps<typeof thumbVariants>;

package/dist/src/slider/SliderThumbContext.d.ts

@@ -0,0 +1,5 @@
+export interface SliderThumbContextValue {
+    isInsideThumb: true;
+}
+export declare const SliderThumbContext: import('react').Context<SliderThumbContextValue | null>;
+export declare const useSliderThumbContext: () => SliderThumbContextValue | null;

package/dist/src/slider/SliderTrack.d.ts

@@ -0,0 +1,7 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import { ComponentProps } from 'react';
+export type SliderTrackProps = Omit<ComponentProps<typeof BaseSlider.Track>, 'render'>;
+export declare const SliderTrack: {
+    ({ className, ref, ...rest }: SliderTrackProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/SliderTrack.styles.d.ts

@@ -0,0 +1,6 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const trackVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const rangeVariants: (props?: ({
+    intent?: "main" | "alert" | "error" | "support" | "accent" | "success" | "info" | "neutral" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SliderRangeVariantsProps = VariantProps<typeof rangeVariants>;

package/dist/src/slider/SliderValue.d.ts

@@ -0,0 +1,12 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import { ReactNode, ComponentProps } from 'react';
+export type SliderValueProps = Omit<ComponentProps<typeof BaseSlider.Value>, 'render' | 'children'> & {
+    children?: ReactNode | ((formatted: string, value: number) => ReactNode);
+};
+/**
+ * Normalizes Base UI's (formattedValues, values) to single (formatted, value) for the render prop.
+ */
+export declare const SliderValue: {
+    ({ className, children, ref, ...rest }: SliderValueProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/slider/index.d.mts

@@ -0,0 +1,20 @@
+import { Slider as Root, SliderProps } from './Slider';
+import { SliderControl as Control, SliderControlProps } from './SliderControl';
+import { SliderIndicator as Indicator, SliderIndicatorProps } from './SliderIndicator';
+import { SliderLabel as Label, SliderLabelProps } from './SliderLabel';
+import { SliderMaxValue as MaxValue, SliderMaxValueProps } from './SliderMaxValue';
+import { SliderMinValue as MinValue, SliderMinValueProps } from './SliderMinValue';
+import { SliderThumb as Thumb, SliderThumbProps } from './SliderThumb';
+import { SliderTrack as Track, SliderTrackProps } from './SliderTrack';
+import { SliderValue as Value, SliderValueProps } from './SliderValue';
+export declare const Slider: typeof Root & {
+    Control: typeof Control;
+    Indicator: typeof Indicator;
+    Label: typeof Label;
+    MaxValue: typeof MaxValue;
+    MinValue: typeof MinValue;
+    Thumb: typeof Thumb;
+    Track: typeof Track;
+    Value: typeof Value;
+};
+export type { SliderProps, SliderControlProps, SliderIndicatorProps, SliderLabelProps, SliderMaxValueProps, SliderMinValueProps, SliderThumbProps, SliderTrackProps, SliderValueProps, };

package/dist/src/slider/index.d.ts

@@ -0,0 +1,20 @@
+import { Slider as Root, SliderProps } from './Slider';
+import { SliderControl as Control, SliderControlProps } from './SliderControl';
+import { SliderIndicator as Indicator, SliderIndicatorProps } from './SliderIndicator';
+import { SliderLabel as Label, SliderLabelProps } from './SliderLabel';
+import { SliderMaxValue as MaxValue, SliderMaxValueProps } from './SliderMaxValue';
+import { SliderMinValue as MinValue, SliderMinValueProps } from './SliderMinValue';
+import { SliderThumb as Thumb, SliderThumbProps } from './SliderThumb';
+import { SliderTrack as Track, SliderTrackProps } from './SliderTrack';
+import { SliderValue as Value, SliderValueProps } from './SliderValue';
+export declare const Slider: typeof Root & {
+    Control: typeof Control;
+    Indicator: typeof Indicator;
+    Label: typeof Label;
+    MaxValue: typeof MaxValue;
+    MinValue: typeof MinValue;
+    Thumb: typeof Thumb;
+    Track: typeof Track;
+    Value: typeof Value;
+};
+export type { SliderProps, SliderControlProps, SliderIndicatorProps, SliderLabelProps, SliderMaxValueProps, SliderMinValueProps, SliderThumbProps, SliderTrackProps, SliderValueProps, };

package/dist/src/slider/useSliderValueBoundaries.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+/**
+ * Computes the translateX (in pixels) to apply to the value element so it stays
+ * within the horizontal bounds of the slider control when displayed inside the thumb.
+ *
+ * @param controlRef - Ref to the slider control (track container)
+ * @param thumbRef - Ref to the thumb element
+ * @param valueRef - Ref to the value label element
+ * @param value - Current slider value (0–100 or min–max), used to re-run when thumb moves
+ * @returns translateX in pixels (positive = right, negative = left), or 0 if refs are missing
+ */
+export declare function useSliderValueBoundaries(controlRef: RefObject<HTMLElement | null>, thumbRef: RefObject<HTMLElement | null>, valueRef: RefObject<HTMLElement | null>, value: number): number;

package/dist/src/slot/Slot.d.ts

@@ -0,0 +1,12 @@
+import { Slot as RadixSlot } from 'radix-ui';
+import { HTMLAttributes, PropsWithChildren, ReactNode, Ref } from 'react';
+export declare const Slottable: typeof RadixSlot.Slottable;
+export type SlotProps = PropsWithChildren<HTMLAttributes<HTMLElement>> & {
+    ref?: Ref<HTMLElement>;
+};
+export declare const Slot: ({ ref, ...props }: SlotProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * When using Radix `Slot` component, it will consider its first child to merge its props with.
+ * In some cases, you might need to wrap the top child with additional markup without breaking this behaviour.
+ */
+export declare const wrapPolymorphicSlot: (asChild: boolean | undefined, children: ReactNode, callback: (children: ReactNode) => ReactNode) => ReactNode;

package/dist/src/slot/index.d.mts

@@ -0,0 +1 @@
+export * from './Slot';

package/dist/src/slot/index.d.ts

@@ -0,0 +1 @@
+export * from './Slot';

package/dist/src/snackbar/Snackbar.d.ts

@@ -0,0 +1,29 @@
+import { ToastOptions as SnackBarItemOptions } from '@react-stately/toast';
+import { ReactElement, Ref } from 'react';
+import { SnackbarItemValue } from './SnackbarItem';
+import { SnackbarRegionProps } from './SnackbarRegion';
+export declare const clearSnackbarQueue: () => void;
+export type SnackbarProps = Omit<SnackbarRegionProps, 'state'> & {
+    ref?: Ref<HTMLDivElement>;
+};
+export declare const Snackbar: {
+    ({ ref: forwardedRef, ...props }: SnackbarProps): ReactElement | null;
+    displayName: string;
+};
+export interface AddSnackbarArgs extends SnackbarItemValue, Omit<SnackBarItemOptions, 'timeout'> {
+    /**
+     * Handler that is called when the snackbar is closed, either by the user
+     * or after a timeout.
+     */
+    onClose?: () => void;
+    /**
+     * A timeout to automatically close the snackbar after, in milliseconds.
+     * @default 5000
+     */
+    timeout?: number | null;
+    /**
+     * The priority of the snackbar relative to other snackbars. Larger numbers indicate higher priority.
+     */
+    priority?: number;
+}
+export declare const addSnackbar: ({ onClose, timeout, priority, ...content }: AddSnackbarArgs) => void;

package/dist/src/snackbar/SnackbarItem.d.ts

@@ -0,0 +1,49 @@
+import { ComponentPropsWithRef, PropsWithChildren, ReactNode } from 'react';
+import { SnackbarItemVariantContentProps, SnackbarItemVariantProps } from './SnackbarItem.styles';
+export interface SnackbarItemValue extends SnackbarItemVariantProps {
+    /**
+     * Icon that will be prepended before snackbar message
+     */
+    icon?: ReactNode;
+    message: ReactNode;
+    /**
+     * If `true` snackbar will display a close button
+     * @default false
+     */
+    isClosable?: boolean;
+    /**
+     * A label for the action button within the toast.
+     */
+    actionLabel?: string;
+    /**
+     * Handler that is called when the action button is pressed.
+     */
+    onAction?: () => void;
+    /**
+     * If `true` the action button will be displayed on a new line.
+     * @default false
+     */
+    actionOnNewline?: boolean;
+}
+export interface SnackbarItemProps extends ComponentPropsWithRef<'div'>, SnackbarItemVariantProps, SnackbarItemVariantContentProps {
+    /**
+     * Defines a string value that labels the current element.
+     */
+    'aria-label'?: string;
+    /**
+     * Identifies the element (or elements) that labels the current element.
+     */
+    'aria-labelledby'?: string;
+    /**
+     * Identifies the element (or elements) that describes the object.
+     */
+    'aria-describedby'?: string;
+    /**
+     * Identifies the element (or elements) that provide a detailed, extended description for the object.
+     */
+    'aria-details'?: string;
+}
+export declare const SnackbarItem: {
+    ({ "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, "aria-describedby": ariaDescribedby, "aria-details": ariaDetails, design: designProp, intent: intentProp, actionOnNewline: actionOnNewlineProp, className, children, ref: forwardedRef, ...rest }: PropsWithChildren<SnackbarItemProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/snackbar/SnackbarItem.styles.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const snackbarItemVariant: (props?: ({
+    design?: "filled" | "tinted" | null | undefined;
+    intent?: "main" | "alert" | "error" | "support" | "accent" | "success" | "info" | "neutral" | "inverse" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const snackbarItemVariantContent: (props?: ({
+    actionOnNewline?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SnackbarItemVariantProps = VariantProps<typeof snackbarItemVariant>;
+export type SnackbarItemVariantContentProps = VariantProps<typeof snackbarItemVariantContent>;

package/dist/src/snackbar/SnackbarItemAction.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'react';
+import { ButtonProps } from '../button';
+import { SnackbarItemVariantProps } from './SnackbarItem.styles';
+export type SnackbarItemActionProps = Omit<ButtonProps, 'size' | 'shape' | 'intent'> & SnackbarItemVariantProps & {
+    ref?: Ref<HTMLButtonElement>;
+};
+export declare const SnackbarItemAction: {
+    ({ design: designProp, intent: intentProp, onClick, children, className, ref, ...rest }: SnackbarItemActionProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/snackbar/SnackbarItemClose.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPropsWithRef } from 'react';
+import { IconButtonProps } from '../icon-button';
+import { SnackbarItemVariantProps } from './SnackbarItem.styles';
+export interface SnackbarItemCloseProps extends Omit<ComponentPropsWithRef<'button'>, 'aria-label' | 'disabled'>, Pick<IconButtonProps, 'aria-label'>, SnackbarItemVariantProps {
+}
+export declare const SnackbarItemClose: {
+    ({ design: designProp, intent: intentProp, "aria-label": ariaLabel, onClick, className, ref, ...rest }: SnackbarItemCloseProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};