mtxuilib 0.1.12 → 0.1.13

package/dist/lib/zod/meta.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export type TRPCMeta = Record<string, unknown>;
+export type Meta<TMeta = TRPCMeta> = TMeta & {
+    authRequired?: boolean;
+    role?: 'user' | 'admin';
+    curdTitle?: string;
+    curdView?: z.infer<typeof curdViewSchema>;
+    listView?: z.infer<typeof metaListViewSchema>;
+};
+export declare const metaListViewSchema: z.ZodObject<{
+    viewType: z.ZodOptional<z.ZodDefault<z.ZodEnum<["default", "grid", "table"]>>>;
+    titleFormat: z.ZodOptional<z.ZodString>;
+    listPaginateType: z.ZodOptional<z.ZodDefault<z.ZodEnum<["default", "infinite"]>>>;
+    listDefaultPageSize: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    initQueryParams: z.ZodOptional<z.ZodOptional<z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    viewType?: "table" | "default" | "grid" | undefined;
+    titleFormat?: string | undefined;
+    listPaginateType?: "default" | "infinite" | undefined;
+    listDefaultPageSize?: number | undefined;
+    initQueryParams?: any;
+}, {
+    viewType?: "table" | "default" | "grid" | undefined;
+    titleFormat?: string | undefined;
+    listPaginateType?: "default" | "infinite" | undefined;
+    listDefaultPageSize?: number | undefined;
+    initQueryParams?: any;
+}>;
+declare const curdViewSchema: z.ZodObject<{
+    viewHome: z.ZodDefault<z.ZodString>;
+    viewLayout: z.ZodDefault<z.ZodEnum<["default", "mail", "table"]>>;
+    routeShow: z.ZodDefault<z.ZodString>;
+    routeEdit: z.ZodDefault<z.ZodString>;
+    routeDelete: z.ZodDefault<z.ZodString>;
+    routeList: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    viewHome: string;
+    viewLayout: "table" | "default" | "mail";
+    routeShow: string;
+    routeEdit: string;
+    routeDelete: string;
+    routeList: string;
+}, {
+    viewHome?: string | undefined;
+    viewLayout?: "table" | "default" | "mail" | undefined;
+    routeShow?: string | undefined;
+    routeEdit?: string | undefined;
+    routeDelete?: string | undefined;
+    routeList?: string | undefined;
+}>;
+export {};

package/dist/lib/zod/msg.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const msgOpenBrowser: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;
+export type MsgOpenBrowser = z.infer<typeof msgOpenBrowser>;

package/dist/lib/zod/taskStatus.z.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare enum TASK_STATUS {
+    Init = 0,
+    Padding = 1,
+    Running = 2,
+    Paused = 3,
+    Terminated = 4
+}
+export declare const taskStatusSchema: z.ZodEffects<z.ZodEffects<z.ZodType<TASK_STATUS, z.ZodTypeDef, TASK_STATUS>, TASK_STATUS, TASK_STATUS>, number, TASK_STATUS>;
+export type TaskStatusSchema = z.infer<typeof taskStatusSchema>;
+export declare enum TASK_STATUS_V2 {
+    Init = 0,
+    Padding = 1,
+    fulfill = 2
+}
+export declare const taskStatusV2Schema: z.ZodEffects<z.ZodEffects<z.ZodType<TASK_STATUS, z.ZodTypeDef, TASK_STATUS>, TASK_STATUS, TASK_STATUS>, number, TASK_STATUS>;
+export type TaskStatusV2 = z.infer<typeof taskStatusV2Schema>;

package/dist/lib/zustand.d.ts

@@ -0,0 +1,5 @@
+import { StateStorage } from 'zustand/middleware';
+import { StateCreator, StoreMutatorIdentifier } from 'zustand/vanilla';
+export declare const customCookieStorage: StateStorage;
+export declare const hashStorage: StateStorage;
+export type ImmerStateCreator<T, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = [], U = T> = StateCreator<T, [...Mps, ['zustand/immer', never], ["zustand/devtools", never]], Mcs, U>;

package/dist/misc/CustomErrorRetry.d.ts

