@gamecrafters/base-ui 0.0.40 → 0.0.42

package/build/components/index.d.ts

@@ -59,12 +59,14 @@ export * from "./highlight";
 export * from "./hover-card";
 export * from "./icon-button";
 export * from "./image";
+export * from "./inline-edit";
 export * from "./inline-message";
 export * from "./json-tree-view";
 export * from "./keybinding-hint";
 export * from "./label";
 export * from "./label-group";
 export * from "./layer-card";
+export * from "./layer-dialog";
 export * from "./link";
 export * from "./list";
 export * from "./map";
@@ -115,6 +117,7 @@ export * from "./swap";
 export * from "./switch";
 export * from "./table-of-contents";
 export * from "./tabs";
+export * from "./tag-input";
 export * from "./text";
 export * from "./text-input";
 export * from "./textarea";

package/build/components/inline-edit/InlineEdit.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./InlineEdit.types").UseInlineEditProps> & import("./InlineEdit.types").UseInlineEditProps & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEdit.types.d.ts

@@ -0,0 +1,116 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { ButtonSize, ButtonVariant, ButtonVisual } from "../button";
+import type { TextInputSize } from "../text-input/TextInput.types";
+export type InlineEditActivationMode = "focus" | "click" | "dblclick" | "none";
+export type InlineEditSubmitMode = "enter" | "blur" | "both" | "none";
+export type InlineEditPlaceholder = string | {
+    edit: string;
+    preview: string;
+};
+export type InlineEditInputElement = "input" | "textarea";
+export type InlineEditIds = {
+    root?: string;
+    label?: string;
+    area?: string;
+    input?: string;
+    preview?: string;
+    control?: string;
+    editTrigger?: string;
+    submitTrigger?: string;
+    cancelTrigger?: string;
+};
+export type UseInlineEditProps = {
+    value?: string;
+    defaultValue?: string;
+    edit?: boolean;
+    defaultEdit?: boolean;
+    activationMode?: InlineEditActivationMode;
+    submitMode?: InlineEditSubmitMode;
+    selectOnFocus?: boolean;
+    placeholder?: InlineEditPlaceholder;
+    maxLength?: number;
+    autoResize?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    name?: string;
+    form?: string;
+    id?: string;
+    ids?: InlineEditIds;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    onValueChange?: (value: string) => void;
+    onValueCommit?: (value: string) => void;
+    onValueRevert?: (value: string) => void;
+    onEditChange?: (edit: boolean) => void;
+};
+export type UseInlineEditReturn = {
+    editing: boolean;
+    empty: boolean;
+    value: string;
+    valueText: string;
+    placeholder?: string;
+    activationMode: InlineEditActivationMode;
+    autoResize: boolean;
+    maxLength?: number;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+    name?: string;
+    form?: string;
+    ids: Required<InlineEditIds>;
+    describedBy?: string;
+    setValue: (value: string) => void;
+    clearValue: () => void;
+    edit: () => void;
+    submit: () => void;
+    cancel: () => void;
+    focus: () => void;
+    rootRef: React.RefObject<HTMLDivElement | null>;
+    handleInputChange: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    handleInputKeyDown: (event: React.KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    handlePreviewFocus: () => void;
+    handlePreviewClick: () => void;
+    handlePreviewDoubleClick: () => void;
+    handlePreviewKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+};
+type InlineEditFieldProps = {
+    size?: TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+};
+export type InlineEditProps = Omit<React.ComponentPropsWithoutRef<"div">, keyof UseInlineEditProps> & UseInlineEditProps & InlineEditFieldProps;
+export type InlineEditRootProviderProps = Omit<React.ComponentPropsWithoutRef<"div">, "defaultValue"> & InlineEditFieldProps & {
+    value: UseInlineEditReturn;
+};
+export type InlineEditLabelProps = React.ComponentPropsWithoutRef<"label"> & {
+    visuallyHidden?: boolean;
+    className?: string;
+};
+export type InlineEditAreaProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type InlineEditInputProps<As extends InlineEditInputElement = "input"> = Omit<PolymorphicProps<As, "input", {
+    className?: string;
+}>, "value" | "defaultValue">;
+export type InlineEditPreviewProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    className?: string;
+}>;
+export type InlineEditControlProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+type InlineEditTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "type" | "aria-label" | "aria-labelledby"> & {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    icon?: ButtonVisual;
+    label?: string;
+    className?: string;
+};
+export type InlineEditEditTriggerProps = InlineEditTriggerProps;
+export type InlineEditSubmitTriggerProps = InlineEditTriggerProps;
+export type InlineEditCancelTriggerProps = InlineEditTriggerProps;
+export type InlineEditContextValue = Partial<UseInlineEditReturn> & Omit<InlineEditFieldProps, "className">;
+export {};

