@gamecrafters/base-ui 0.0.6 → 0.0.7

package/build/components/code/Code.d.ts

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

package/build/components/code/Code.types.d.ts

@@ -0,0 +1,5 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type CodeProps<As extends React.ElementType = "code"> = PolymorphicProps<As, "code", {
+    className?: string;
+}>;

package/build/components/code/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Code } from "./Code";
+export * from "./Code.types";

package/build/components/code-block/CodeBlock.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "div" : As> & {
+    language?: import("./CodeBlock.types").CodeBlockLanguage;
+    lightTheme?: import("./CodeBlock.types").CodeBlockTheme;
+    darkTheme?: import("./CodeBlock.types").CodeBlockTheme;
+    showLineNumbers?: boolean;
+    wrap?: import("./CodeBlock.types").CodeBlockWrap;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/code-block/CodeBlock.types.d.ts

@@ -0,0 +1,40 @@
+import type * as React from "react";
+import type { BundledLanguage, BundledTheme, SpecialLanguage } from "shiki";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type CodeBlockLanguage = BundledLanguage | SpecialLanguage;
+export type CodeBlockTheme = BundledTheme;
+export type CodeBlockWrap = "wrap" | "nowrap";
+export type CodeBlockToken = {
+    content: string;
+    style?: Record<string, string>;
+};
+export type CodeBlockLine = CodeBlockToken[];
+export type CodeBlockProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    language?: CodeBlockLanguage;
+    lightTheme?: CodeBlockTheme;
+    darkTheme?: CodeBlockTheme;
+    showLineNumbers?: boolean;
+    wrap?: CodeBlockWrap;
+    className?: string;
+}>;
+export type CodeBlockHeaderProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type CodeBlockTitleProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    className?: string;
+}>;
+export type CodeBlockContentProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type CodeBlockCodeProps = Omit<React.ComponentPropsWithoutRef<"pre">, "children"> & {
+    children?: string;
+    language?: CodeBlockLanguage;
+    className?: string;
+};
+export type CodeBlockContextValue = {
+    language?: CodeBlockLanguage;
+    lightTheme?: CodeBlockTheme;
+    darkTheme?: CodeBlockTheme;
+    showLineNumbers?: boolean;
+    wrap?: CodeBlockWrap;
+};

package/build/components/code-block/CodeBlockCode.d.ts

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

package/build/components/code-block/CodeBlockContent.d.ts

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

package/build/components/code-block/CodeBlockContext.d.ts

@@ -0,0 +1,2 @@
+import type { CodeBlockContextValue } from "./CodeBlock.types";
+export declare const CodeBlockContext: import("react").Context<CodeBlockContextValue>;

package/build/components/code-block/CodeBlockHeader.d.ts

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

package/build/components/code-block/CodeBlockTitle.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/code-block/highlightCode.d.ts

@@ -0,0 +1,12 @@
+import type { CodeBlockLanguage, CodeBlockLine, CodeBlockTheme } from "./CodeBlock.types";
+export declare const DEFAULT_LANGUAGE = "text";
+export declare const DEFAULT_LIGHT_THEME = "github-light";
+export declare const DEFAULT_DARK_THEME = "github-dark";
+type HighlightOptions = {
+    language: CodeBlockLanguage;
+    lightTheme: CodeBlockTheme;
+    darkTheme: CodeBlockTheme;
+};
+export declare const toPlainLines: (code: string) => CodeBlockLine[];
+export declare const highlightLines: (code: string, options: HighlightOptions) => Promise<CodeBlockLine[]>;
+export {};

package/build/components/code-block/index.d.ts

