@ark-ui/react 0.0.0-rc-20221215085635 → 0.0.0-rc-20221215123045

package/dist/accordion/accordion-content.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type AccordionContentProps = HTMLArkProps<'div'>;
+export declare const AccordionContent: ComponentWithAs<"div", AccordionContentProps>;

package/dist/accordion/accordion-context.d.ts

@@ -0,0 +1,52 @@
+import type { Provider, HTMLAttributes, DetailedHTMLProps, ButtonHTMLAttributes } from 'react';
+import type { UseAccordionReturn } from './use-accordion';
+export declare type AccordionContext = UseAccordionReturn;
+export declare const AccordionProvider: Provider<{
+    value: string | string[] | null;
+    setValue(value: string | string[]): void;
+    rootProps: HTMLAttributes<HTMLElement>;
+    getItemState(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): {
+        isOpen: boolean;
+        isFocused: boolean;
+        isDisabled: boolean;
+    };
+    getItemProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): HTMLAttributes<HTMLElement>;
+    getContentProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): HTMLAttributes<HTMLElement>;
+    getTriggerProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+}>, useAccordionContext: () => {
+    value: string | string[] | null;
+    setValue(value: string | string[]): void;
+    rootProps: HTMLAttributes<HTMLElement>;
+    getItemState(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): {
+        isOpen: boolean;
+        isFocused: boolean;
+        isDisabled: boolean;
+    };
+    getItemProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): HTMLAttributes<HTMLElement>;
+    getContentProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): HTMLAttributes<HTMLElement>;
+    getTriggerProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};

package/dist/accordion/accordion-icon.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type AccordionIconProps = HTMLArkProps<'div'>;
+export declare const AccordionIcon: ComponentWithAs<"div", AccordionIconProps>;

package/dist/accordion/accordion-item-context.d.ts

@@ -0,0 +1,7 @@
+import type { Provider } from 'react';
+import type { AccordionContext } from './accordion-context';
+export declare type AccordionItemContext = ReturnType<AccordionContext['getItemState']> & {
+    value: string;
+    disabled?: boolean;
+};
+export declare const AccordionItemProvider: Provider<AccordionItemContext>, useAccordionItemContext: () => AccordionItemContext;

package/dist/accordion/accordion-item.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentWithAs, Assign } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+import { type AccordionContext } from './accordion-context';
+export declare type AccordionItemProps = Assign<HTMLArkProps<'div'>, {
+    value: string;
+    disabled?: boolean;
+    children?: React.ReactNode | ((props: ReturnType<AccordionContext['getItemState']>) => React.ReactNode);
+}>;
+export declare const AccordionItem: ComponentWithAs<"div", AccordionItemProps>;

package/dist/accordion/accordion-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type AccordionTriggerProps = {
+    children: ReactElement;
+};
+export declare const AccordionTrigger: (props: AccordionTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/accordion/accordion.anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as accordionAnatomy } from '@zag-js/accordion';

package/dist/accordion/accordion.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { UseAccordionProps } from './use-accordion';
+export declare type AccordionProps = Assign<HTMLArkProps<'div'>, UseAccordionProps>;
+export declare const Accordion: ComponentWithAs<"div", AccordionProps>;

package/dist/accordion/index.d.ts

@@ -0,0 +1,8 @@
+export { Accordion, type AccordionProps } from './accordion';
+export { AccordionContent, type AccordionContentProps } from './accordion-content';
+export { AccordionIcon, type AccordionIconProps } from './accordion-icon';
+export { AccordionItem, type AccordionItemProps } from './accordion-item';
+export { useAccordionItemContext, type AccordionItemContext } from './accordion-item-context';
+export { AccordionTrigger, type AccordionTriggerProps } from './accordion-trigger';
+export { accordionAnatomy } from './accordion.anatomy';
+export { useAccordion, type UseAccordionProps, type UseAccordionReturn } from './use-accordion';

package/dist/accordion/use-accordion.d.ts