package/build/components/inline-edit/InlineEditArea.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditCancelTrigger.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "type" | "aria-label" | "aria-labelledby"> & {
+    variant?: import("..").ButtonVariant;
+    size?: import("..").ButtonSize;
+    icon?: import("..").ButtonVisual;
+    label?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditContext.d.ts

@@ -0,0 +1,10 @@
+import type { InlineEditContextValue } from "./InlineEdit.types";
+export declare const InlineEditContext: import("react").Context<InlineEditContextValue>;
+export declare const useInlineEditContext: () => InlineEditContextValue;
+export declare const getStateAttributes: ({ editing, disabled, readOnly, required, invalid, }: InlineEditContextValue) => {
+    "data-editing": true | undefined;
+    "data-disabled": true | undefined;
+    "data-readonly": true | undefined;
+    "data-required": true | undefined;
+    "data-invalid": true | undefined;
+};

package/build/components/inline-edit/InlineEditControl.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditEditTrigger.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "type" | "aria-label" | "aria-labelledby"> & {
+    variant?: import("..").ButtonVariant;
+    size?: import("..").ButtonSize;
+    icon?: import("..").ButtonVisual;
+    label?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditInput.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { InlineEditInputElement, InlineEditInputProps } from "./InlineEdit.types";
+declare const _default: <As extends InlineEditInputElement = "input">(props: InlineEditInputProps<As> & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditLabel.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+    visuallyHidden?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditPreview.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditRootProvider.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue"> & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & {
+    value: import("./InlineEdit.types").UseInlineEditReturn;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/InlineEditSubmitTrigger.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "type" | "aria-label" | "aria-labelledby"> & {
+    variant?: import("..").ButtonVariant;
+    size?: import("..").ButtonSize;
+    icon?: import("..").ButtonVisual;
+    label?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/inline-edit/index.d.ts

@@ -0,0 +1,71 @@
+import InlineEditArea from "./InlineEditArea";
+import InlineEditCancelTrigger from "./InlineEditCancelTrigger";
+import InlineEditControl from "./InlineEditControl";
+import InlineEditEditTrigger from "./InlineEditEditTrigger";
+import InlineEditInput from "./InlineEditInput";
+import InlineEditLabel from "./InlineEditLabel";
+import InlineEditPreview from "./InlineEditPreview";
+import InlineEditRootProvider from "./InlineEditRootProvider";
+import InlineEditSubmitTrigger from "./InlineEditSubmitTrigger";
+export declare const InlineEdit: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./InlineEdit.types").UseInlineEditProps> & import("./InlineEdit.types").UseInlineEditProps & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Root: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./InlineEdit.types").UseInlineEditProps> & import("./InlineEdit.types").UseInlineEditProps & {
+        size?: import("..").TextInputSize;
+        block?: boolean;
+        contrast?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    RootProvider: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue"> & {
+        size?: import("..").TextInputSize;
+        block?: boolean;
+        contrast?: boolean;
+        className?: string;
+    } & {
+        value: import("./InlineEdit.types").UseInlineEditReturn;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        visuallyHidden?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Area: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Input: <As extends import("./InlineEdit.types").InlineEditInputElement = "input">(props: import("./InlineEdit.types").InlineEditInputProps<As> & import("react").RefAttributes<any>) => React.ReactNode;
+    Preview: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Control: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    EditTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "type" | "aria-label" | "aria-labelledby"> & {
+        variant?: import("..").ButtonVariant;
+        size?: import("..").ButtonSize;
+        icon?: import("..").ButtonVisual;
+        label?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SubmitTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "type" | "aria-label" | "aria-labelledby"> & {
+        variant?: import("..").ButtonVariant;
+        size?: import("..").ButtonSize;
+        icon?: import("..").ButtonVisual;
+        label?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    CancelTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "type" | "aria-label" | "aria-labelledby"> & {
+        variant?: import("..").ButtonVariant;
+        size?: import("..").ButtonSize;
+        icon?: import("..").ButtonVisual;
+        label?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { InlineEditRootProvider, InlineEditLabel, InlineEditArea, InlineEditInput, InlineEditPreview, InlineEditControl, InlineEditEditTrigger, InlineEditSubmitTrigger, InlineEditCancelTrigger, };
+export { InlineEditContext, useInlineEditContext } from "./InlineEditContext";
+export { useInlineEdit } from "./useInlineEdit";
+export * from "./InlineEdit.types";

package/build/components/inline-edit/useInlineEdit.d.ts

@@ -0,0 +1,2 @@
+import type { UseInlineEditProps, UseInlineEditReturn } from "./InlineEdit.types";
+export declare const useInlineEdit: (props?: UseInlineEditProps) => UseInlineEditReturn;

package/build/components/layer-dialog/LayerDialog.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { LayerDialogProps } from "./LayerDialog.types";
+declare function LayerDialog(props: LayerDialogProps): React.JSX.Element;
+declare namespace LayerDialog {
+    var displayName: string;
+}
+export default LayerDialog;

package/build/components/layer-dialog/LayerDialog.types.d.ts

@@ -0,0 +1,65 @@
+import type * as React from "react";
+import type { ButtonProps } from "../button";
+export type LayerDialogOpenChangeGesture = "trigger-press" | "close-button" | "dismiss-button" | "escape" | "click-outside" | "swipe" | "imperative";
+export type LayerDialogSize = "small" | "medium" | "large" | "xlarge";
+export type LayerDialogVerticalAlign = "top" | "center";
+export type LayerDialogActionVariant = "primary" | "danger";
+export type LayerDialogInstance = {
+    close: () => void;
+};
+export type LayerDialogProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean, gesture: LayerDialogOpenChangeGesture) => void;
+    dismissDisabled?: boolean;
+    modal?: boolean;
+    disablePointerDismissal?: boolean;
+    actionsRef?: React.Ref<LayerDialogInstance | null>;
+    children?: React.ReactNode;
+};
+export type LayerDialogAlertProps = LayerDialogProps;
+export type LayerDialogTriggerProps<As extends React.ElementType = "button"> = ButtonProps<As>;
+export type LayerDialogContentProps = {
+    children: React.ReactNode;
+    size?: LayerDialogSize;
+    verticalAlign?: LayerDialogVerticalAlign;
+    closeLabel?: string;
+    portalContainerName?: string;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    className?: string;
+};
+export type LayerDialogTitleProps = Omit<React.ComponentPropsWithoutRef<"h2">, "id"> & {
+    className?: string;
+};
+export type LayerDialogDescriptionProps = Omit<React.ComponentPropsWithoutRef<"p">, "id"> & {
+    className?: string;
+};
+export type LayerDialogBodyProps = {
+    children?: React.ReactNode;
+    className?: string;
+};
+export type LayerDialogActionsProps = {
+    children: React.ReactNode;
+    dismissLabel?: string;
+    className?: string;
+};
+export type LayerDialogActionProps = Omit<ButtonProps, "as" | "variant" | "size" | "block" | "children"> & {
+    children: React.ReactNode;
+    variant?: LayerDialogActionVariant;
+    menu?: React.ReactNode[];
+    menuLabel?: string;
+};
+export type LayerDialogContextValue = {
+    open: boolean;
+    setOpen: (open: boolean, gesture: LayerDialogOpenChangeGesture) => void;
+    dismiss: (gesture: LayerDialogOpenChangeGesture) => void;
+    alert: boolean;
+    modal: boolean;
+    dismissDisabled: boolean;
+    pointerDismissal: boolean;
+    narrow: boolean;
+    popupId: string;
+    titleId: string;
+    descriptionId: string;
+};

package/build/components/layer-dialog/LayerDialogAction.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<import("..").ButtonProps, "size" | "as" | "children" | "variant" | "block"> & {
+    children: React.ReactNode;
+    variant?: import("./LayerDialog.types").LayerDialogActionVariant;
+    menu?: React.ReactNode[];
+    menuLabel?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogActions.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { LayerDialogActionsProps } from "./LayerDialog.types";
+declare const _default: (props: LayerDialogActionsProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogAlert.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { LayerDialogAlertProps } from "./LayerDialog.types";
+declare function LayerDialogAlert(props: LayerDialogAlertProps): React.JSX.Element;
+declare namespace LayerDialogAlert {
+    var displayName: string;
+}
+export default LayerDialogAlert;

package/build/components/layer-dialog/LayerDialogBody.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { LayerDialogBodyProps } from "./LayerDialog.types";
+declare const _default: (props: LayerDialogBodyProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogContent.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { LayerDialogContentProps } from "./LayerDialog.types";
+declare const _default: (props: LayerDialogContentProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogContext.d.ts

@@ -0,0 +1,12 @@
+import type * as React from "react";
+import type { LayerDialogContextValue } from "./LayerDialog.types";
+export declare const LayerDialogContext: React.Context<LayerDialogContextValue>;
+export declare const useLayerDialogContext: () => LayerDialogContextValue;
+export type LayerDialogBodySlots = {
+    title: React.ReactNode;
+    description: React.ReactNode;
+    actions: React.ReactNode;
+    showCloseButton: boolean;
+    closeLabel: string;
+};
+export declare const LayerDialogBodySlotsContext: React.Context<LayerDialogBodySlots>;

package/build/components/layer-dialog/LayerDialogDescription.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, "id"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogPopup.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { UsePresenceReturn } from "../presence";
+import type { LayerDialogContentProps } from "./LayerDialog.types";
+declare const _default: (props: Omit<LayerDialogContentProps, "children" | "closeLabel"> & {
+    presence: UsePresenceReturn;
+    actions?: React.ReactNode;
+    children: React.ReactNode;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogTitle.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "id"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/LayerDialogTrigger.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "button">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "button" : As> & import("..").ButtonBaseProps & import("..").ButtonContentProps, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/layer-dialog/index.d.ts

@@ -0,0 +1,34 @@
+import LayerDialogBase from "./LayerDialog";
+import LayerDialogAction from "./LayerDialogAction";
+import LayerDialogActions from "./LayerDialogActions";
+import LayerDialogAlert from "./LayerDialogAlert";
+import LayerDialogBody from "./LayerDialogBody";
+import LayerDialogContent from "./LayerDialogContent";
+import LayerDialogDescription from "./LayerDialogDescription";
+import LayerDialogTitle from "./LayerDialogTitle";
+import LayerDialogTrigger from "./LayerDialogTrigger";
+export declare const LayerDialog: typeof LayerDialogBase & {
+    Root: typeof LayerDialogBase;
+    Alert: typeof LayerDialogAlert;
+    Trigger: <As extends React.ElementType = "button">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "button" : As> & import("..").ButtonBaseProps & import("..").ButtonContentProps, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Content: (props: import("./LayerDialog.types").LayerDialogContentProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Title: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "id"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, "id"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Body: (props: import("./LayerDialog.types").LayerDialogBodyProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Actions: (props: import("./LayerDialog.types").LayerDialogActionsProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Action: (props: Omit<import("..").ButtonProps, "size" | "as" | "children" | "variant" | "block"> & {
+        children: React.ReactNode;
+        variant?: import("./LayerDialog.types").LayerDialogActionVariant;
+        menu?: React.ReactNode[];
+        menuLabel?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { LayerDialogAlert, LayerDialogTrigger, LayerDialogContent, LayerDialogTitle, LayerDialogDescription, LayerDialogBody, LayerDialogActions, LayerDialogAction, };
+export { LayerDialogContext, useLayerDialogContext } from "./LayerDialogContext";
+export * from "./LayerDialog.types";

package/build/components/layer-dialog/useLayerDialog.d.ts

@@ -0,0 +1,6 @@
+import type { LayerDialogContextValue, LayerDialogProps } from "./LayerDialog.types";
+type UseLayerDialogProps = Omit<LayerDialogProps, "children"> & {
+    alert: boolean;
+};
+export declare const useLayerDialog: (props: UseLayerDialogProps) => LayerDialogContextValue;
+export {};

package/build/components/tag-input/TagInput.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof import("./TagInput.types").UseTagInputProps> & import("./TagInput.types").UseTagInputProps & {
+    size?: import("..").TextInputSize;
+    block?: boolean;
+    contrast?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;