@@ -0,0 +1,38 @@
+import CodeBlockCode from "./CodeBlockCode";
+import CodeBlockContent from "./CodeBlockContent";
+import CodeBlockHeader from "./CodeBlockHeader";
+import CodeBlockTitle from "./CodeBlockTitle";
+export declare const CodeBlock: (<As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+    language?: import("./CodeBlock.types").CodeBlockLanguage;
+    lightTheme?: import("./CodeBlock.types").CodeBlockTheme;
+    darkTheme?: import("./CodeBlock.types").CodeBlockTheme;
+    showLineNumbers?: boolean;
+    wrap?: import("./CodeBlock.types").CodeBlockWrap;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Header: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Title: <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;
+    Content: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Code: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLPreElement>, HTMLPreElement>, "ref">, "children"> & {
+        children?: string;
+        language?: import("./CodeBlock.types").CodeBlockLanguage;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { CodeBlockHeader, CodeBlockTitle, CodeBlockContent, CodeBlockCode };
+export { CodeBlockContext } from "./CodeBlockContext";
+export * from "./CodeBlock.types";

package/build/components/highlight/Highlight.d.ts

@@ -0,0 +1,11 @@
+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> & {
+    children?: string;
+    match?: import("./Highlight.types").HighlightMatch;
+    caseSensitive?: boolean;
+    variant?: import("..").MarkVariant;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/highlight/Highlight.types.d.ts

@@ -0,0 +1,15 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { MarkVariant } from "../mark";
+export type HighlightMatch = string | string[];
+export type HighlightChunk = {
+    text: string;
+    matched: boolean;
+};
+export type HighlightProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    children?: string;
+    match?: HighlightMatch;
+    caseSensitive?: boolean;
+    variant?: MarkVariant;
+    className?: string;
+}>;

package/build/components/highlight/highlightMatches.d.ts

@@ -0,0 +1,2 @@
+import type { HighlightChunk, HighlightMatch } from "./Highlight.types";
+export declare const splitHighlightChunks: (text: string, match?: HighlightMatch, caseSensitive?: boolean) => HighlightChunk[];

package/build/components/highlight/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Highlight } from "./Highlight";
+export { splitHighlightChunks } from "./highlightMatches";
+export * from "./Highlight.types";

package/build/components/index.d.ts

@@ -20,6 +20,8 @@ export * from "./carousel";
 export * from "./chart";
 export * from "./checkbox";
 export * from "./checkbox-group";
+export * from "./code";
+export * from "./code-block";
 export * from "./collapsible";
 export * from "./command-palette";
 export * from "./confirmation-dialog";
@@ -35,6 +37,7 @@ export * from "./filtered-action-list";
 export * from "./form-control";
 export * from "./heading";
 export * from "./hidden";
+export * from "./highlight";
 export * from "./icon-button";
 export * from "./image";
 export * from "./inline-message";
@@ -42,6 +45,8 @@ export * from "./keybinding-hint";
 export * from "./label";
 export * from "./link";
 export * from "./link-button";
+export * from "./mark";
+export * from "./markdown";
 export * from "./nav-list";
 export * from "./page-content";
 export * from "./page-footer";
@@ -52,9 +57,12 @@ export * from "./pagination";
 export * from "./placeholder";
 export * from "./portal";
 export * from "./progress-bar";
+export * from "./progress-circle";
 export * from "./radio";
 export * from "./radio-group";
+export * from "./rating";
 export * from "./relative-time";
+export * from "./rich-text-editor";
 export * from "./scrollable-region";
 export * from "./segmented-control";
 export * from "./select";
@@ -67,6 +75,7 @@ export * from "./slider";
 export * from "./spinner";
 export * from "./stack";
 export * from "./state-label";
+export * from "./status";
 export * from "./tabs";
 export * from "./text";
 export * from "./text-input";

package/build/components/mark/Mark.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import type { MarkSize, MarkVariant, MarkWeight } from "./Mark.types";
+declare const _default: <As extends React.ElementType = "mark">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "mark" : As> & {
+    variant?: MarkVariant;
+    size?: MarkSize;
+    weight?: MarkWeight;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/mark/Mark.types.d.ts

@@ -0,0 +1,11 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type MarkVariant = "attention" | "accent" | "success" | "danger" | "neutral";
+export type MarkSize = "large" | "medium" | "small";
+export type MarkWeight = "light" | "normal" | "medium" | "semibold";
+export type MarkProps<As extends React.ElementType = "mark"> = PolymorphicProps<As, "mark", {
+    variant?: MarkVariant;
+    size?: MarkSize;
+    weight?: MarkWeight;
+    className?: string;
+}>;

package/build/components/mark/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Mark } from "./Mark";
+export * from "./Mark.types";

package/build/components/markdown/Markdown.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    children?: string;
+    transformers?: import("@lexical/markdown").Transformer[];
+    preserveNewLines?: boolean;
+    namespace?: string;
+    onError?: (error: Error, editor: import("lexical").LexicalEditor) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/markdown/Markdown.types.d.ts

@@ -0,0 +1,17 @@
+import type * as React from "react";
+import type { Transformer } from "@lexical/markdown";
+import type { LexicalEditor } from "lexical";
+export type MarkdownProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & {
+    children?: string;
+    transformers?: Transformer[];
+    preserveNewLines?: boolean;
+    namespace?: string;
+    onError?: (error: Error, editor: LexicalEditor) => void;
+    className?: string;
+};
+export type MarkdownProseProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & {
+    source: string;
+    transformers: Transformer[];
+    preserveNewLines?: boolean;
+    className?: string;
+};

package/build/components/markdown/MarkdownProse.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    source: string;
+    transformers: import("@lexical/markdown").Transformer[];
+    preserveNewLines?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/markdown/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Markdown } from "./Markdown";
+export { DEFAULT_MARKDOWN_NAMESPACE, markdownTheme, MARKDOWN_NODES, MARKDOWN_TRANSFORMERS, } from "./markdownTheme";
+export * from "./Markdown.types";