@@ -0,0 +1,32 @@
+import type { HTMLAttributes, DetailedHTMLProps, ButtonHTMLAttributes } from 'react';
+import * as accordion from '@zag-js/accordion';
+import type { Optional } from '../types';
+export declare type UseAccordionProps = Optional<accordion.Context, 'id'> & {
+    defaultValue?: accordion.Context['value'];
+};
+export declare type UseAccordionReturn = ReturnType<typeof useAccordion>;
+export declare const useAccordion: (props: UseAccordionProps) => {
+    value: string | string[] | null;
+    setValue(value: string | string[]): void;
+    rootProps: HTMLAttributes<HTMLElement>;
+    getItemState(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): {
+        isOpen: boolean;
+        isFocused: boolean;
+        isDisabled: boolean;
+    };
+    getItemProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): HTMLAttributes<HTMLElement>;
+    getContentProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): HTMLAttributes<HTMLElement>;
+    getTriggerProps(props: {
+        value: string;
+        disabled?: boolean | undefined;
+    }): DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};

package/dist/checkbox/checkbox-context.d.ts

@@ -0,0 +1,30 @@
+import type { Provider, DetailedHTMLProps, LabelHTMLAttributes, HTMLAttributes, InputHTMLAttributes } from 'react';
+import type { UseCheckboxReturn } from './use-checkbox';
+export declare type CheckboxContext = UseCheckboxReturn;
+export declare const CheckboxProvider: Provider<{
+    isChecked: boolean;
+    isDisabled: boolean | undefined;
+    isIndeterminate: boolean | undefined;
+    isFocused: boolean;
+    isReadOnly: boolean | undefined;
+    view: string;
+    setChecked(checked: boolean): void;
+    setIndeterminate(indeterminate: boolean): void;
+    rootProps: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    labelProps: HTMLAttributes<HTMLElement>;
+    controlProps: HTMLAttributes<HTMLElement>;
+    inputProps: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+}>, useCheckboxContext: () => {
+    isChecked: boolean;
+    isDisabled: boolean | undefined;
+    isIndeterminate: boolean | undefined;
+    isFocused: boolean;
+    isReadOnly: boolean | undefined;
+    view: string;
+    setChecked(checked: boolean): void;
+    setIndeterminate(indeterminate: boolean): void;
+    rootProps: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    labelProps: HTMLAttributes<HTMLElement>;
+    controlProps: HTMLAttributes<HTMLElement>;
+    inputProps: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+};

package/dist/checkbox/checkbox-control.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type CheckboxControlProps = HTMLArkProps<'div'>;
+export declare const CheckboxControl: ComponentWithAs<"div", CheckboxControlProps>;

package/dist/checkbox/checkbox-input.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type CheckboxInputProps = HTMLArkProps<'input'>;
+export declare const CheckboxInput: ComponentWithAs<"input", CheckboxInputProps>;

package/dist/checkbox/checkbox-label.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type CheckboxLabelProps = HTMLArkProps<'label'>;
+export declare const CheckboxLabel: ComponentWithAs<"label", CheckboxLabelProps>;

package/dist/checkbox/checkbox.anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as checkboxAnatomy } from '@zag-js/checkbox';

package/dist/checkbox/checkbox.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { UseCheckboxProps } from './use-checkbox';
+export declare type CheckboxProps = Assign<HTMLArkProps<'label'>, UseCheckboxProps>;
+export declare const Checkbox: ComponentWithAs<"label", CheckboxProps>;

package/dist/checkbox/index.d.ts

@@ -0,0 +1,6 @@
+export { Checkbox, type CheckboxProps } from './checkbox';
+export { CheckboxControl, type CheckboxControlProps } from './checkbox-control';
+export { CheckboxInput, type CheckboxInputProps } from './checkbox-input';
+export { CheckboxLabel, type CheckboxLabelProps } from './checkbox-label';
+export { checkboxAnatomy } from './checkbox.anatomy';
+export { useCheckbox, type UseCheckboxProps, type UseCheckboxReturn } from './use-checkbox';

package/dist/checkbox/use-checkbox.d.ts

