@ark-ui/solid 1.0.0-beta.3 → 1.0.1

package/types/presence/use-presence.d.ts

@@ -1,4 +1,25 @@
 import * as presence from '@zag-js/presence';
 import type { Optional } from '../types';
-export type UsePresenceProps = Optional<presence.Context, 'present'>;
-export declare const usePresence: (props: UsePresenceProps) => import("solid-js").Accessor<presence.Api>;
+export interface UsePresenceProps extends Optional<presence.Context, 'present'> {
+    /**
+     * Whether to enable lazy mounting
+     * @default false
+     */
+    lazyMount?: boolean;
+    /**
+     * Whether to unmount on exit.
+     * @default false
+     */
+    unmountOnExit?: boolean;
+}
+export interface UsePresenceReturn extends ReturnType<typeof usePresence> {
+}
+export declare const usePresence: (props: UsePresenceProps) => import("solid-js").Accessor<{
+    isUnmounted: boolean;
+    isPresent: boolean;
+    presenceProps: {
+        ref: (node: HTMLElement) => void;
+        hidden: boolean;
+        'data-state': string;
+    };
+}>;

package/types/radio-group/radio-group-context.d.ts

@@ -1,3 +1,4 @@
 import { type UseRadioGroupReturn } from './use-radio-group';
-export type RadioGroupContext = UseRadioGroupReturn;
-export declare const RadioGroupProvider: import("solid-js").ContextProviderComponent<UseRadioGroupReturn>, useRadioGroupContext: () => UseRadioGroupReturn;
+export interface RadioGroupContext extends UseRadioGroupReturn {
+}
+export declare const RadioGroupProvider: import("solid-js").ContextProviderComponent<RadioGroupContext>, useRadioGroupContext: () => RadioGroupContext;

package/types/radio-group/radio-group-indicator.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type RadioGroupIndicatorProps = HTMLArkProps<'div'>;
+export interface RadioGroupIndicatorProps extends HTMLArkProps<'div'> {
+}
 export declare const RadioGroupIndicator: (props: RadioGroupIndicatorProps) => import("solid-js").JSX.Element;

package/types/radio-group/radio-group-item-context.d.ts

@@ -1,3 +1,4 @@
 import type { ItemProps } from '@zag-js/radio-group';
-export type RadioGroupItemContext = ItemProps;
-export declare const RadioProvider: import("solid-js").ContextProviderComponent<ItemProps>, useRadioGroupItemContext: () => ItemProps;
+export interface RadioGroupItemContext extends ItemProps {
+}
+export declare const RadioProvider: import("solid-js").ContextProviderComponent<RadioGroupItemContext>, useRadioGroupItemContext: () => RadioGroupItemContext;

package/types/radio-group/radio-group-item-control.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type RadioGroupItemControlProps = HTMLArkProps<'div'>;
+export interface RadioGroupItemControlProps extends HTMLArkProps<'div'> {
+}
 export declare const RadioGroupItemControl: (props: RadioGroupItemControlProps) => import("solid-js").JSX.Element;

package/types/radio-group/radio-group-item-text.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type RadioGroupItemTextProps = HTMLArkProps<'span'>;
+export interface RadioGroupItemTextProps extends HTMLArkProps<'span'> {
+}
 export declare const RadioGroupItemText: (props: RadioGroupItemTextProps) => import("solid-js").JSX.Element;

package/types/radio-group/radio-group-item.d.ts

@@ -1,5 +1,6 @@
 import type { ItemProps } from '@zag-js/radio-group';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-export type RadioGroupItemProps = Assign<HTMLArkProps<'label'>, ItemProps>;
+export interface RadioGroupItemProps extends Assign<HTMLArkProps<'label'>, ItemProps> {
+}
 export declare const RadioGroupItem: (props: RadioGroupItemProps) => import("solid-js").JSX.Element;

package/types/radio-group/radio-group-label.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type RadioGroupLabelProps = HTMLArkProps<'label'>;
+export interface RadioGroupLabelProps extends HTMLArkProps<'label'> {
+}
 export declare const RadioGroupLabel: (props: RadioGroupLabelProps) => import("solid-js").JSX.Element;

package/types/radio-group/radio-group.d.ts