package/build/components/markdown/markdownTheme.d.ts

@@ -0,0 +1,6 @@
+import type { Transformer } from "@lexical/markdown";
+import type { EditorThemeClasses, Klass, LexicalNode } from "lexical";
+export declare const DEFAULT_MARKDOWN_NAMESPACE = "Markdown";
+export declare const MARKDOWN_NODES: readonly Klass<LexicalNode>[];
+export declare const MARKDOWN_TRANSFORMERS: Transformer[];
+export declare const markdownTheme: EditorThemeClasses;

package/build/components/progress-circle/ProgressCircle.d.ts

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

package/build/components/progress-circle/ProgressCircle.types.d.ts

@@ -0,0 +1,10 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type ProgressCircleSize = "small" | "medium" | "large";
+export type ProgressCircleVariant = "accent" | "attention" | "danger" | "done" | "neutral" | "severe" | "sponsors" | "success";
+export type ProgressCircleProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    progress?: number;
+    size?: ProgressCircleSize;
+    variant?: ProgressCircleVariant;
+    className?: string;
+}>;

package/build/components/progress-circle/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ProgressCircle } from "./ProgressCircle";
+export * from "./ProgressCircle.types";

package/build/components/rating/Rating.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import type { RatingSize } from "./Rating.types";
+export declare const DEFAULT_RATING_COUNT = 5;
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, "onChange" | "defaultValue"> & {
+    count?: number;
+    value?: number;
+    defaultValue?: number;
+    size?: RatingSize;
+    readOnly?: boolean;
+    disabled?: boolean;
+    clearable?: boolean;
+    name?: string;
+    onChange?: (value: number) => void;
+    itemLabel?: (value: number, count: number) => string;
+    valueLabel?: (value: number, count: number) => string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/rating/Rating.types.d.ts

@@ -0,0 +1,16 @@
+import type * as React from "react";
+export type RatingSize = "small" | "medium" | "large";
+export type RatingProps = Omit<React.ComponentPropsWithoutRef<"span">, "onChange" | "defaultValue"> & {
+    count?: number;
+    value?: number;
+    defaultValue?: number;
+    size?: RatingSize;
+    readOnly?: boolean;
+    disabled?: boolean;
+    clearable?: boolean;
+    name?: string;
+    onChange?: (value: number) => void;
+    itemLabel?: (value: number, count: number) => string;
+    valueLabel?: (value: number, count: number) => string;
+    className?: string;
+};

package/build/components/rating/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Rating, DEFAULT_RATING_COUNT } from "./Rating";
+export * from "./Rating.types";

package/build/components/rich-text-editor/RichTextEditor.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import type { LexicalEditor } from "lexical";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onChange"> & {
+    defaultValue?: import("@lexical/react/LexicalComposer").InitialEditorStateType;
+    onChange?: (editorState: import("lexical").EditorState, editor: LexicalEditor) => void;
+    placeholder?: string;
+    readOnly?: boolean;
+    nodes?: readonly (import("lexical").Klass<import("lexical").LexicalNode> | import("lexical").LexicalNodeReplacement)[];
+    namespace?: string;
+    onError?: (error: Error, editor: LexicalEditor) => void;
+    minHeight?: number;
+    maxHeight?: number;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/rich-text-editor/RichTextEditor.types.d.ts