@@ -0,0 +1,21 @@
+import type { DetailedHTMLProps, LabelHTMLAttributes, HTMLAttributes, InputHTMLAttributes } from 'react';
+import { Context } from '@zag-js/checkbox';
+import type { Optional } from '../types';
+export declare type UseCheckboxProps = Optional<Context, 'id'> & {
+    defaultValue?: Context['value'];
+};
+export declare type UseCheckboxReturn = ReturnType<typeof useCheckbox>;
+export declare const useCheckbox: (props: UseCheckboxProps) => {
+    isChecked: boolean;
+    isDisabled: boolean | undefined;
+    isIndeterminate: boolean | undefined;
+    isFocused: boolean;
+    isReadOnly: boolean | undefined;
+    view: string;
+    setChecked(checked: boolean): void;
+    setIndeterminate(indeterminate: boolean): void;
+    rootProps: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    labelProps: HTMLAttributes<HTMLElement>;
+    controlProps: HTMLAttributes<HTMLElement>;
+    inputProps: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+};

package/dist/create-context.d.ts

@@ -0,0 +1,10 @@
+export interface CreateContextOptions<T> {
+    strict?: boolean;
+    hookName?: string;
+    providerName?: string;
+    errorMessage?: string;
+    name?: string;
+    defaultValue?: T;
+}
+export declare type CreateContextReturn<T> = [React.Provider<T>, () => T, React.Context<T>];
+export declare function createContext<T>(options?: CreateContextOptions<T>): CreateContextReturn<T>;

package/dist/create-split-props.d.ts

@@ -0,0 +1 @@
+export declare const createSplitProps: <Target>() => <Keys extends (keyof Target)[], Props extends Target = Target>(props: Props, keys: Keys & ([keyof Target] extends [Keys[number]] ? unknown : never)) => [Target, Omit<Props, Extract<(Keys & ([keyof Target] extends [Keys[number]] ? unknown : never))[number], string>>];

package/dist/dialog/dialog-backdrop.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type DialogBackdropProps = HTMLArkProps<'div'>;
+export declare const DialogBackdrop: ComponentWithAs<"div", DialogBackdropProps>;