@@ -1,5 +1,6 @@
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 import { type UseRadioGroupProps } from './use-radio-group';
-export type RadioGroupProps = Assign<HTMLArkProps<'div'>, UseRadioGroupProps>;
+export interface RadioGroupProps extends Assign<HTMLArkProps<'div'>, UseRadioGroupProps> {
+}
 export declare const RadioGroup: (props: RadioGroupProps) => import("solid-js").JSX.Element;

package/types/radio-group/use-radio-group.d.ts

@@ -2,6 +2,8 @@ import * as radio from '@zag-js/radio-group';
 import { type PropTypes } from '@zag-js/solid';
 import { type Accessor } from 'solid-js';
 import { type Optional } from '../types';
-export type UseRadioGroupProps = Optional<radio.Context, 'id'>;
-export type UseRadioGroupReturn = Accessor<radio.Api<PropTypes>>;
+export interface UseRadioGroupProps extends Optional<radio.Context, 'id'> {
+}
+export interface UseRadioGroupReturn extends Accessor<radio.Api<PropTypes>> {
+}
 export declare const useRadioGroup: (props: UseRadioGroupProps) => UseRadioGroupReturn;

package/types/rating-group/rating-group-context.d.ts

@@ -1,3 +1,4 @@
 import { type UseRatingGroupReturn } from './use-rating-group';
-export type RatingGroupContext = UseRatingGroupReturn;
-export declare const RatingGroupProvider: import("solid-js").ContextProviderComponent<UseRatingGroupReturn>, useRatingGroupContext: () => UseRatingGroupReturn;
+export interface RatingGroupContext extends UseRatingGroupReturn {
+}
+export declare const RatingGroupProvider: import("solid-js").ContextProviderComponent<RatingGroupContext>, useRatingGroupContext: () => RatingGroupContext;

package/types/rating-group/rating-group-control.d.ts