@@ -0,0 +1,36 @@
+import type * as React from "react";
+import type { InitialEditorStateType } from "@lexical/react/LexicalComposer";
+import type { EditorState, Klass, LexicalEditor, LexicalNode, LexicalNodeReplacement } from "lexical";
+export type RichTextEditorControl = "history" | "inline" | "block" | "list" | "link";
+export type RichTextEditorBlockType = "paragraph" | "h1" | "h2" | "h3" | "quote" | "bullet" | "number";
+export type RichTextEditorTextFormat = "bold" | "italic" | "underline" | "strikethrough" | "code";
+export type RichTextEditorProps = Omit<React.ComponentPropsWithoutRef<"div">, "onChange"> & {
+    defaultValue?: InitialEditorStateType;
+    onChange?: (editorState: EditorState, editor: LexicalEditor) => void;
+    placeholder?: string;
+    readOnly?: boolean;
+    nodes?: readonly (Klass<LexicalNode> | LexicalNodeReplacement)[];
+    namespace?: string;
+    onError?: (error: Error, editor: LexicalEditor) => void;
+    minHeight?: number;
+    maxHeight?: number;
+    className?: string;
+};
+export type RichTextEditorToolbarProps = React.ComponentPropsWithoutRef<"div"> & {
+    controls?: readonly RichTextEditorControl[];
+    children?: React.ReactNode;
+    "aria-label"?: string;
+    className?: string;
+};
+export type RichTextEditorContentProps = Omit<React.ComponentPropsWithoutRef<"div">, "children" | "placeholder" | "aria-placeholder"> & {
+    className?: string;
+};
+export type RichTextEditorContextValue = {
+    readOnly?: boolean;
+    placeholder?: string;
+    minHeight?: number;
+    maxHeight?: number;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+};

package/build/components/rich-text-editor/RichTextEditorContent.d.ts

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

package/build/components/rich-text-editor/RichTextEditorContext.d.ts

@@ -0,0 +1,2 @@
+import type { RichTextEditorContextValue } from "./RichTextEditor.types";
+export declare const RichTextEditorContext: import("react").Context<RichTextEditorContextValue>;

package/build/components/rich-text-editor/RichTextEditorToolbar.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { RichTextEditorControl, RichTextEditorToolbarProps } from "./RichTextEditor.types";
+export declare const DEFAULT_RICH_TEXT_EDITOR_CONTROLS: readonly RichTextEditorControl[];
+declare function RichTextEditorToolbar(props: RichTextEditorToolbarProps): React.JSX.Element;
+declare namespace RichTextEditorToolbar {
+    var displayName: string;
+}
+export default RichTextEditorToolbar;

package/build/components/rich-text-editor/index.d.ts

@@ -0,0 +1,23 @@
+import RichTextEditorContent from "./RichTextEditorContent";
+import RichTextEditorToolbar from "./RichTextEditorToolbar";
+export declare const RichTextEditor: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onChange"> & {
+    defaultValue?: import("@lexical/react/LexicalComposer").InitialEditorStateType;
+    onChange?: (editorState: import("lexical").EditorState, editor: import("lexical").LexicalEditor) => void;
+    placeholder?: string;
+    readOnly?: boolean;
+    nodes?: readonly (import("lexical").Klass<import("lexical").LexicalNode> | import("lexical").LexicalNodeReplacement)[];
+    namespace?: string;
+    onError?: (error: Error, editor: import("lexical").LexicalEditor) => void;
+    minHeight?: number;
+    maxHeight?: number;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Toolbar: typeof RichTextEditorToolbar;
+    Content: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "aria-placeholder" | "children" | "placeholder"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { RichTextEditorToolbar, RichTextEditorContent };
+export { DEFAULT_RICH_TEXT_EDITOR_CONTROLS } from "./RichTextEditorToolbar";
+export { DEFAULT_RICH_TEXT_EDITOR_NAMESPACE, RICH_TEXT_EDITOR_NODES, richTextEditorTheme, } from "./richTextEditorTheme";
+export * from "./RichTextEditor.types";