package/dist/dialog/dialog-close-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type DialogCloseTriggerProps = {
+    children: ReactElement;
+};
+export declare const DialogCloseTrigger: (props: DialogCloseTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/dialog/dialog-container.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type DialogContainerProps = HTMLArkProps<'div'>;
+export declare const DialogContainer: ComponentWithAs<"div", DialogContainerProps>;

package/dist/dialog/dialog-content.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type DialogContentProps = HTMLArkProps<'div'>;
+export declare const DialogContent: ComponentWithAs<"div", DialogContentProps>;

package/dist/dialog/dialog-context.d.ts

@@ -0,0 +1,26 @@
+import type { Provider, DetailedHTMLProps, ButtonHTMLAttributes, HTMLAttributes } from 'react';
+import type { UseDialogReturn } from './use-dialog';
+export declare type DialogContext = UseDialogReturn;
+export declare const DialogProvider: Provider<{
+    isOpen: boolean;
+    open(): void;
+    close(): void;
+    triggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    backdropProps: HTMLAttributes<HTMLElement>;
+    containerProps: HTMLAttributes<HTMLElement>;
+    contentProps: HTMLAttributes<HTMLElement>;
+    titleProps: HTMLAttributes<HTMLElement>;
+    descriptionProps: HTMLAttributes<HTMLElement>;
+    closeTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+}>, useDialogContext: () => {
+    isOpen: boolean;
+    open(): void;
+    close(): void;
+    triggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    backdropProps: HTMLAttributes<HTMLElement>;
+    containerProps: HTMLAttributes<HTMLElement>;
+    contentProps: HTMLAttributes<HTMLElement>;
+    titleProps: HTMLAttributes<HTMLElement>;
+    descriptionProps: HTMLAttributes<HTMLElement>;
+    closeTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};

package/dist/dialog/dialog-description.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type DialogDescriptionProps = HTMLArkProps<'p'>;
+export declare const DialogDescription: ComponentWithAs<"p", DialogDescriptionProps>;

package/dist/dialog/dialog-title.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type DialogTitleProps = HTMLArkProps<'h2'>;
+export declare const DialogTitle: ComponentWithAs<"h2", DialogTitleProps>;

package/dist/dialog/dialog-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type DialogTriggerProps = {
+    children: ReactElement;
+};
+export declare const DialogTrigger: (props: DialogTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/dialog/dialog.anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as dialogAnatomy } from '@zag-js/dialog';

package/dist/dialog/dialog.d.ts

@@ -0,0 +1,4 @@
+import type { PropsWithChildren } from 'react';
+import { UseDialogProps } from './use-dialog';
+export declare type DialogProps = PropsWithChildren<UseDialogProps>;
+export declare const Dialog: (props: DialogProps) => JSX.Element;

package/dist/dialog/index.d.ts

@@ -0,0 +1,9 @@
+export { Dialog, type DialogProps } from './dialog';
+export { DialogBackdrop, type DialogBackdropProps } from './dialog-backdrop';
+export { DialogCloseTrigger, type DialogCloseTriggerProps } from './dialog-close-trigger';
+export { DialogContainer, type DialogContainerProps } from './dialog-container';
+export { DialogContent, type DialogContentProps } from './dialog-content';
+export { DialogDescription, type DialogDescriptionProps } from './dialog-description';
+export { DialogTitle, type DialogTitleProps } from './dialog-title';
+export { DialogTrigger, type DialogTriggerProps } from './dialog-trigger';
+export { dialogAnatomy } from './dialog.anatomy';

package/dist/dialog/use-dialog.d.ts

@@ -0,0 +1,17 @@
+import type { DetailedHTMLProps, ButtonHTMLAttributes, HTMLAttributes } from 'react';
+import * as dialog from '@zag-js/dialog';
+import type { Optional } from '../types';
+export declare type UseDialogProps = Optional<dialog.Context, 'id'>;
+export declare const useDialog: (props: UseDialogProps) => {
+    isOpen: boolean;
+    open(): void;
+    close(): void;
+    triggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    backdropProps: HTMLAttributes<HTMLElement>;
+    containerProps: HTMLAttributes<HTMLElement>;
+    contentProps: HTMLAttributes<HTMLElement>;
+    titleProps: HTMLAttributes<HTMLElement>;
+    descriptionProps: HTMLAttributes<HTMLElement>;
+    closeTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};
+export declare type UseDialogReturn = ReturnType<typeof useDialog>;

package/dist/editable/editable-area.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type EditableAreaProps = HTMLArkProps<'div'>;
+export declare const EditableArea: ComponentWithAs<"div", EditableAreaProps>;

package/dist/editable/editable-cancel-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type EditableCancelTriggerProps = {
+    children: ReactElement;
+};
+export declare const EditableCancelTrigger: (props: EditableCancelTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/editable/editable-context.d.ts

@@ -0,0 +1,40 @@
+import type { Provider, HTMLAttributes, DetailedHTMLProps, LabelHTMLAttributes, InputHTMLAttributes, ButtonHTMLAttributes } from 'react';
+import type { UseEditableReturn } from './use-editable';
+export declare type EditableContext = UseEditableReturn;
+export declare const EditableProvider: Provider<{
+    isEditing: boolean;
+    isValueEmpty: boolean;
+    value: string;
+    setValue(value: string): void;
+    clearValue(): void;
+    edit(): void;
+    cancel(): void;
+    submit(): void;
+    rootProps: HTMLAttributes<HTMLElement>;
+    areaProps: HTMLAttributes<HTMLElement>;
+    labelProps: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    inputProps: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    previewProps: HTMLAttributes<HTMLElement>;
+    editTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    controlProps: HTMLAttributes<HTMLElement>;
+    submitTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    cancelTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+}>, useEditableContext: () => {
+    isEditing: boolean;
+    isValueEmpty: boolean;
+    value: string;
+    setValue(value: string): void;
+    clearValue(): void;
+    edit(): void;
+    cancel(): void;
+    submit(): void;
+    rootProps: HTMLAttributes<HTMLElement>;
+    areaProps: HTMLAttributes<HTMLElement>;
+    labelProps: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    inputProps: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    previewProps: HTMLAttributes<HTMLElement>;
+    editTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    controlProps: HTMLAttributes<HTMLElement>;
+    submitTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    cancelTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};

package/dist/editable/editable-control.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type EditableControlProps = HTMLArkProps<'div'>;
+export declare const EditableControl: ComponentWithAs<"div", EditableControlProps>;

package/dist/editable/editable-edit-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type EditableEditTriggerProps = {
+    children: ReactElement;
+};
+export declare const EditableEditTrigger: (props: EditableEditTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/editable/editable-input.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type EditableInputProps = HTMLArkProps<'input'>;
+export declare const EditableInput: ComponentWithAs<"input", EditableInputProps>;

package/dist/editable/editable-label.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type EditableLabelProps = HTMLArkProps<'label'>;
+export declare const EditableLabel: ComponentWithAs<"label", EditableLabelProps>;

package/dist/editable/editable-preview.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type EditablePreviewProps = HTMLArkProps<'span'>;
+export declare const EditablePreview: ComponentWithAs<"span", EditablePreviewProps>;

package/dist/editable/editable-submit-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type EditableSubmitTriggerProps = {
+    children: ReactElement;
+};
+export declare const EditableSubmitTrigger: (props: EditableSubmitTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/editable/editable.anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as editableAnatomy } from '@zag-js/editable';

package/dist/editable/editable.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import type { ReactNode } from 'react';
+import { HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { EditableContext } from './editable-context';
+import { UseEditableProps } from './use-editable';
+export declare type EditableProps = Assign<Omit<HTMLArkProps<'div'>, 'children'> & {
+    children: ReactNode | ((pages: EditableContext) => ReactNode);
+}, UseEditableProps>;
+export declare const Editable: ComponentWithAs<"div", EditableProps>;

package/dist/editable/index.d.ts

@@ -0,0 +1,11 @@
+export { Editable, type EditableProps } from './editable';
+export { EditableArea, type EditableAreaProps } from './editable-area';
+export { EditableCancelTrigger, type EditableCancelTriggerProps } from './editable-cancel-trigger';
+export { EditableControl, type EditableControlProps } from './editable-control';
+export { EditableEditTrigger, type EditableEditTriggerProps } from './editable-edit-trigger';
+export { EditableInput, type EditableInputProps } from './editable-input';
+export { EditableLabel, type EditableLabelProps } from './editable-label';
+export { EditablePreview, type EditablePreviewProps } from './editable-preview';
+export { EditableSubmitTrigger, type EditableSubmitTriggerProps } from './editable-submit-trigger';
+export { editableAnatomy } from './editable.anatomy';
+export { useEditable, type UseEditableProps, type UseEditableReturn } from './use-editable';

package/dist/editable/use-editable.d.ts

@@ -0,0 +1,26 @@
+import type { HTMLAttributes, DetailedHTMLProps, LabelHTMLAttributes, InputHTMLAttributes, ButtonHTMLAttributes } from 'react';
+import * as editable from '@zag-js/editable';
+import type { Optional } from '../types';
+export declare type UseEditableProps = Optional<editable.Context, 'id'> & {
+    defaultValue?: editable.Context['value'];
+};
+export declare type UseEditableReturn = ReturnType<typeof useEditable>;
+export declare const useEditable: (props: UseEditableProps) => {
+    isEditing: boolean;
+    isValueEmpty: boolean;
+    value: string;
+    setValue(value: string): void;
+    clearValue(): void;
+    edit(): void;
+    cancel(): void;
+    submit(): void;
+    rootProps: HTMLAttributes<HTMLElement>;
+    areaProps: HTMLAttributes<HTMLElement>;
+    labelProps: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    inputProps: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    previewProps: HTMLAttributes<HTMLElement>;
+    editTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    controlProps: HTMLAttributes<HTMLElement>;
+    submitTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+    cancelTriggerProps: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
+};

package/dist/factory.d.ts

@@ -0,0 +1,12 @@
+/**
+ * All html and svg elements for ark components.
+ * This is mostly for `ark.<element>` syntax.
+ */
+import type { ComponentWithAs, HTMLPolymorphicComponents,  HTMLPolymorphicProps } from '@polymorphic-factory/react';
+import type { ElementType } from 'react';
+export declare type HTMLArkComponents = HTMLPolymorphicComponents;
+export declare type HTMLArkProps<T extends ElementType> = HTMLPolymorphicProps<T>;
+/**
+ * The ark factory serves as an object of JSX elements to render React components which accept the `as` prop
+ */
+export declare const ark: (<T extends ElementType<any>, P extends Record<string, unknown> = Record<never, never>, Options = never>(component: T, option?: Options | undefined) => ComponentWithAs<T, P>) & HTMLPolymorphicComponents;

package/dist/hover-card/hover-card-arrow-tip.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type HoverCardArrowTipProps = HTMLArkProps<'div'>;
+export declare const HoverCardArrowTip: ComponentWithAs<"div", HoverCardArrowTipProps>;

package/dist/hover-card/hover-card-arrow.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type HoverCardArrowProps = HTMLArkProps<'div'>;
+export declare const HoverCardArrow: ComponentWithAs<"div", HoverCardArrowProps>;

package/dist/hover-card/hover-card-content.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type HoverCardContentProps = HTMLArkProps<'div'>;
+export declare const HoverCardContent: ComponentWithAs<"div", HoverCardContentProps>;

package/dist/hover-card/hover-card-context.d.ts

@@ -0,0 +1,18 @@
+import type { Provider, HTMLAttributes } from 'react';
+import type { UseHoverCardReturn } from './use-hover-card';
+export declare type HoverCardContext = UseHoverCardReturn;
+export declare const HoverCardProvider: Provider<{
+    isOpen: boolean;
+    arrowProps: HTMLAttributes<HTMLElement>;
+    arrowTipProps: HTMLAttributes<HTMLElement>;
+    triggerProps: HTMLAttributes<HTMLElement>;
+    positionerProps: HTMLAttributes<HTMLElement>;
+    contentProps: HTMLAttributes<HTMLElement>;
+}>, useHoverCardContext: () => {
+    isOpen: boolean;
+    arrowProps: HTMLAttributes<HTMLElement>;
+    arrowTipProps: HTMLAttributes<HTMLElement>;
+    triggerProps: HTMLAttributes<HTMLElement>;
+    positionerProps: HTMLAttributes<HTMLElement>;
+    contentProps: HTMLAttributes<HTMLElement>;
+};

package/dist/hover-card/hover-card-positioner.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentWithAs } from '@polymorphic-factory/react';
+import { HTMLArkProps } from '../factory';
+export declare type HoverCardPositionerProps = HTMLArkProps<'div'>;
+export declare const HoverCardPositioner: ComponentWithAs<"div", HoverCardPositionerProps>;

package/dist/hover-card/hover-card-trigger.d.ts

@@ -0,0 +1,5 @@
+import type { JSXElementConstructor, ReactElement } from 'react';
+export declare type HoverCardTriggerProps = {
+    children: ReactElement;
+};
+export declare const HoverCardTrigger: (props: HoverCardTriggerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

package/dist/hover-card/hover-card.anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as hoverCardAnatomy } from '@zag-js/hover-card';

package/dist/hover-card/hover-card.d.ts

@@ -0,0 +1,4 @@
+import type { PropsWithChildren } from 'react';
+import { UseHoverCardProps } from './use-hover-card';
+export declare type HoverCardProps = PropsWithChildren<UseHoverCardProps>;
+export declare const HoverCard: (props: HoverCardProps) => JSX.Element;

package/dist/hover-card/index.d.ts

@@ -0,0 +1,7 @@
+export { HoverCard, type HoverCardProps } from './hover-card';
+export { HoverCardArrow, type HoverCardArrowProps } from './hover-card-arrow';
+export { HoverCardArrowTip, type HoverCardArrowTipProps } from './hover-card-arrow-tip';
+export { HoverCardContent, type HoverCardContentProps } from './hover-card-content';
+export { HoverCardPositioner, type HoverCardPositionerProps } from './hover-card-positioner';
+export { HoverCardTrigger, type HoverCardTriggerProps } from './hover-card-trigger';
+export { hoverCardAnatomy } from './hover-card.anatomy';

package/dist/hover-card/use-hover-card.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes } from 'react';
+import * as hoverCard from '@zag-js/hover-card';
+import type { Optional } from '../types';
+export declare type UseHoverCardProps = Optional<hoverCard.Context, 'id'>;
+export declare const useHoverCard: (props: UseHoverCardProps) => {
+    isOpen: boolean;
+    arrowProps: HTMLAttributes<HTMLElement>;
+    arrowTipProps: HTMLAttributes<HTMLElement>;
+    triggerProps: HTMLAttributes<HTMLElement>;
+    positionerProps: HTMLAttributes<HTMLElement>;
+    contentProps: HTMLAttributes<HTMLElement>;
+};
+export declare type UseHoverCardReturn = ReturnType<typeof useHoverCard>;