@@ -1,8 +1,9 @@
-import { type JSX } from 'solid-js/jsx-runtime';
+import { type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-import { type RatingGroupContext } from './rating-group-context';
-export type RatingGroupControlProps = Assign<HTMLArkProps<'div'>, {
-    children: JSX.Element | ((context: RatingGroupContext) => JSX.Element);
-}>;
+import type { UseRatingGroupReturn } from './use-rating-group';
+export interface RatingGroupControlProps extends Assign<HTMLArkProps<'div'>, {
+    children?: JSX.Element | ((api: UseRatingGroupReturn) => JSX.Element);
+}> {
+}
 export declare const RatingGroupControl: (props: RatingGroupControlProps) => JSX.Element;

package/types/rating-group/rating-group-item-context.d.ts

@@ -1,3 +1,5 @@
 import { type ItemState } from '@zag-js/rating-group';
-export type RatingGroupItemContext = ItemState;
-export declare const RatingGroupItemProvider: import("solid-js").ContextProviderComponent<ItemState>, useRatingGroupItemContext: () => ItemState;
+import type { Accessor } from 'solid-js';
+export interface RatingGroupItemContext extends Accessor<ItemState> {
+}
+export declare const RatingGroupItemProvider: import("solid-js").ContextProviderComponent<RatingGroupItemContext>, useRatingGroupItemContext: () => RatingGroupItemContext;

package/types/rating-group/rating-group-item.d.ts

@@ -1,9 +1,9 @@
-import type { ItemProps } from '@zag-js/rating-group';
-import { type JSX } from 'solid-js/jsx-runtime';
+import type { ItemProps, ItemState } from '@zag-js/rating-group';
+import { type Accessor, type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-import { type RatingGroupItemContext } from './rating-group-item-context';
-export type RatingGroupItemProps = Assign<HTMLArkProps<'span'>, ItemProps & {
-    children: (state: RatingGroupItemContext) => JSX.Element | JSX.Element;
-}>;
+export interface RatingGroupItemProps extends Assign<HTMLArkProps<'span'>, {
+    children?: JSX.Element | ((state: Accessor<ItemState>) => JSX.Element);
+}>, ItemProps {
+}
 export declare const RatingGroupItem: (props: RatingGroupItemProps) => JSX.Element;

package/types/rating-group/rating-group-label.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type RatingGroupLabelProps = HTMLArkProps<'label'>;
+export interface RatingGroupLabelProps extends HTMLArkProps<'label'> {
+}
 export declare const RatingGroupLabel: (props: RatingGroupLabelProps) => import("solid-js").JSX.Element;

package/types/rating-group/rating-group.d.ts

@@ -1,5 +1,6 @@
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 import { type UseRatingGroupProps } from './use-rating-group';
-export type RatingGroupProps = Assign<HTMLArkProps<'div'>, UseRatingGroupProps>;
+export interface RatingGroupProps extends Assign<HTMLArkProps<'div'>, UseRatingGroupProps> {
+}
 export declare const RatingGroup: (props: RatingGroupProps) => import("solid-js").JSX.Element;

package/types/rating-group/use-rating-group.d.ts

@@ -2,6 +2,8 @@ import * as rating from '@zag-js/rating-group';
 import { type PropTypes } from '@zag-js/solid';
 import { type Accessor } from 'solid-js';
 import { type Optional } from '../types';
-export type UseRatingGroupProps = Optional<rating.Context, 'id'>;
-export type UseRatingGroupReturn = Accessor<rating.Api<PropTypes>>;
+export interface UseRatingGroupProps extends Optional<rating.Context, 'id'> {
+}
+export interface UseRatingGroupReturn extends Accessor<rating.Api<PropTypes>> {
+}
 export declare const useRatingGroup: (props: UseRatingGroupProps) => UseRatingGroupReturn;

package/types/segment-group/segment-group-context.d.ts

@@ -1,3 +1,4 @@
 import { type UseSegmentGroupReturn } from './use-segment-group';
-export type SegmentGroupContext = UseSegmentGroupReturn;
-export declare const SegmentGroupProvider: import("solid-js").ContextProviderComponent<UseSegmentGroupReturn>, useSegmentGroupContext: () => UseSegmentGroupReturn;
+export interface SegmentGroupContext extends UseSegmentGroupReturn {
+}
+export declare const SegmentGroupProvider: import("solid-js").ContextProviderComponent<SegmentGroupContext>, useSegmentGroupContext: () => SegmentGroupContext;

package/types/segment-group/segment-group-indicator.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SegmentGroupIndicatorProps = HTMLArkProps<'div'>;
+export interface SegmentGroupIndicatorProps extends HTMLArkProps<'div'> {
+}
 export declare const SegmentGroupIndicator: (props: SegmentGroupIndicatorProps) => import("solid-js").JSX.Element;

package/types/segment-group/segment-group-item-control.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SegmentGroupItemControlProps = HTMLArkProps<'div'>;
+export interface SegmentGroupItemControlProps extends HTMLArkProps<'div'> {
+}
 export declare const SegmentGroupItemControl: (props: SegmentGroupItemControlProps) => import("solid-js").JSX.Element;

package/types/segment-group/segment-group-item-text.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SegmentGroupItemTextProps = HTMLArkProps<'span'>;
+export interface SegmentGroupItemTextProps extends HTMLArkProps<'span'> {
+}
 export declare const SegmentGroupItemText: (props: SegmentGroupItemTextProps) => import("solid-js").JSX.Element;

package/types/segment-group/segment-group-item.d.ts

@@ -1,5 +1,6 @@
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 import { type SegmentGroupItemContext } from './segment-group-item-context';
-export type SegmentGroupItemProps = Assign<HTMLArkProps<'label'>, SegmentGroupItemContext>;
+export interface SegmentGroupItemProps extends Assign<HTMLArkProps<'label'>, SegmentGroupItemContext> {
+}
 export declare const SegmentGroupItem: (props: SegmentGroupItemProps) => import("solid-js").JSX.Element;

package/types/segment-group/segment-group-label.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SegmentGroupLabelProps = HTMLArkProps<'label'>;
+export interface SegmentGroupLabelProps extends HTMLArkProps<'label'> {
+}
 export declare const SegmentGroupLabel: (props: SegmentGroupLabelProps) => import("solid-js").JSX.Element;

package/types/segment-group/segment-group.d.ts

@@ -1,5 +1,6 @@
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 import { type UseSegmentGroupProps } from './use-segment-group';
-export type SegmentGroupProps = Assign<HTMLArkProps<'div'>, UseSegmentGroupProps>;
+export interface SegmentGroupProps extends Assign<HTMLArkProps<'div'>, UseSegmentGroupProps> {
+}
 export declare const SegmentGroup: (props: SegmentGroupProps) => import("solid-js").JSX.Element;

package/types/segment-group/use-segment-group.d.ts

@@ -2,6 +2,8 @@ import * as segment from '@zag-js/radio-group';
 import { type PropTypes } from '@zag-js/solid';
 import { type Accessor } from 'solid-js';
 import { type Optional } from '../types';
-export type UseSegmentGroupProps = Optional<segment.Context, 'id'>;
-export type UseSegmentGroupReturn = Accessor<segment.Api<PropTypes>>;
+export interface UseSegmentGroupProps extends Optional<segment.Context, 'id'> {
+}
+export interface UseSegmentGroupReturn extends Accessor<segment.Api<PropTypes>> {
+}
 export declare const useSegmentGroup: (props: UseSegmentGroupProps) => UseSegmentGroupReturn;

package/types/select/select-clear-trigger.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectClearTriggerProps = HTMLArkProps<'button'>;
+export interface SelectClearTriggerProps extends HTMLArkProps<'button'> {
+}
 export declare const SelectClearTrigger: (props: SelectClearTriggerProps) => import("solid-js").JSX.Element;

package/types/select/select-content.d.ts

@@ -1,6 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-import { type PresenceProps } from '../presence';
-import type { Assign } from '../types';
-export interface SelectContentProps extends Assign<HTMLArkProps<'div'>, Omit<PresenceProps, 'fallback'>> {
+export interface SelectContentProps extends HTMLArkProps<'div'> {
 }
 export declare const SelectContent: (props: SelectContentProps) => import("solid-js").JSX.Element;

package/types/select/select-context.d.ts

@@ -1,4 +1,5 @@
 import type { CollectionItem } from '../types';
 import { type UseSelectReturn } from './use-select';
-export type SelectContext<T extends CollectionItem> = UseSelectReturn<T>;
+export interface SelectContext<T extends CollectionItem> extends UseSelectReturn<T> {
+}
 export declare const SelectProvider: import("solid-js").ContextProviderComponent<SelectContext<any>>, useSelectContext: () => SelectContext<any>;

package/types/select/select-control.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectControlProps = HTMLArkProps<'div'>;
+export interface SelectControlProps extends HTMLArkProps<'div'> {
+}
 export declare const SelectControl: (props: SelectControlProps) => import("solid-js").JSX.Element;

package/types/select/select-indicator.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectIndicatorProps = HTMLArkProps<'div'>;
+export interface SelectIndicatorProps extends HTMLArkProps<'div'> {
+}
 export declare const SelectIndicator: (props: SelectIndicatorProps) => import("solid-js").JSX.Element;

package/types/select/select-item-context.d.ts

@@ -1,3 +1,4 @@
 import type { ItemProps } from '@zag-js/select';
-export type SelectItemContext = ItemProps;
+export interface SelectItemContext extends ItemProps {
+}
 export declare const SelectItemProvider: import("solid-js").ContextProviderComponent<SelectItemContext>, useSelectItemContext: () => SelectItemContext;

package/types/select/select-item-group.d.ts

@@ -1,5 +1,6 @@
 import type { ItemGroupProps } from '@zag-js/select';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-export type SelectItemGroupProps = Assign<HTMLArkProps<'div'>, ItemGroupProps>;
+export interface SelectItemGroupProps extends Assign<HTMLArkProps<'div'>, ItemGroupProps> {
+}
 export declare const SelectItemGroup: (props: SelectItemGroupProps) => import("solid-js").JSX.Element;

package/types/select/select-item-indicator.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectItemIndicatorProps = HTMLArkProps<'div'>;
+export interface SelectItemIndicatorProps extends HTMLArkProps<'div'> {
+}
 export declare const SelectItemIndicator: (props: SelectItemIndicatorProps) => import("solid-js").JSX.Element;

package/types/select/select-item-text.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectItemTextProps = HTMLArkProps<'span'>;
+export interface SelectItemTextProps extends HTMLArkProps<'span'> {
+}
 export declare const SelectItemText: (props: SelectItemTextProps) => import("solid-js").JSX.Element;

package/types/select/select-item.d.ts

@@ -1,8 +1,9 @@
 import type { ItemProps, ItemState } from '@zag-js/select';
-import { type JSX } from 'solid-js';
+import { type Accessor, type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-export type SelectItemProps = Assign<HTMLArkProps<'div'>, ItemProps & {
-    children?: JSX.Element | ((state: () => ItemState) => JSX.Element);
-}>;
+export interface SelectItemProps extends Assign<HTMLArkProps<'div'>, {
+    children?: JSX.Element | ((state: Accessor<ItemState>) => JSX.Element);
+}>, ItemProps {
+}
 export declare const SelectItem: (props: SelectItemProps) => JSX.Element;

package/types/select/select-label.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectLabelProps = HTMLArkProps<'label'>;
+export interface SelectLabelProps extends HTMLArkProps<'label'> {
+}
 export declare const SelectLabel: (props: SelectLabelProps) => import("solid-js").JSX.Element;

package/types/select/select-positioner.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectPositionerProps = HTMLArkProps<'div'>;
+export interface SelectPositionerProps extends HTMLArkProps<'div'> {
+}
 export declare const SelectPositioner: (props: SelectPositionerProps) => import("solid-js").JSX.Element;

package/types/select/select-trigger.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SelectTriggerProps = HTMLArkProps<'button'>;
+export interface SelectTriggerProps extends HTMLArkProps<'button'> {
+}
 export declare const SelectTrigger: (props: SelectTriggerProps) => import("solid-js").JSX.Element;

package/types/select/select.d.ts

@@ -1,9 +1,10 @@
-import { type JSX } from 'solid-js/jsx-runtime';
+import { type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
+import { type UsePresenceProps } from '../presence';
 import type { Assign, CollectionItem } from '../types';
-import { type SelectContext } from './select-context';
-import { type UseSelectProps } from './use-select';
-export type SelectProps<T extends CollectionItem> = Assign<HTMLArkProps<'div'>, UseSelectProps<T>> & {
-    children?: JSX.Element | ((context: SelectContext<T>) => JSX.Element);
-};
+import { type UseSelectProps, type UseSelectReturn } from './use-select';
+export interface SelectProps<T extends CollectionItem> extends Assign<Assign<HTMLArkProps<'div'>, {
+    children?: JSX.Element | ((api: UseSelectReturn<T>) => JSX.Element);
+}>, UseSelectProps<T>>, UsePresenceProps {
+}
 export declare const Select: <T extends CollectionItem>(props: SelectProps<T>) => JSX.Element;

package/types/select/use-select.d.ts

@@ -5,5 +5,6 @@ import { type Accessor } from 'solid-js';
 import { type CollectionItem, type Optional } from '../types';
 export interface UseSelectProps<T extends CollectionItem> extends CollectionOptions<T>, Omit<Optional<select.Context<T>, 'id'>, 'collection'> {
 }
-export type UseSelectReturn<T extends CollectionItem> = Accessor<select.Api<PropTypes, T>>;
+export interface UseSelectReturn<T extends CollectionItem> extends Accessor<select.Api<PropTypes, T>> {
+}
 export declare const useSelect: <T extends CollectionItem>(props: UseSelectProps<T>) => UseSelectReturn<T>;

package/types/slider/slider-context.d.ts

@@ -1,3 +1,4 @@
 import { type UseSliderReturn } from './use-slider';
-export type SliderContext = UseSliderReturn;
-export declare const SliderProvider: import("solid-js").ContextProviderComponent<UseSliderReturn>, useSliderContext: () => UseSliderReturn;
+export interface SliderContext extends UseSliderReturn {
+}
+export declare const SliderProvider: import("solid-js").ContextProviderComponent<SliderContext>, useSliderContext: () => SliderContext;

package/types/slider/slider-control.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SliderControlProps = HTMLArkProps<'div'>;
+export interface SliderControlProps extends HTMLArkProps<'div'> {
+}
 export declare const SliderControl: (props: SliderControlProps) => import("solid-js").JSX.Element;

package/types/slider/slider-label.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SliderLabelProps = HTMLArkProps<'label'>;
+export interface SliderLabelProps extends HTMLArkProps<'label'> {
+}
 export declare const SliderLabel: (props: SliderLabelProps) => import("solid-js").JSX.Element;

package/types/slider/slider-marker-group.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SliderMarkerGroupProps = HTMLArkProps<'div'>;
+export interface SliderMarkerGroupProps extends HTMLArkProps<'div'> {
+}
 export declare const SliderMarkerGroup: (props: SliderMarkerGroupProps) => import("solid-js").JSX.Element;

package/types/slider/slider-marker.d.ts

@@ -1,5 +1,6 @@
 import type { MarkerProps } from '@zag-js/slider';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-export type SliderMarkerProps = Assign<HTMLArkProps<'span'>, MarkerProps>;
+export interface SliderMarkerProps extends Assign<HTMLArkProps<'span'>, MarkerProps> {
+}
 export declare const SliderMarker: (props: SliderMarkerProps) => import("solid-js").JSX.Element;

package/types/slider/slider-range.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SliderRangeProps = HTMLArkProps<'div'>;
+export interface SliderRangeProps extends HTMLArkProps<'div'> {
+}
 export declare const SliderRange: (props: SliderRangeProps) => import("solid-js").JSX.Element;

package/types/slider/slider-thumb.d.ts

@@ -1,5 +1,6 @@
 import type { ThumbProps } from '@zag-js/slider';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-export type SliderThumbProps = Assign<HTMLArkProps<'div'>, ThumbProps>;
+export interface SliderThumbProps extends Assign<HTMLArkProps<'div'>, ThumbProps> {
+}
 export declare const SliderThumb: (props: SliderThumbProps) => import("solid-js").JSX.Element;

package/types/slider/slider-track.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SliderTrackProps = HTMLArkProps<'div'>;
+export interface SliderTrackProps extends HTMLArkProps<'div'> {
+}
 export declare const SliderTrack: (props: SliderTrackProps) => import("solid-js").JSX.Element;

package/types/slider/slider-value-text.d.ts

@@ -1,8 +1,4 @@
-import { type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
-import type { Assign } from '../types';
-import { type UseSliderReturn } from './use-slider';
-export type SliderValueTextProps = Assign<HTMLArkProps<'div'>, {
-    children?: ((pages: UseSliderReturn) => JSX.Element) | JSX.Element;
-}>;
-export declare const SliderValueText: (props: SliderValueTextProps) => JSX.Element;
+export interface SliderValueTextProps extends HTMLArkProps<'div'> {
+}
+export declare const SliderValueText: (props: SliderValueTextProps) => import("solid-js").JSX.Element;

package/types/slider/slider.d.ts

@@ -2,7 +2,8 @@ import { type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 import { type UseSliderProps, type UseSliderReturn } from './use-slider';
-export type SliderProps = Assign<HTMLArkProps<'div'>, UseSliderProps & {
-    children?: ((api: UseSliderReturn) => JSX.Element) | JSX.Element;
-}>;
+export interface SliderProps extends Assign<Assign<HTMLArkProps<'div'>, {
+    children?: JSX.Element | ((api: UseSliderReturn) => JSX.Element);
+}>, UseSliderProps> {
+}
 export declare const Slider: (props: SliderProps) => JSX.Element;

package/types/slider/use-slider.d.ts

@@ -2,6 +2,8 @@ import * as slider from '@zag-js/slider';
 import { type PropTypes } from '@zag-js/solid';
 import { type Accessor } from 'solid-js';
 import { type Optional } from '../types';
-export type UseSliderProps = Optional<slider.Context, 'id'>;
-export type UseSliderReturn = Accessor<slider.Api<PropTypes>>;
+export interface UseSliderProps extends Optional<slider.Context, 'id'> {
+}
+export interface UseSliderReturn extends Accessor<slider.Api<PropTypes>> {
+}
 export declare const useSlider: (props: UseSliderProps) => UseSliderReturn;

package/types/splitter/splitter-context.d.ts

@@ -1,3 +1,4 @@
 import { type UseSplitterReturn } from './use-splitter';
-export type SplitterContext = UseSplitterReturn;
-export declare const SplitterProvider: import("solid-js").ContextProviderComponent<UseSplitterReturn>, useSplitterContext: () => UseSplitterReturn;
+export interface SplitterContext extends UseSplitterReturn {
+}
+export declare const SplitterProvider: import("solid-js").ContextProviderComponent<SplitterContext>, useSplitterContext: () => SplitterContext;

package/types/splitter/splitter-panel.d.ts

@@ -2,6 +2,7 @@ import { type connect } from '@zag-js/splitter';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 type PanelParams = Parameters<ReturnType<typeof connect>['getPanelProps']>[0];
-export type SplitterPanelProps = Assign<HTMLArkProps<'div'>, PanelParams>;
+export interface SplitterPanelProps extends Assign<HTMLArkProps<'div'>, PanelParams> {
+}
 export declare const SplitterPanel: (props: SplitterPanelProps) => import("solid-js").JSX.Element;
 export {};

package/types/splitter/splitter-resize-trigger.d.ts

@@ -2,6 +2,7 @@ import { connect } from '@zag-js/splitter';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 type TriggerParams = Parameters<ReturnType<typeof connect>['getResizeTriggerProps']>[0];
-export type SplitterResizeTriggerProps = Assign<HTMLArkProps<'button'>, TriggerParams>;
+export interface SplitterResizeTriggerProps extends Assign<HTMLArkProps<'button'>, TriggerParams> {
+}
 export declare const SplitterResizeTrigger: (props: SplitterResizeTriggerProps) => import("solid-js").JSX.Element;
 export {};

package/types/splitter/splitter.d.ts

@@ -2,7 +2,8 @@ import { type JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
 import { type UseSplitterProps, type UseSplitterReturn } from './use-splitter';
-export type SplitterProps = Assign<HTMLArkProps<'div'>, UseSplitterProps & {
-    children?: JSX.Element | ((pages: UseSplitterReturn) => JSX.Element);
-}>;
+export interface SplitterProps extends Assign<Assign<HTMLArkProps<'div'>, {
+    children?: JSX.Element | ((api: UseSplitterReturn) => JSX.Element);
+}>, UseSplitterProps> {
+}
 export declare const Splitter: (props: SplitterProps) => JSX.Element;

package/types/splitter/use-splitter.d.ts

@@ -2,6 +2,8 @@ import { type PropTypes } from '@zag-js/solid';
 import * as splitter from '@zag-js/splitter';
 import { type Accessor } from 'solid-js';
 import { type Optional } from '../types';
-export type UseSplitterProps = Optional<splitter.Context, 'id'>;
-export type UseSplitterReturn = Accessor<splitter.Api<PropTypes>>;
+export interface UseSplitterProps extends Optional<splitter.Context, 'id'> {
+}
+export interface UseSplitterReturn extends Accessor<splitter.Api<PropTypes>> {
+}
 export declare const useSplitter: (props: UseSplitterProps) => UseSplitterReturn;

package/types/switch/switch-context.d.ts

@@ -1,3 +1,4 @@
 import { type UseSwitchReturn } from './use-switch';
-export type SwitchContext = UseSwitchReturn;
-export declare const SwitchProvider: import("solid-js").ContextProviderComponent<UseSwitchReturn>, useSwitchContext: () => UseSwitchReturn;
+export interface SwitchContext extends UseSwitchReturn {
+}
+export declare const SwitchProvider: import("solid-js").ContextProviderComponent<SwitchContext>, useSwitchContext: () => SwitchContext;

package/types/switch/switch-control.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SwitchControlProps = HTMLArkProps<'span'>;
+export interface SwitchControlProps extends HTMLArkProps<'span'> {
+}
 export declare const SwitchControl: (props: SwitchControlProps) => import("solid-js").JSX.Element;

package/types/switch/switch-label.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SwitchLabelProps = HTMLArkProps<'span'>;
+export interface SwitchLabelProps extends HTMLArkProps<'span'> {
+}
 export declare const SwitchLabel: (props: SwitchLabelProps) => import("solid-js").JSX.Element;

package/types/switch/switch-thumb.d.ts

@@ -1,3 +1,4 @@
 import { type HTMLArkProps } from '../factory';
-export type SwitchThumbProps = HTMLArkProps<'span'>;
+export interface SwitchThumbProps extends HTMLArkProps<'span'> {
+}
 export declare const SwitchThumb: (props: SwitchThumbProps) => import("solid-js").JSX.Element;

package/types/switch/switch.d.ts

@@ -1,9 +1,9 @@
 import type { JSX } from 'solid-js';
 import { type HTMLArkProps } from '../factory';
 import type { Assign } from '../types';
-import { type SwitchContext } from './switch-context';
-import { type UseSwitchProps } from './use-switch';
-export type SwitchProps = Assign<HTMLArkProps<'label'>, UseSwitchProps & {
-    children?: JSX.Element | ((context: SwitchContext) => JSX.Element);
-}>;
+import { type UseSwitchProps, type UseSwitchReturn } from './use-switch';
+export interface SwitchProps extends Assign<Assign<HTMLArkProps<'label'>, {
+    children?: JSX.Element | ((api: UseSwitchReturn) => JSX.Element);
+}>, UseSwitchProps> {
+}
 export declare const Switch: (props: SwitchProps) => JSX.Element;