package/build/components/rich-text-editor/richTextEditorTheme.d.ts

@@ -0,0 +1,4 @@
+import type { EditorThemeClasses, Klass, LexicalNode } from "lexical";
+export declare const DEFAULT_RICH_TEXT_EDITOR_NAMESPACE = "RichTextEditor";
+export declare const RICH_TEXT_EDITOR_NODES: readonly Klass<LexicalNode>[];
+export declare const richTextEditorTheme: EditorThemeClasses;

package/build/components/status/Status.d.ts

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

package/build/components/status/Status.types.d.ts

@@ -0,0 +1,19 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type StatusVariant = "accent" | "success" | "attention" | "severe" | "danger" | "done" | "neutral";
+export type StatusSize = "small" | "medium" | "large";
+export type StatusProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    variant?: StatusVariant;
+    size?: StatusSize;
+    srText?: string;
+    className?: string;
+}>;
+export type StatusIndicatorProps = React.ComponentPropsWithoutRef<"span"> & {
+    variant?: StatusVariant;
+    size?: StatusSize;
+    className?: string;
+};
+export type StatusContextValue = {
+    variant?: StatusVariant;
+    size?: StatusSize;
+};

package/build/components/status/StatusContext.d.ts

@@ -0,0 +1,2 @@
+import type { StatusContextValue } from "./Status.types";
+export declare const StatusContext: import("react").Context<StatusContextValue>;

package/build/components/status/StatusIndicator.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { StatusSize, StatusVariant } from "./Status.types";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    variant?: StatusVariant;
+    size?: StatusSize;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/status/index.d.ts

@@ -0,0 +1,17 @@
+import StatusIndicator from "./StatusIndicator";
+export declare const Status: (<As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+    variant?: import("./Status.types").StatusVariant;
+    size?: import("./Status.types").StatusSize;
+    srText?: string;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Indicator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        variant?: import("./Status.types").StatusVariant;
+        size?: import("./Status.types").StatusSize;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { StatusIndicator };
+export * from "./Status.types";

package/build/hooks/useSlots.d.ts

@@ -6,9 +6,6 @@ export type SlotConfig = Record<string, ComponentMatcher | ComponentAndPropsMatc
 type SlotElements<Config extends SlotConfig> = {
     [Property in keyof Config]: SlotValue<Config, Property>;
 };
-type SlotValue<Config, Property extends keyof Config> = Config[Property] extends React.ElementType ? React.ReactElement<React.ComponentPropsWithoutRef<Config[Property]>, Config[Property]> : Config[Property] extends readonly [
-    infer ElementType extends React.ElementType,
-    infer _testFn
-] ? React.ReactElement<React.ComponentPropsWithoutRef<ElementType>, ElementType> : never;
+type SlotValue<Config, Property extends keyof Config> = Config[Property] extends React.ElementType ? React.ReactElement<React.ComponentPropsWithoutRef<Config[Property]>, Config[Property]> : Config[Property] extends readonly [infer ElementType extends React.ElementType, infer _testFn] ? React.ReactElement<React.ComponentPropsWithoutRef<ElementType>, ElementType> : never;
 export declare const useSlots: <Config extends SlotConfig>(children: React.ReactNode, config: Config) => [Partial<SlotElements<Config>>, React.ReactNode[]];
 export {};

package/build/lib/qr-code/core/data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * QR Code data encoding and bitstream construction
+ */
+import type { ErrorCorrectionLevel, QRCodeOptions } from "./types";
+export interface EncodedData {
+    version: number;
+    ecLevel: ErrorCorrectionLevel;
+    bits: number[];
+}
+/**
+ * Encode text into QR code data bits with error correction
+ */
+export declare function encodeData(text: string, options?: QRCodeOptions): EncodedData;

package/build/lib/qr-code/core/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom error classes for qr-code
+ */
+export declare class QRCodeError extends Error {
+    name: string;
+}
+export declare class InvalidInputError extends QRCodeError {
+    name: string;
+}
+export declare class CapacityError extends QRCodeError {
+    name: string;
+}