@@ -0,0 +1,4 @@
+export declare const CustomErrorRetry: (props: {
+    message?: string;
+    onRetry: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/misc/ExampleErrorDemo.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const ExampleError2: () => import("react/jsx-runtime").JSX.Element;
+export declare const ExampleError1: () => never;
+export declare const WiehErrorExample: import("react").ForwardRefExoticComponent<object & import("react").RefAttributes<any>>;

package/dist/misc/MtErrorBoundary.d.ts

@@ -0,0 +1,16 @@
+import { Component, ErrorInfo, ReactNode } from "react";
+interface Props {
+    children: ReactNode;
+    title?: string;
+}
+interface State {
+    hasError: boolean;
+    errorMessage: string | null;
+}
+export declare class MtErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<import("react").AwaitedReactNode> | null | undefined;
+}
+export default MtErrorBoundary;

package/dist/misc/MtErrorBoundary.stories.d.ts

@@ -0,0 +1,15 @@
+import type { StoryObj } from '@storybook/react';
+import MtErrorBoundary from './MtErrorBoundary';
+declare const meta: {
+    title: string;
+    component: typeof MtErrorBoundary;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Primary: Story;
+export declare const Secondary: Story;

package/dist/misc/MtErrorBoundaryV2.d.ts

@@ -0,0 +1,2 @@
+import type { PropsWithChildren } from "react";
+export declare const MtErrorBoundaryV2: (props: {} & PropsWithChildren) => import("react/jsx-runtime").JSX.Element;

package/dist/misc/MtErrorBoundaryV2.stories.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { StoryObj } from '@storybook/react';
+declare const meta: {
+    title: string;
+    component: (props: {
+        children?: import("react").ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    argTypes: {};
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Primary: Story;
+export declare const Secondary: Story;

package/dist/mtapp/History.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { type StateCreator } from "zustand/vanilla";
+export type HisSliceProps = {};
+export interface HisSliceState extends HisSliceProps {
+    _hasHydrated?: boolean;
+    setHasHydrated: (_hasHydrated: boolean) => void;
+    histories: any[];
+    canGoback: () => boolean;
+    setHist: (his: any) => void;
+}
+export declare const createHisSlice: StateCreator<HisSliceState, [
+], [
+], HisSliceState>;
+type MainState = HisSliceState;
+export declare const hisContext: import("react").Context<(Omit<import("zustand").StoreApi<HisSliceState>, "setState"> & {
+    setState(nextStateOrUpdater: HisSliceState | Partial<HisSliceState> | ((state: import("immer").WritableDraft<HisSliceState>) => void), shouldReplace?: boolean | undefined): void;
+}) | null>;
+type ModalProviderProps = React.PropsWithChildren<HisSliceProps>;
+export declare const HisProvider: (props: ModalProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DEFAULT_USE_SHALLOW = true;
+export declare function useHisStore(): MainState;
+export declare function useHisStore<T>(selector: (state: MainState) => T): T;
+export declare const useCanGoBack: () => boolean;
+export {};

package/dist/mtapp/MtAppProvider.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="react" />
+import { type StateCreator } from "zustand";
+export interface AppSliceProps {
+    debug?: boolean;
+    listviewLayout?: string;
+    cacheEnabled?: boolean;
+    layout?: string;
+    theme?: string;
+    params?: any;
+    globalSearchParams?: any;
+    openDebug?: boolean;
+    openFab?: boolean;
+    url?: string;
+    hostname: string;
+}
+export interface AppSliceState extends AppSliceProps {
+    _hasHydrated?: boolean;
+    setHasHydrated: (_hasHydrated: boolean) => void;
+    setDebug: (debug: boolean) => void;
+    setLayout: (layout: string) => void;
+    setGlobalSearchParams: (globalSearchParams: any) => void;
+    setOpenDebug: (openDebug: boolean) => void;
+    setCacheEnabled: (cacheEnabled: boolean) => void;
+    setOpenFab: (openFab: boolean) => void;
+    cmdHandler: (name: string, params?: any) => boolean;
+}
+export declare const createAppSlice: StateCreator<AppSliceState, [
+], [
+], AppSliceState>;
+type mtappState = AppSliceState;
+export declare const gomtmContext: import("react").Context<(Omit<Omit<Omit<import("zustand").StoreApi<AppSliceState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<AppSliceState, {
+            [k: string]: unknown;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => void | Promise<void>;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AppSliceState) => void) => () => void;
+        onFinishHydration: (fn: (state: AppSliceState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<AppSliceState, {
+            [k: string]: unknown;
+        }>>;
+    };
+}, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: AppSliceState | Partial<AppSliceState> | ((state: AppSliceState) => AppSliceState | Partial<AppSliceState>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: AppSliceState | Partial<AppSliceState> | ((state: import("immer").WritableDraft<AppSliceState>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}) | null>;
+type AppProviderProps = React.PropsWithChildren<AppSliceProps>;
+export declare const MtAppProvider: (props: AppProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare function useMtapp(): mtappState;
+export declare function useMtapp<T>(selector: (state: mtappState) => T): T;
+export {};

package/dist/mtedtior/AiButtons.d.ts

@@ -0,0 +1,10 @@
+export default function DemoAiButtons(props: {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openNode: boolean;
+    setOpenNode: (open: boolean) => void;
+    openLink: boolean;
+    setOpenLink: (open: boolean) => void;
+    openColor: boolean;
+    setOpenColor: (open: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/mtedtior/MtEditor.d.ts

@@ -0,0 +1,29 @@
+import type { Range } from "@tiptap/core";
+import { type ComponentProps, type PropsWithChildren } from "react";
+import { type StateCreator } from "zustand";
+import { type JSONContent } from "./components";
+export interface MtEditorProps {
+    open?: boolean;
+}
+interface MtEditorState extends MtEditorProps {
+    _hasHydrated?: boolean;
+    setHasHydrated: (_hasHydrated: boolean) => void;
+    setOpen: (open: boolean) => void;
+    setQuery: (query: string) => void;
+    range: Range | null;
+    query: string;
+    setRange: (range: Range | null) => void;
+}
+export declare const createMtEditorSlice: StateCreator<MtEditorState, [
+], [
+], MtEditorState>;
+export declare const MtEditorProvider: (props: PropsWithChildren<MtEditorProps>) => import("react/jsx-runtime").JSX.Element;
+export declare function useMtEditorStore<T>(selector: (state: MtEditorState) => T): T;
+export declare function MtEditor(props: {
+    content?: string | JSONContent;
+} & MtEditorProps & ComponentProps<typeof TailwindAdvancedEditor>): import("react/jsx-runtime").JSX.Element;
+export default function TailwindAdvancedEditor(props: {
+    onValueChange?: (content: any) => void;
+    content?: JSONContent | null;
+}): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/mtedtior/components/editor-bubble-item.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from "@tiptap/react";
+import type { ReactNode } from "react";
+interface EditorBubbleItemProps {
+    readonly children: ReactNode;
+    readonly asChild?: boolean;
+    readonly onSelect?: (editor: Editor) => void;
+}
+export declare const EditorBubbleItem: import("react").ForwardRefExoticComponent<EditorBubbleItemProps & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & import("react").RefAttributes<HTMLDivElement>>;
+export default EditorBubbleItem;

package/dist/mtedtior/components/editor-bubble.d.ts

@@ -0,0 +1,7 @@
+import type { BubbleMenuProps } from "@tiptap/react";
+import type { ReactNode } from "react";
+export interface EditorBubbleProps extends Omit<BubbleMenuProps, "editor"> {
+    readonly children: ReactNode;
+}
+export declare const EditorBubble: import("react").ForwardRefExoticComponent<EditorBubbleProps & import("react").RefAttributes<HTMLDivElement>>;
+export default EditorBubble;

package/dist/mtedtior/components/editor-command-item.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import type { Editor, Range } from "@tiptap/core";
+interface EditorCommandItemProps {
+    readonly onCommand: ({ editor, range, }: {
+        editor: Editor;
+        range: Range;
+    }) => void;
+}
+export declare const EditorCommandItem: import("react").ForwardRefExoticComponent<EditorCommandItemProps & Omit<Omit<{
+    children?: import("react").ReactNode;
+} & Omit<import("react").HTMLAttributes<HTMLDivElement>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean | undefined;
+    onSelect?: ((value: string) => void) | undefined;
+    value?: string | undefined;
+    forceMount?: boolean | undefined;
+} & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const EditorCommandEmpty: import("react").ForwardRefExoticComponent<Omit<{
+    children?: import("react").ReactNode;
+} & import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export default EditorCommandItem;

package/dist/mtedtior/components/editor-command.d.ts

@@ -0,0 +1,29 @@
+import type { Range } from "@tiptap/core";
+import type { FC } from "react";
+export declare const EditorCommandTunnelContext: import("react").Context<{
+    In: ({ children }: {
+        children: import("react").ReactNode;
+    }) => null;
+    Out: () => JSX.Element;
+}>;
+interface EditorCommandOutProps {
+    readonly query: string;
+    readonly range: Range;
+}
+export declare const EditorCommandOut: FC<EditorCommandOutProps>;
+export declare const EditorCommand: import("react").ForwardRefExoticComponent<Omit<{
+    children?: import("react").ReactNode;
+} & import("react").HTMLAttributes<HTMLDivElement> & {
+    label?: string | undefined;
+    shouldFilter?: boolean | undefined;
+    filter?: ((value: string, search: string) => number) | undefined;
+    defaultValue?: string | undefined;
+    value?: string | undefined;
+    onValueChange?: ((value: string) => void) | undefined;
+    loop?: boolean | undefined;
+    vimBindings?: boolean | undefined;
+} & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const EditorCommandList: import("react").ForwardRefExoticComponent<{
+    children?: import("react").ReactNode;
+} & import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/mtedtior/components/editor.d.ts

@@ -0,0 +1,21 @@
+import type { EditorProviderProps, JSONContent } from "@tiptap/react";
+import type { FC, ReactNode } from "react";
+export interface EditorProps {
+    readonly children: ReactNode;
+    readonly className?: string;
+}
+interface EditorRootProps {
+    readonly children: ReactNode;
+}
+export declare const EditorRoot: FC<EditorRootProps>;
+export type EditorContentProps = Omit<EditorProviderProps, "content"> & {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly initialContent?: JSONContent;
+};
+export declare const EditorContent: import("react").ForwardRefExoticComponent<Omit<EditorProviderProps, "content"> & {
+    readonly children?: ReactNode;
+    readonly className?: string | undefined;
+    readonly initialContent?: JSONContent | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/mtedtior/components/index.d.ts

@@ -0,0 +1,8 @@
+export { useCurrentEditor as useEditor } from "@tiptap/react";
+export { type Editor as EditorInstance } from "@tiptap/core";
+export type { JSONContent } from "@tiptap/react";
+export { EditorRoot, EditorContent, type EditorContentProps } from "./editor";
+export { EditorBubble } from "./editor-bubble";
+export { EditorBubbleItem } from "./editor-bubble-item";
+export { EditorCommand, EditorCommandList } from "./editor-command";
+export { EditorCommandItem, EditorCommandEmpty } from "./editor-command-item";

package/dist/mtedtior/content.d.ts

@@ -0,0 +1,132 @@
+export declare const exampleHtml = "\n<h1>exampleHtml</h1>\n<p>\nThis is still the text editor you\u2019re used to, but enriched with node views.\n</p>\n<react-component>\n<p>This is editable. You can create a new component by pressing Mod+Enter.</p>\n</react-component>\n<p>\nDid you see that? That\u2019s a React component. We are really living in the future.\n</p>\n";
+export declare const defaultEditorContent: {
+    type: string;
+    content: ({
+        type: string;
+        attrs: {
+            level: number;
+            language?: undefined;
+            tight?: undefined;
+            start?: undefined;
+            src?: undefined;
+            alt?: undefined;
+            title?: undefined;
+            width?: undefined;
+            height?: undefined;
+        };
+        content: {
+            type: string;
+            text: string;
+        }[];
+    } | {
+        type: string;
+        content: ({
+            type: string;
+            marks: {
+                type: string;
+                attrs: {
+                    href: string;
+                    target: string;
+                };
+            }[];
+            text: string;
+        } | {
+            type: string;
+            text: string;
+            marks?: undefined;
+        })[];
+        attrs?: undefined;
+    } | {
+        type: string;
+        attrs: {
+            language: null;
+            level?: undefined;
+            tight?: undefined;
+            start?: undefined;
+            src?: undefined;
+            alt?: undefined;
+            title?: undefined;
+            width?: undefined;
+            height?: undefined;
+        };
+        content: {
+            type: string;
+            text: string;
+        }[];
+    } | {
+        type: string;
+        attrs: {
+            tight: boolean;
+            start: number;
+            level?: undefined;
+            language?: undefined;
+            src?: undefined;
+            alt?: undefined;
+            title?: undefined;
+            width?: undefined;
+            height?: undefined;
+        };
+        content: {
+            type: string;
+            content: {
+                type: string;
+                content: ({
+                    type: string;
+                    text: string;
+                    marks?: undefined;
+                } | {
+                    type: string;
+                    marks: {
+                        type: string;
+                    }[];
+                    text: string;
+                })[];
+            }[];
+        }[];
+    } | {
+        type: string;
+        attrs: {
+            src: string;
+            alt: string;
+            title: string;
+            width: null;
+            height: null;
+            level?: undefined;
+            language?: undefined;
+            tight?: undefined;
+            start?: undefined;
+        };
+        content?: undefined;
+    } | {
+        type: string;
+        attrs?: undefined;
+        content?: undefined;
+    } | {
+        type: string;
+        content: {
+            type: string;
+            attrs: {
+                checked: boolean;
+            };
+            content: {
+                type: string;
+                content: ({
+                    type: string;
+                    text: string;
+                    marks?: undefined;
+                } | {
+                    type: string;
+                    marks: {
+                        type: string;
+                        attrs: {
+                            href: string;
+                            target: string;
+                        };
+                    }[];
+                    text: string;
+                })[];
+            }[];
+        }[];
+        attrs?: undefined;
+    })[];
+};

package/dist/mtedtior/extensions/ai-highlight.d.ts

@@ -0,0 +1,22 @@
+import { Mark, type Editor } from "@tiptap/core";
+export interface AIHighlightOptions {
+    HTMLAttributes: Record<string, any>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        AIHighlight: {
+            setAIHighlight: (attributes?: {
+                color: string;
+            }) => ReturnType;
+            toggleAIHighlight: (attributes?: {
+                color: string;
+            }) => ReturnType;
+            unsetAIHighlight: () => ReturnType;
+        };
+    }
+}
+export declare const inputRegex: RegExp;
+export declare const pasteRegex: RegExp;
+export declare const AIHighlight: Mark<AIHighlightOptions, any>;
+export declare const removeAIHighlight: (editor: Editor) => void;
+export declare const addAIHighlight: (editor: Editor, color?: string) => void;

package/dist/mtedtior/extensions/custom-keymap.d.ts

@@ -0,0 +1,10 @@
+import { Extension } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        customkeymap: {
+            selectTextWithinNodeBoundaries: () => ReturnType;
+        };
+    }
+}
+declare const CustomKeymap: Extension<any, any>;
+export default CustomKeymap;

package/dist/mtedtior/extensions/drag-and-drop.d.ts

@@ -0,0 +1,6 @@
+import { Extension } from "@tiptap/core";
+export interface DragHandleOptions {
+    dragHandleWidth: number;
+}
+declare const DragAndDrop: Extension<any, any>;
+export default DragAndDrop;

package/dist/mtedtior/extensions/image-resizer.d.ts

@@ -0,0 +1,2 @@
+import type { FC } from "react";
+export declare const ImageResizer: FC;

package/dist/mtedtior/extensions/index.d.ts

@@ -0,0 +1,12 @@
+import { InputRule } from "@tiptap/core";
+import TiptapImage from "@tiptap/extension-image";
+import TiptapLink from "@tiptap/extension-link";
+import { TaskItem } from "@tiptap/extension-task-item";
+import { TaskList } from "@tiptap/extension-task-list";
+import StarterKit from "@tiptap/starter-kit";
+import { ImageResizer } from "./image-resizer";
+import UpdatedImage from "./updated-image";
+declare const PlaceholderExtension: import("@tiptap/core").Extension<import("@tiptap/extension-placeholder").PlaceholderOptions, any>;
+declare const simpleExtensions: readonly [import("@tiptap/core").Mark<import("@tiptap/extension-underline").UnderlineOptions, any>, import("@tiptap/core").Mark<import("@tiptap/extension-text-style").TextStyleOptions, any>, import("@tiptap/core").Extension<import("@tiptap/extension-color").ColorOptions, any>, import("@tiptap/core").Mark<import("@tiptap/extension-highlight").HighlightOptions, any>, import("@tiptap/core").Extension<import("tiptap-markdown").MarkdownOptions, import("tiptap-markdown").MarkdownStorage>, import("@tiptap/core").Extension<any, any>, import("@tiptap/core").Extension<any, any>, import("@tiptap/core").Node<any, any>];
+declare const Horizontal: import("@tiptap/core").Node<import("@tiptap/extension-horizontal-rule").HorizontalRuleOptions, any>;
+export { Horizontal as HorizontalRule, ImageResizer, InputRule, PlaceholderExtension as Placeholder, StarterKit, TaskItem, TaskList, TiptapImage, TiptapLink, UpdatedImage, simpleExtensions, };

package/dist/mtedtior/extensions/slash-command.d.ts

@@ -0,0 +1,33 @@
+import type { Editor, Range } from "@tiptap/core";
+import { Extension } from "@tiptap/core";
+import type { ReactNode } from "react";
+declare const Command: Extension<any, any>;
+declare const renderItems: () => {
+    onStart: (props: {
+        editor: Editor;
+        clientRect: DOMRect;
+    }) => false | undefined;
+    onUpdate: (props: {
+        editor: Editor;
+        clientRect: DOMRect;
+    }) => void;
+    onKeyDown: (props: {
+        event: KeyboardEvent;
+    }) => any;
+    onExit: () => void;
+};
+export interface SuggestionItem {
+    title: string;
+    description: string;
+    icon: ReactNode;
+    searchTerms?: string[];
+    command?: (props: {
+        editor: Editor;
+        range: Range;
+    }) => void;
+}
+export declare const createSuggestionItems: (items: SuggestionItem[]) => SuggestionItem[];
+export declare const handleCommandNavigation: (event: KeyboardEvent) => true | undefined;
+export { Command, renderItems };
+export declare const suggestionItems: SuggestionItem[];
+export declare const slashCommand: Extension<any, any>;

package/dist/mtedtior/extensions/updated-image.d.ts

@@ -0,0 +1,2 @@
+declare const UpdatedImage: import("@tiptap/core").Node<import("@tiptap/extension-image").ImageOptions, any>;
+export default UpdatedImage;

package/dist/mtedtior/generative/ai-completion-command.d.ts

@@ -0,0 +1,5 @@
+declare const AICompletionCommands: ({ completion, onDiscard, }: {
+    completion: string;
+    onDiscard: () => void;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default AICompletionCommands;

package/dist/mtedtior/generative/ai-selector-commands.d.ts

@@ -0,0 +1,5 @@
+interface AISelectorCommandsProps {
+    onSelect: (value: string, option: string) => void;
+}
+declare const AISelectorCommands: ({ onSelect }: AISelectorCommandsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default AISelectorCommands;

package/dist/mtedtior/generative/ai-selector.d.ts

@@ -0,0 +1,6 @@
+interface AISelectorProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function AISelector({ onOpenChange }: AISelectorProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/mtedtior/generative/generative-menu-switch.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from "react";
+interface GenerativeMenuSwitchProps {
+    children: ReactNode;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+declare const GenerativeMenuSwitch: ({ children, open, onOpenChange, }: GenerativeMenuSwitchProps) => import("react/jsx-runtime").JSX.Element | undefined;
+export default GenerativeMenuSwitch;

package/dist/mtedtior/mtextesions/DemoComponent.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const DemoComponentExtesion: Node<any, any>;