osameditor 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,598 @@
+import * as React from 'react';
+import { CSSProperties } from 'react';
+import * as _tiptap_core from '@tiptap/core';
+import { AnyExtension, JSONContent, Editor, Node, Extension } from '@tiptap/core';
+import { UseEditorOptions } from '@tiptap/react';
+import { CodeBlockLowlightOptions } from '@tiptap/extension-code-block-lowlight';
+
+/**
+ * Storage layer types.
+ *
+ * `osameditor` never talks to a storage backend directly. It only ever calls an
+ * `UploadHandler`. Two ready-made handlers ship in the box:
+ *
+ *   - `createOsamStorageUploader()` — uploads through the `osamstorage` SDK
+ *   - `createVpsUploader()`         — POSTs the file to your own server / VPS
+ *
+ * You can also pass any function that matches `UploadHandler` to use a completely
+ * custom backend (S3 presigned URL, Cloudinary, UploadThing, etc.).
+ */
+/** The kind of asset. `osamstorage` only accepts these three. */
+type UploadKind = "image" | "video" | "pdf";
+interface UploadContext {
+    /** 0 - 100. Called repeatedly while the file transfers. */
+    onProgress?: (percent: number) => void;
+    /** Abort the upload (wired to the editor / dialog lifecycle). */
+    signal?: AbortSignal;
+    /** Detected kind, based on the file's MIME type. */
+    kind: UploadKind;
+}
+interface UploadResult {
+    /** Public URL of the stored asset. Required. */
+    url: string;
+    /** Defaults to the detected kind. */
+    kind?: UploadKind;
+    /** Poster / thumbnail image URL (useful for video). */
+    poster?: string;
+    /** Natural width in px, if known. */
+    width?: number;
+    /** Natural height in px, if known. */
+    height?: number;
+    /** Original file name. */
+    name?: string;
+    /** Anything else your backend returned — kept on the node as `data-*` is not, but available to callbacks. */
+    meta?: Record<string, unknown>;
+}
+/**
+ * The single function the editor uses to persist a file.
+ * Throw (or reject) to signal failure — the editor surfaces it to the user.
+ */
+type UploadHandler = (file: File, ctx: UploadContext) => Promise<UploadResult>;
+declare function detectKind(file: File): UploadKind;
+
+/**
+ * Every switch you can flip in the toolbar.
+ *
+ * Pass an array of these to `<OsamEditor toolbar={[...]} />` to build exactly the
+ * toolbar you want. `"|"` renders a divider; `"spacer"` pushes the rest to the
+ * right. Unknown / disabled features are silently skipped.
+ */
+type ToolbarItem = "bold" | "italic" | "underline" | "strike" | "code" | "color" | "highlight" | "clearFormatting" | "paragraph" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "headings" | "alignLeft" | "alignCenter" | "alignRight" | "alignJustify" | "hardBreak" | "bulletList" | "orderedList" | "taskList" | "indent" | "outdent" | "link" | "unlink" | "blockquote" | "codeBlock" | "image" | "imageUrl" | "mediaLibrary" | "youtube" | "instagram" | "video" | "embed" | "pdf" | "horizontalRule" | "undo" | "redo" | "fullscreen" | "source" | "customHtml" | "|" | "spacer";
+type ToolbarPreset = "full" | "blog" | "basic" | "minimal";
+interface HeadingConfig {
+    levels?: Array<1 | 2 | 3 | 4 | 5 | 6>;
+}
+interface LinkConfig {
+    /** Add `target="_blank"` control in the link dialog. Default `true`. */
+    allowTargetBlank?: boolean;
+    /** Show the `rel="nofollow"` / `rel="sponsored"` checkboxes. Default `true`. */
+    allowRelAttributes?: boolean;
+    /** `rel` applied to every link unless overridden in the dialog. */
+    defaultRel?: string | null;
+    /** Only allow these protocols. Default `["http", "https", "mailto", "tel"]`. */
+    protocols?: string[];
+    /** Auto-linkify URLs as you type / paste. Default `true`. */
+    autolink?: boolean;
+}
+interface ColorConfig {
+    /** Swatches shown in the color picker. */
+    colors?: string[];
+    /** Swatches shown in the highlight picker. */
+    highlights?: string[];
+}
+/** Alignment / text-wrap mode for an image. */
+type ImageAlign = "left" | "center" | "right";
+interface ImageConfig {
+    /** Allow the end user to drag-resize images. Default `true`. */
+    resizable?: boolean;
+    /** Allow a caption (`<figcaption>`) under images. Default `true`. */
+    caption?: boolean;
+    /**
+     * Allow alignment / text-wrap. `left` and `right` float the image so body text
+     * fills the rest of the row; `center` is a plain block. Default `true`.
+     */
+    align?: boolean;
+    /** Allow wrapping the image in a link (`<a><img></a>`). Default `true`. */
+    link?: boolean;
+    /** Accept attribute for the file picker. Default `"image/*"`. */
+    accept?: string;
+    /** Max file size in bytes. Images above this are rejected before upload. */
+    maxSize?: number;
+}
+interface UploadConfig {
+    /**
+     * Where files go. The only two supported models:
+     *   - `createOsamStorageUploader(...)` — upload through OsamStorage
+     *   - `createVpsUploader(...)` — POST to your own backend API
+     * (Any function matching `UploadHandler` also works.)
+     *
+     * If omitted, upload buttons are hidden but "by URL" buttons still work.
+     */
+    handler?: UploadHandler;
+    /** Accept video uploads (not just embeds). Default `true` when a handler is set. */
+    video?: boolean;
+    /** Accept PDF uploads. Default `true` when a handler is set. */
+    pdf?: boolean;
+    /** Global max upload size in bytes. */
+    maxSize?: number;
+}
+interface EmbedConfig {
+    /**
+     * Hostnames allowed for generic `embed` / iframe insertion. `"*"` allows any.
+     * Default is a curated list (YouTube, Vimeo, Instagram, Twitter/X, CodePen,
+     * CodeSandbox, Spotify, SoundCloud, Google Maps, Loom, Figma, GitHub Gist).
+     */
+    allowedHosts?: string[] | "*";
+    /** Default aspect ratio (`"16/9"`, `"4/3"`, `"1/1"`, …). Default `"16/9"`. */
+    defaultRatio?: string;
+}
+interface MediaLibraryItem {
+    url: string;
+    name?: string;
+    thumbnail?: string;
+}
+interface MediaLibraryConfig {
+    /**
+     * Your **GET** endpoint (string) or a function returning the list. The editor
+     * shows these images in a "Library" tab so the user can re-pick past uploads.
+     */
+    list: string | (() => Promise<Array<string | MediaLibraryItem>> | Array<string | MediaLibraryItem>);
+    /**
+     * Your **POST** endpoint (string) or a function. Called with the image URL
+     * after every successful upload so it lands in the user's library. POST body
+     * is `{ url }`.
+     */
+    save?: string | ((url: string, file?: File) => void | Promise<void>);
+    /** Extra headers for the GET / POST requests. */
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    /** `fetch` credentials mode. Default `"same-origin"`. */
+    credentials?: RequestCredentials;
+    /** Map an arbitrary GET response shape to the list. */
+    resolveList?: (response: any) => Array<string | MediaLibraryItem>;
+}
+interface HtmlConfig {
+    /** Show the whole-document "view source" toggle in the toolbar. Default `true`. */
+    sourceView?: boolean;
+    /** Allow inserting raw "Custom HTML/CSS" blocks. Default `true`. */
+    customBlock?: boolean;
+    /** Keep `style=""` attributes on paragraphs / headings / quotes. Default `true`. */
+    styleAttributes?: boolean;
+    /** Keep `class` / `id` attributes on paragraphs / headings / quotes. Default `true`. */
+    classAttributes?: boolean;
+    /**
+     * Also allow `<style>` blocks through the sanitizer. `<script>` and inline
+     * event handlers are **always** stripped. Default `false`.
+     */
+    allowStyleTags?: boolean;
+}
+/**
+ * Per-instance colors. Each maps to a CSS custom property on the editor root, so
+ * you can also set these in CSS if you prefer. All optional.
+ */
+interface OsamEditorTheme {
+    background?: string;
+    foreground?: string;
+    muted?: string;
+    border?: string;
+    accent?: string;
+    accentText?: string;
+    radius?: string | number;
+    fontFamily?: string;
+    monoFontFamily?: string;
+    /** Toolbar strip background. */
+    toolbarBackground?: string;
+    /** Toolbar button text/icon color. */
+    buttonColor?: string;
+    /** Toolbar button hover background. */
+    buttonHoverBackground?: string;
+    /** Active/"on" toolbar button background. */
+    buttonActiveBackground?: string;
+    /** Active/"on" toolbar button text color. */
+    buttonActiveColor?: string;
+    /** Editing surface background. */
+    contentBackground?: string;
+    /** Code / pre background. */
+    codeBackground?: string;
+}
+type OsamEditorLabels = Partial<Record<string, string>>;
+interface OsamEditorConfig {
+    /** Which buttons to show. An array of `ToolbarItem`, a preset name, or `false`. */
+    toolbar?: ToolbarItem[] | ToolbarPreset | false;
+    /** Placeholder shown when the document is empty. */
+    placeholder?: string;
+    /** Heading levels the schema allows. Also inferred from `h1`–`h6` toolbar items. */
+    heading?: HeadingConfig | false;
+    link?: LinkConfig | false;
+    color?: ColorConfig | false;
+    highlight?: ColorConfig | false;
+    image?: ImageConfig | false;
+    upload?: UploadConfig;
+    embed?: EmbedConfig | false;
+    /** The user's own image library, backed by their own GET/POST API. */
+    mediaLibrary?: MediaLibraryConfig;
+    /** Raw HTML / inline-CSS editing (source view + custom HTML block). */
+    html?: boolean | HtmlConfig;
+    /** Per-instance colors (editor surface, toolbar, buttons). */
+    theme?: OsamEditorTheme;
+    /** Show the small "powered by osamtech.com" credit. Default `true`. */
+    branding?: boolean;
+    /** Enable the task/checklist list. Inferred from the `taskList` toolbar item. */
+    taskList?: boolean;
+    /** Enable code blocks with syntax highlighting + a copy button. Inferred from `codeBlock`. */
+    codeBlock?: boolean | {
+        defaultLanguage?: string;
+        copyButton?: boolean;
+    };
+    /** Enable blockquotes. Inferred from `blockquote`. */
+    blockquote?: boolean;
+    /** Enable `<hr>`. Inferred from `horizontalRule`. */
+    horizontalRule?: boolean;
+    /** Enable text alignment. Inferred from any `align*` toolbar item. */
+    textAlign?: boolean | {
+        types?: string[];
+        alignments?: string[];
+        defaultAlignment?: string;
+    };
+    /** Extra raw TipTap extensions appended to the schema. */
+    extensions?: AnyExtension[] | ((base: AnyExtension[]) => AnyExtension[]);
+    /** Options forwarded to `StarterKit.configure(...)`. */
+    starterKit?: Record<string, unknown>;
+    /** Override any UI string. */
+    labels?: OsamEditorLabels;
+    /** `"ltr"` | `"rtl"`. Default `"ltr"`. */
+    dir?: "ltr" | "rtl";
+}
+
+interface ResolvedConfig {
+    toolbar: ToolbarItem[] | false;
+    placeholder: string;
+    dir: "ltr" | "rtl";
+    labels: Record<string, string>;
+    headingLevels: Array<1 | 2 | 3 | 4 | 5 | 6> | false;
+    link: false | {
+        allowTargetBlank: boolean;
+        allowRelAttributes: boolean;
+        defaultRel: string | null;
+        protocols: string[];
+        autolink: boolean;
+    };
+    color: false | {
+        colors: string[];
+    };
+    highlight: false | {
+        colors: string[];
+        multicolor: boolean;
+    };
+    image: false | {
+        resizable: boolean;
+        caption: boolean;
+        align: boolean;
+        link: boolean;
+        accept: string;
+        maxSize?: number;
+        allowUrl: boolean;
+        allowUpload: boolean;
+    };
+    upload: {
+        hasHandler: boolean;
+        video: boolean;
+        pdf: boolean;
+        maxSize?: number;
+    };
+    embed: false | {
+        allowedHosts: string[] | "*";
+        defaultRatio: string;
+    };
+    mediaLibrary: MediaLibraryConfig | false;
+    html: false | {
+        sourceView: boolean;
+        customBlock: boolean;
+        styleAttributes: boolean;
+        classAttributes: boolean;
+        allowStyleTags: boolean;
+    };
+    theme: OsamEditorTheme | undefined;
+    branding: boolean;
+    taskList: boolean;
+    codeBlock: false | {
+        defaultLanguage?: string;
+        copyButton: boolean;
+    };
+    blockquote: boolean;
+    horizontalRule: boolean;
+    textAlign: false | {
+        types: string[];
+        alignments: string[];
+        defaultAlignment: string;
+    };
+    starterKit: Record<string, unknown>;
+}
+declare function resolveConfig(input?: OsamEditorConfig): ResolvedConfig;
+
+interface UseOsamEditorOptions extends OsamEditorConfig {
+    /** Initial content: an HTML string or TipTap JSON. */
+    content?: string | JSONContent | null;
+    editable?: boolean;
+    autofocus?: UseEditorOptions["autofocus"];
+    /** Fired on every change with the current HTML + JSON. */
+    onUpdate?: (payload: {
+        html: string;
+        json: JSONContent;
+        editor: Editor;
+    }) => void;
+    onCreate?: (editor: Editor) => void;
+}
+interface OsamEditorController {
+    editor: Editor | null;
+    config: ResolvedConfig;
+}
+/**
+ * Lower-level hook: build a TipTap editor from an `OsamEditorConfig`. Use this
+ * when you want to render the toolbar and content area yourself. Most people
+ * should use `<OsamEditor />`.
+ */
+declare function useOsamEditor(options?: UseOsamEditorOptions): OsamEditorController;
+
+interface OsamEditorProps extends OsamEditorConfig {
+    /** Uncontrolled initial content (HTML string or TipTap JSON). */
+    defaultValue?: string | JSONContent;
+    /** Controlled content (HTML string or TipTap JSON). Pair with `onChange`. */
+    value?: string | JSONContent;
+    /** Called on every edit. `html` is always provided; `json` is the TipTap doc. */
+    onChange?: (html: string, extra: {
+        json: JSONContent;
+        editor: Editor;
+    }) => void;
+    /** Get the editor instance once it's ready. */
+    onReady?: (editor: Editor) => void;
+    editable?: boolean;
+    autofocus?: UseOsamEditorOptions["autofocus"];
+    className?: string;
+    style?: React.CSSProperties;
+    /** Min height of the editable area. Default `260`. */
+    minHeight?: number | string;
+    /** Where the toolbar sits. Default `"top"`. */
+    toolbarPosition?: "top" | "bottom" | "none";
+    /** Stick the toolbar to the top while scrolling. Default `false`. */
+    stickyToolbar?: boolean;
+    /** Start in fullscreen (fills the viewport). Default `false`. */
+    defaultFullscreen?: boolean;
+    /** Controlled fullscreen state. */
+    fullscreen?: boolean;
+    onFullscreenChange?: (fullscreen: boolean) => void;
+}
+declare function OsamEditor(props: OsamEditorProps): React.JSX.Element;
+
+interface OsamContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** HTML produced by the editor (`onChange` html / `editor.getHTML()`). */
+    html: string;
+    /** Load `hls.js` to play `.m3u8` videos outside Safari. Default `true`. */
+    hls?: boolean;
+}
+/**
+ * Render saved editor HTML on your site (blog post page, preview, …) with the
+ * same look as the editor. Pair with `import "osameditor/styles.css"`.
+ */
+declare function OsamContent({ html, hls, className, ...rest }: OsamContentProps): React.JSX.Element;
+
+interface ToolbarView {
+    fullscreen?: boolean;
+    onToggleFullscreen?: () => void;
+    sourceMode?: boolean;
+    onToggleSource?: () => void;
+}
+interface ToolbarProps {
+    editor: Editor;
+    config: ResolvedConfig;
+    uploadHandler?: UploadHandler;
+    view?: ToolbarView;
+}
+declare function Toolbar({ editor, config, uploadHandler, view }: ToolbarProps): React.JSX.Element | null;
+
+declare function buildExtensions(config: ResolvedConfig): AnyExtension[];
+declare function applyUserExtensions(base: AnyExtension[], extra: AnyExtension[] | ((base: AnyExtension[]) => AnyExtension[]) | undefined): AnyExtension[];
+
+declare const TOOLBAR_PRESETS: Record<ToolbarPreset, ToolbarItem[]>;
+declare function resolveToolbar(toolbar: ToolbarItem[] | ToolbarPreset | false | undefined): ToolbarItem[] | false;
+
+/** Turn a `theme` prop into inline CSS custom properties for the editor root. */
+declare function themeToStyle(theme: OsamEditorTheme | undefined): CSSProperties;
+
+/**
+ * Small, dependency-free HTML sanitizer for user-authored markup coming from the
+ * source view / custom-HTML block / paste.
+ *
+ * Policy: `<script>` and inline event handlers (`on*`) are **always** removed;
+ * `javascript:` URLs are neutralised. `<style>` blocks are removed unless
+ * `allowStyleTags` is set. Everything else is kept — this is deliberately
+ * permissive so authors can write real HTML/CSS, and matches the
+ * "inline style + class" trust level.
+ */
+interface SanitizeOptions {
+    allowStyleTags?: boolean;
+}
+declare function sanitizeHtml(input: string, opts?: SanitizeOptions): string;
+
+/** GET the user's image library through their own API. */
+declare function loadMediaLibrary(cfg: MediaLibraryConfig): Promise<MediaLibraryItem[]>;
+/** POST a freshly-uploaded image URL into the user's library. Best-effort. */
+declare function saveToMediaLibrary(cfg: MediaLibraryConfig, url: string, file?: File): Promise<void>;
+
+interface OsamStorageUploaderOptions {
+    /**
+     * Returns a short-lived OsamStorage token. Same contract as the `osamstorage`
+     * SDK: point it at your backend route that exchanges your secret MAIN_TOKEN
+     * for a temporary token.
+     *
+     * @example
+     * getToken: async () => {
+     *   const r = await fetch("/api/osam-token");
+     *   return (await r.json()).token;
+     * }
+     */
+    getToken: () => Promise<string> | string;
+    /** Passed straight through to `new OsamStorage(...)`. */
+    baseUrl?: string;
+    chunkSize?: number;
+    concurrency?: number;
+    maxAttempts?: number;
+    /**
+     * OsamStorage processes files asynchronously and the merge response shape can
+     * evolve, so you map it to a public URL here. The default tries the most
+     * common fields.
+     */
+    resolveUrl?: (data: any, file: File) => string | undefined | null;
+    /** Optional: map the merge response to a poster/thumbnail URL. */
+    resolvePoster?: (data: any, file: File) => string | undefined | null;
+    /**
+     * Provide the SDK instance yourself instead of letting this helper import
+     * `osamstorage`. Useful if you already configured one, or to control which
+     * adapter build is used.
+     */
+    client?: {
+        upload: (file: any, opts: any) => Promise<any>;
+    };
+}
+/**
+ * Upload handler backed by the `osamstorage` SDK (chunked upload, automatic
+ * image → WebP, video → HLS, PDF passthrough).
+ *
+ * `osamstorage` is an **optional** dependency — it's only required if you
+ * actually use this handler.
+ */
+declare function createOsamStorageUploader(options: OsamStorageUploaderOptions): UploadHandler;
+
+interface VpsUploaderOptions {
+    /**
+     * Your upload endpoint. Receives a `multipart/form-data` POST with the file
+     * under `fieldName` (default `"file"`).
+     *
+     * Can be a string or a function of the file (e.g. to route images and video
+     * to different endpoints).
+     */
+    endpoint: string | ((file: File, kind: ReturnType<typeof detectKind>) => string);
+    /** Form field name for the file. Default `"file"`. */
+    fieldName?: string;
+    /** Extra static form fields sent with every upload. */
+    fields?: Record<string, string> | ((file: File) => Record<string, string>);
+    /** Extra headers (auth tokens, etc.). Don't set `Content-Type` — the browser does. */
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    /** `fetch` credentials mode. Default `"same-origin"`. */
+    credentials?: RequestCredentials;
+    /**
+     * Map your JSON response to a public URL. Default tries `url`, `fileUrl`,
+     * `location`, `src`, `data.url`.
+     */
+    resolveUrl?: (data: any, file: File) => string | undefined | null;
+    /** Map your JSON response to a poster/thumbnail URL. */
+    resolvePoster?: (data: any, file: File) => string | undefined | null;
+}
+/**
+ * Upload handler that POSTs the file to your own server / VPS storage.
+ *
+ * Reports real progress via `XMLHttpRequest` (so the editor's progress bar
+ * works) and supports cancellation through `AbortSignal`.
+ */
+declare function createVpsUploader(options: VpsUploaderOptions): UploadHandler;
+
+interface ResizableImageOptions {
+    resizable: boolean;
+    caption: boolean;
+    align: boolean;
+    link: boolean;
+    HTMLAttributes: Record<string, unknown>;
+}
+/**
+ * Block image with alt / title / caption / alignment / drag-resize, and an
+ * optional wrapping link. `left` / `right` alignment **float** the image so body
+ * text fills the rest of the row; `center` is a plain block.
+ * Serializes to `<figure><a?><img></a?><figcaption?></figure>`.
+ */
+declare const ResizableImage: _tiptap_core.Node<ResizableImageOptions, any>;
+
+type EmbedProvider = "youtube" | "vimeo" | "instagram" | "twitter" | "video" | "pdf" | "iframe";
+interface ResolvedEmbed {
+    provider: EmbedProvider;
+    /** URL to load in the iframe / <video> / <object>. */
+    src: string;
+    /** The URL the user pasted. */
+    originalUrl: string;
+}
+/**
+ * Turn a pasted URL into something embeddable. Returns `null` if we can't.
+ */
+declare function resolveEmbed(raw: string, opts: {
+    allowedHosts: string[] | "*";
+    treatAsPdf?: boolean;
+    treatAsVideo?: boolean;
+}): ResolvedEmbed | null;
+
+interface EmbedAttributes {
+    src: string | null;
+    provider: EmbedProvider;
+    ratio: string;
+    title: string | null;
+    originalUrl: string | null;
+    align: "left" | "center" | "right" | null;
+    width: string | null;
+}
+interface EmbedOptions {
+    defaultRatio: string;
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        embed: {
+            setEmbed: (attrs: Partial<EmbedAttributes> & {
+                src: string;
+            }) => ReturnType;
+            updateEmbed: (attrs: Partial<EmbedAttributes>) => ReturnType;
+        };
+    }
+}
+/**
+ * One atom block node for every kind of rich media that isn't an image:
+ * YouTube / Vimeo / Instagram / generic iframe, self-hosted `<video>`
+ * (with lazy HLS support) and PDF documents.
+ */
+declare const Embed: Node<EmbedOptions, any>;
+
+type CodeBlockOptions = Partial<CodeBlockLowlightOptions> & {
+    copyButton: boolean;
+    languages: string[];
+};
+/**
+ * `CodeBlockLowlight` + a header with a language picker and a "Copy" button so
+ * readers can copy the snippet.
+ */
+declare const CodeBlock: _tiptap_core.Node<CodeBlockOptions, any>;
+
+interface CustomHtmlOptions {
+    allowStyleTags: boolean;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        customHtml: {
+            setCustomHtml: (html?: string) => ReturnType;
+        };
+    }
+}
+/**
+ * A raw HTML/CSS block. Renders sanitized markup; double-click (or the Edit
+ * button) to edit the source in a textarea.
+ */
+declare const CustomHtml: Node<CustomHtmlOptions, any>;
+
+interface PreserveAttributesOptions {
+    types: string[];
+    style: boolean;
+    classAttr: boolean;
+}
+/**
+ * Keeps `style` / `class` / `id` attributes on block nodes so inline CSS written
+ * in the source view (or pasted) survives a round-trip through the schema.
+ * Scoped to text blocks by default — not images/embeds, which manage their own.
+ */
+declare const PreserveAttributes: Extension<PreserveAttributesOptions, any>;
+
+export { CodeBlock, type ColorConfig, CustomHtml, Embed, type EmbedConfig, type HeadingConfig, type HtmlConfig, type ImageAlign, type ImageConfig, type LinkConfig, type MediaLibraryConfig, type MediaLibraryItem, OsamContent, type OsamContentProps, OsamEditor, type OsamEditorConfig, type OsamEditorController, type OsamEditorProps, type OsamEditorTheme, type OsamStorageUploaderOptions, PreserveAttributes, ResizableImage, type ResolvedConfig, type SanitizeOptions, TOOLBAR_PRESETS, Toolbar, type ToolbarItem, type ToolbarPreset, type UploadConfig, type UploadContext, type UploadHandler, type UploadKind, type UploadResult, type UseOsamEditorOptions, type VpsUploaderOptions, applyUserExtensions, buildExtensions, createOsamStorageUploader, createVpsUploader, detectKind, loadMediaLibrary, resolveConfig, resolveEmbed, resolveToolbar, sanitizeHtml, saveToMediaLibrary, themeToStyle, useOsamEditor };