import * as react from 'react';
import { ReactNode } from 'react';
import { E as ExtensiveEditorProps, a as ExtensiveEditorRef, F as FeatureFlagOverrides, d as EditorThemeOverrides, b as EditorPreset } from './index-DPw2EK7p.js';
import { E as ExtensivePresetConfig } from './preset-iV8kbSxN.js';

/**
 * Copyright (c) Luthor Team and contributors.
 * Open source under the MIT License (LICENSE).
 * Fork it. Remix it. Ship it.
 * Build freely. Credit kindly.
 */
type ClassNameToken = string | false | null | undefined;
type PresetFeatureOverrides<TFeature extends string> = Partial<Record<TFeature, boolean>>;
/**
 * Encapsulates default + enforced feature-flag composition for preset editors.
 */
declare class PresetFeaturePolicy<TFeature extends string> {
    private readonly defaults;
    private readonly enforced;
    constructor(defaults: PresetFeatureOverrides<TFeature>, enforced?: PresetFeatureOverrides<TFeature>);
    resolve(overrides?: PresetFeatureOverrides<TFeature>): PresetFeatureOverrides<TFeature>;
}
declare function joinClassNames(...tokens: readonly ClassNameToken[]): string;

/**
 * Copyright (c) Luthor Team and contributors.
 * Open source under the MIT License (LICENSE).
 * Fork it. Remix it. Ship it.
 * Build freely. Credit kindly.
 */
/** A reference to a note, by human title and/or stable id. */
interface PapyraNoteRef {
    /** The note's display title, as written inside `[[Title]]`. */
    title?: string;
    /** The note's stable id, when the host already resolved one. */
    id?: string;
}
/** A single note returned by {@link PapyraEditorAdapter.searchNotes}. */
interface PapyraNoteSearchResult {
    /** The note's stable id. */
    id: string;
    /** The note's display title. */
    title: string;
    /** Optional per-note tint, used to color the typeahead entry. */
    color?: string;
}
/** A reference to a specific block inside a note, for transclusion. */
interface PapyraBlockRef {
    /** The target note (title or id), as written before `#^`. */
    note: string;
    /** The block anchor id, as written after `#^`. */
    blockId: string;
}
/**
 * Archived metadata for a saved web card (`![[card:url]]`). The host returns
 * whatever it captured when it archived the page; every field is optional and
 * the card degrades to a bare link when a field (or the whole record) is absent.
 */
interface PapyraSavedCard {
    /** The page title. */
    title?: string;
    /** A short page summary. */
    description?: string;
    /** A preview/hero image URL. */
    image?: string;
    /** A site favicon URL. */
    favicon?: string;
    /** The human site name (e.g. "Wikipedia"). */
    siteName?: string;
}
/**
 * The entire contract between the `papyra` preset and its host.
 *
 * Luthor declares this interface; the host implements it. Keeping the surface
 * small and data-only is what lets the preset stay reusable: a different note app
 * can adopt PapyraEditor by supplying a different adapter, with no fork. Optional
 * members (`resolveBlock`, `onMentions`) gate capabilities the host may not need;
 * when they are absent the preset degrades gracefully (see
 * {@link createFallbackPapyraAdapter}) rather than throwing.
 */
interface PapyraEditorAdapter {
    /**
     * Resolve a media filename (the `file.ext` inside `![[file.ext]]`) to a URL the
     * browser can load. Synchronous so embeds can render their first frame without
     * a loading flash; the host typically returns a stable CDN/API URL.
     */
    resolveMediaUrl(filename: string): string;
    /**
     * Persist a dropped or pasted file and resolve to the stored filename the
     * editor should reference as `![[filename]]`. The host owns the upload endpoint
     * and its authorization.
     */
    uploadMedia(file: File): Promise<{
        filename: string;
    }>;
    /**
     * Navigate to a note. Invoked when the reader activates a `[[Note]]` wikilink.
     * The host owns routing; the editor only reports the intent.
     */
    openNote(ref: PapyraNoteRef): void;
    /**
     * Search notes for the `[[` typeahead. Resolves to the candidate notes for the
     * given query (already debounced by the host if needed).
     */
    searchNotes(query: string): Promise<PapyraNoteSearchResult[]>;
    /**
     * Resolve a transcluded block (`![[Note#^id]]`) to its rendered markdown, or
     * `null` when the host withholds it (missing, or denied by `PathGuard`/`401`).
     * Optional: hosts without transclusion omit it and the embed renders an
     * unresolved chip.
     */
    resolveBlock?(ref: PapyraBlockRef): Promise<string | null>;
    /**
     * Resolve a saved web card (`![[card:url]]`) to its archived metadata, or
     * `null` when the host has no record. Optional: hosts without a web archiver
     * omit it and the card renders as a bare link to the URL.
     */
    resolveCard?(url: string): Promise<PapyraSavedCard | null>;
    /**
     * Report `@username` mentions detected in the body, so the host can route an
     * inbox ping. Optional. Called by the host's save orchestration, never on
     * every keystroke.
     */
    onMentions?(usernames: string[]): void;
}
/**
 * A no-op adapter used when the host injects none. Every method degrades
 * gracefully instead of throwing, so `<PapyraEditor>` still renders, edits, and
 * round-trips its markdown without a host — embeds simply fall back to plain
 * references (media → its filename, wikilink → inert text, transclusion → an
 * unresolved chip). This keeps the preset usable in isolation (docs, tests,
 * Storybook) and upholds the markdown-source-of-truth invariant: the body is
 * never rewritten just because no adapter was supplied.
 */
declare function createFallbackPapyraAdapter(): PapyraEditorAdapter;
/**
 * Context carrying the active {@link PapyraEditorAdapter} to the embed nodes
 * rendered inside a PapyraEditor. Defaults to {@link createFallbackPapyraAdapter}
 * so a node read outside an explicit provider still gets a valid, graceful
 * adapter rather than `null`.
 */
declare const PapyraAdapterContext: react.Context<PapyraEditorAdapter>;
/**
 * Read the active {@link PapyraEditorAdapter}. Embed nodes and host glue call
 * this to reach the injected host services; it always returns a usable adapter
 * (the graceful fallback when none was provided).
 */
declare function usePapyraAdapter(): PapyraEditorAdapter;

/**
 * Modes Papyra ever exposes: the visual canvas and a raw markdown source view.
 * JSON/HTML are intentionally absent — markdown is the source of truth.
 */
declare const PAPYRA_AVAILABLE_MODES: readonly ["visual", "markdown"];
/**
 * Modes used while {@link PapyraEditorProps.readOnly | readOnly} is set. The
 * visual surface is mounted in `visual-only` (non-editable) so it can never
 * promote to an editable caret — there is no `visual-editor` mode to promote
 * into, and `editOnClick` is forced off — so the surface emits no edits. This is
 * what makes `readOnly` safe for time-machine scrubbing and revision previews.
 */
declare const PAPYRA_READONLY_MODES: readonly ["visual-only", "markdown"];
/** Marker class the wrapper carries for the wide-measure focus variant. */
declare const PAPYRA_FOCUS_VARIANT_CLASS = "luthor-preset-papyra--focus";
/** Marker class the wrapper carries while {@link PapyraEditorProps.locked}. */
declare const PAPYRA_LOCKED_VARIANT_CLASS = "luthor-preset-papyra--locked";
/**
 * Reading-surface variant. `default` is the standard editorial measure;
 * `focus` widens to a centered, distraction-free column and keeps the only
 * chrome (the floating toolbar) hidden until there is a selection.
 */
type PapyraEditorVariant = "default" | "focus";
/**
 * One heading in the document outline. The shape matches what Papyra's TOC
 * scrollbar consumes. `getOutline()` returns these in document order.
 *
 * @remarks Stubbed (returns `[]`) until Sprint 1.4 wires the live outline.
 */
interface PapyraOutlineHeading {
    /** Heading level, 1–6. */
    level: number;
    /** Plain-text heading content. */
    text: string;
    /** Stable node key, used by `scrollToHeading`. */
    key: string;
    /** Pixel offset of the heading from the top of the scroll container. */
    top: number;
}
/**
 * A trailing `^uuid` block anchor discovered in the body. Block anchors are
 * non-rendering and let Papyra address a specific block for transclusion.
 */
interface PapyraBlockAnchor {
    /** The anchor id (the part after `^`). */
    blockId: string;
    /** Stable node key of the anchored block. */
    key: string;
}
/**
 * Imperative handle a Papyra host captures through the React ref or `onReady`.
 * Extends {@link ExtensiveEditorRef} with the markdown-first surface Papyra
 * drives: `setMarkdown` (host-driven adopt), `focus`, the outline/block readers,
 * scroll-to-heading, and mention detection.
 */
interface PapyraEditorRef extends ExtensiveEditorRef {
    /**
     * Replace the body with parsed markdown. This is an explicit, host-driven
     * imperative call (used for time-machine scrubbing and remote adoption), not a
     * controlled value path — it never fires on keystrokes. The caret stays sacred
     * because the host decides when to call it.
     */
    setMarkdown: (markdown: string) => void;
    /** Move focus into the editable surface. */
    focus: () => void;
    /**
     * Current document outline in document order, read from the rendered editable
     * surface. Returns `[]` when no visual surface is mounted (e.g. the markdown
     * source view). Pair with {@link onOutlineChange} for a live table of contents.
     */
    getOutline: () => PapyraOutlineHeading[];
    /**
     * Scroll the heading addressed by `key` into view. Pass a `key` from a fresh
     * {@link getOutline} call (keys track document position).
     */
    scrollToHeading: (key: string) => void;
    /** All trailing `^uuid` block anchors in the body. */
    getBlocks: () => PapyraBlockAnchor[];
    /**
     * Distinct `@username` mentions in the body, in first-seen order. The host
     * routes these to its inbox via `adapter.onMentions` during its save
     * orchestration — the preset only detects, it never fires on keystrokes.
     */
    getMentions: () => string[];
}
/**
 * Props for {@link PapyraEditor}. This is {@link ExtensiveEditorProps} with the
 * locked contract removed — callers cannot reach the props Papyra owns:
 * `availableModes`, the view-tabs toggles, the pinned/enabled toolbar switches,
 * `markdownSourceOfTruth`, and `sourceMetadataMode`. `featureFlags` is re-opened
 * but routed through {@link papyraFeaturePolicy}, so the enforced restrictions
 * can never be switched back on. `onReady` is narrowed to the
 * {@link PapyraEditorRef}.
 *
 * Theming is token-driven: caller `editorThemeOverrides` are layered on top of
 * the Papyra token bridge (see {@link createPapyraThemeOverrides}), and the
 * `colored` flag light-locks tinted notes.
 */
type PapyraEditorProps = Omit<ExtensiveEditorProps, "availableModes" | "isEditorViewTabsVisible" | "isEditorViewsTabVisible" | "isToolbarEnabled" | "isToolbarPinned" | "toolbarLayout" | "isListStyleDropdownEnabled" | "markdownSourceOfTruth" | "sourceMetadataMode" | "extraExtensions" | "markdownExtraNodes" | "markdownExtraTransformers" | "headingOptions" | "slashCommandVisibility" | "extraSlashCommands" | "shortcutConfig" | "toolbarVisibility" | "onReady"> & {
    onReady?: (methods: PapyraEditorRef) => void;
    /**
     * Fired (debounced) whenever the document outline changes, with the current
     * outline in document order. Drives a host's live table-of-contents scrollbar.
     * Read-only observation of the rendered surface — it never touches the caret.
     * Omit it to skip outline tracking entirely.
     */
    onOutlineChange?: (outline: PapyraOutlineHeading[]) => void;
    /**
     * Light-lock for tinted ("colored") notes. When the host paints the note
     * paper with a per-note tint, set this so the editor stays on its light
     * editorial palette regardless of the ambient app theme — otherwise ink can
     * wash out on the tint. Forces `initialTheme="light"` and adds the colored
     * variant class. Defaults to `false`.
     */
    colored?: boolean;
    /**
     * Render the note as a non-editable surface. The host decides *when* (revision
     * preview, time-machine scrubbing, a read-only share); the preset decides
     * *how* — the visual surface mounts in `visual-only` mode with click-to-edit
     * promotion disabled, so it never produces an editable caret and emits no
     * change events. Pair with repeated `setMarkdown` calls for time-machine
     * scrubbing without arming autosave. Defaults to `false`.
     */
    readOnly?: boolean;
    /**
     * Reading-surface variant. `"focus"` widens the body to a centered,
     * distraction-free measure and keeps chrome out of the way until there is a
     * selection; `"default"` is the standard editorial measure. The host decides
     * when to enter focus mode. Defaults to `"default"`.
     */
    variant?: PapyraEditorVariant;
    /**
     * Show a persistent toolbar above the editor. By default Papyra ships
     * **chrome-light** — its only toolbar is the floating-on-selection one (plus
     * slash `/` and the command palette), per the preset's minimal-chrome
     * contract. Set this to opt into an always-visible toolbar restricted to
     * Papyra's markdown-safe actions (see {@link PAPYRA_TOOLBAR_LAYOUT}): history,
     * headings/paragraph, quote, bold/italic/strikethrough/inline-code/link,
     * lists + checklist, code block, horizontal rule, table, and image. The
     * restricted controls (typography pickers, color/highlight, sub/superscript,
     * alignment, theme toggle) can never appear — they stay pinned off by the
     * toolbar visibility contract and the enforced feature policy. The toolbar is
     * not pinned/sticky (the pinned toolbar stays enforced off) and only renders
     * in the editable visual surface, so `readOnly`/`locked` never show it.
     * Defaults to `false`.
     */
    toolbar?: boolean;
    /**
     * Withhold the body entirely. When `true`, the preset renders a blurred
     * placeholder and **never mounts the editor or the note's text** — there is no
     * plaintext in the DOM to scrape. This is the UX half of Papyra's secure
     * notes: the host keeps `locked` set while its server withholds the body
     * (`401`/`PathGuard`), then flips it off and remounts (new React `key`) with
     * the decrypted body once the note is unlocked. The lock is never the security
     * boundary — the server is — but it guarantees the editor leaks nothing.
     * Defaults to `false`.
     */
    locked?: boolean;
    /**
     * Custom content for the {@link locked} placeholder. Omit it for the default
     * blurred lock surface. Whatever is passed renders *instead of* the note body,
     * so it must not contain the note's plaintext.
     */
    lockedPlaceholder?: ReactNode;
    /**
     * The host seam. Supplies the editor with media resolution, uploads, note
     * search/navigation, and block resolution for the Papyra embeds
     * (`![[media]]`, `[[Note]]`, `![[Note#^id]]`). When omitted, the preset uses a
     * graceful no-op adapter (see {@link createFallbackPapyraAdapter}) so the
     * editor still renders and round-trips its markdown without a host. The
     * adapter is the only data path out of the editor, and its resolvers are where
     * the host's server-side authorization lives — the editor's blur/lock UX is
     * never the security boundary.
     */
    adapter?: PapyraEditorAdapter;
};
/**
 * `<PapyraEditor>` — the markdown-native note canvas Papyra ships.
 *
 * A thin wrapper over {@link ExtensiveEditor} that hard-locks Papyra's contract:
 * a visual + markdown-source surface, no view tabs, no pinned/persistent
 * toolbar (floating-on-selection only), markdown as the source of truth, and a
 * metadata-free source conversion (`sourceMetadataMode="none"`) so the body
 * never carries an envelope. Caller `featureFlags` are resolved through
 * {@link papyraFeaturePolicy}; the enforced restrictions cannot be re-enabled.
 *
 * **Uncontrolled by design.** The editor reads `defaultContent` once on mount
 * and never again — there is no `value`/`onChange` round-trip. Adopting a remote
 * revision is a host-driven remount (change the React `key`) or an explicit
 * `setMarkdown` call, never a live-DOM patch on keystroke. Read the body
 * imperatively through the ref (or the ref handed to `onReady`). This is what
 * keeps the caret sacred during Papyra's local-first sync.
 */
declare const PapyraEditor: react.ForwardRefExoticComponent<Omit<ExtensiveEditorProps, "headingOptions" | "slashCommandVisibility" | "availableModes" | "toolbarVisibility" | "isListStyleDropdownEnabled" | "onReady" | "toolbarLayout" | "isToolbarEnabled" | "isToolbarPinned" | "isEditorViewTabsVisible" | "extraSlashCommands" | "shortcutConfig" | "sourceMetadataMode" | "markdownSourceOfTruth" | "isEditorViewsTabVisible" | "extraExtensions" | "markdownExtraNodes" | "markdownExtraTransformers"> & {
    onReady?: (methods: PapyraEditorRef) => void;
    /**
     * Fired (debounced) whenever the document outline changes, with the current
     * outline in document order. Drives a host's live table-of-contents scrollbar.
     * Read-only observation of the rendered surface — it never touches the caret.
     * Omit it to skip outline tracking entirely.
     */
    onOutlineChange?: (outline: PapyraOutlineHeading[]) => void;
    /**
     * Light-lock for tinted ("colored") notes. When the host paints the note
     * paper with a per-note tint, set this so the editor stays on its light
     * editorial palette regardless of the ambient app theme — otherwise ink can
     * wash out on the tint. Forces `initialTheme="light"` and adds the colored
     * variant class. Defaults to `false`.
     */
    colored?: boolean;
    /**
     * Render the note as a non-editable surface. The host decides *when* (revision
     * preview, time-machine scrubbing, a read-only share); the preset decides
     * *how* — the visual surface mounts in `visual-only` mode with click-to-edit
     * promotion disabled, so it never produces an editable caret and emits no
     * change events. Pair with repeated `setMarkdown` calls for time-machine
     * scrubbing without arming autosave. Defaults to `false`.
     */
    readOnly?: boolean;
    /**
     * Reading-surface variant. `"focus"` widens the body to a centered,
     * distraction-free measure and keeps chrome out of the way until there is a
     * selection; `"default"` is the standard editorial measure. The host decides
     * when to enter focus mode. Defaults to `"default"`.
     */
    variant?: PapyraEditorVariant;
    /**
     * Show a persistent toolbar above the editor. By default Papyra ships
     * **chrome-light** — its only toolbar is the floating-on-selection one (plus
     * slash `/` and the command palette), per the preset's minimal-chrome
     * contract. Set this to opt into an always-visible toolbar restricted to
     * Papyra's markdown-safe actions (see {@link PAPYRA_TOOLBAR_LAYOUT}): history,
     * headings/paragraph, quote, bold/italic/strikethrough/inline-code/link,
     * lists + checklist, code block, horizontal rule, table, and image. The
     * restricted controls (typography pickers, color/highlight, sub/superscript,
     * alignment, theme toggle) can never appear — they stay pinned off by the
     * toolbar visibility contract and the enforced feature policy. The toolbar is
     * not pinned/sticky (the pinned toolbar stays enforced off) and only renders
     * in the editable visual surface, so `readOnly`/`locked` never show it.
     * Defaults to `false`.
     */
    toolbar?: boolean;
    /**
     * Withhold the body entirely. When `true`, the preset renders a blurred
     * placeholder and **never mounts the editor or the note's text** — there is no
     * plaintext in the DOM to scrape. This is the UX half of Papyra's secure
     * notes: the host keeps `locked` set while its server withholds the body
     * (`401`/`PathGuard`), then flips it off and remounts (new React `key`) with
     * the decrypted body once the note is unlocked. The lock is never the security
     * boundary — the server is — but it guarantees the editor leaks nothing.
     * Defaults to `false`.
     */
    locked?: boolean;
    /**
     * Custom content for the {@link locked} placeholder. Omit it for the default
     * blurred lock surface. Whatever is passed renders *instead of* the note body,
     * so it must not contain the note's plaintext.
     */
    lockedPlaceholder?: ReactNode;
    /**
     * The host seam. Supplies the editor with media resolution, uploads, note
     * search/navigation, and block resolution for the Papyra embeds
     * (`![[media]]`, `[[Note]]`, `![[Note#^id]]`). When omitted, the preset uses a
     * graceful no-op adapter (see {@link createFallbackPapyraAdapter}) so the
     * editor still renders and round-trips its markdown without a host. The
     * adapter is the only data path out of the editor, and its resolvers are where
     * the host's server-side authorization lives — the editor's blur/lock UX is
     * never the security boundary.
     */
    adapter?: PapyraEditorAdapter;
} & react.RefAttributes<PapyraEditorRef>>;

/**
 * Copyright (c) Luthor Team and contributors.
 * Open source under the MIT License (LICENSE).
 * Fork it. Remix it. Ship it.
 * Build freely. Credit kindly.
 */

/**
 * Default feature flags for the Papyra note canvas.
 *
 * These describe Papyra's curated writing surface: the formatting and block
 * primitives that round-trip cleanly to CommonMark plus the small documented
 * Papyra extension set. A caller may switch any of these off (turn off tables on
 * a constrained surface, for example), but cannot turn the {@link
 * PAPYRA_FEATURE_ENFORCED} restrictions back on.
 *
 * Anything absent from this map keeps the underlying extensive default, except
 * the features explicitly disabled below because they have no lossless markdown
 * representation (underline) or arrive later as dedicated lossless nodes
 * (iframe/YouTube embeds land in Sprint 1.5).
 */
declare const PAPYRA_FEATURE_DEFAULTS: FeatureFlagOverrides;
/**
 * Enforced-off feature flags — the markdown-breaking or explicitly restricted
 * controls the preset hard-locks. These win over both {@link
 * PAPYRA_FEATURE_DEFAULTS} and any caller override, so a stray `featureFlags`
 * prop can never re-enable a feature that would corrupt the `.md` body or break
 * the markdown-source-of-truth invariant.
 *
 * Mirrors the OFF column of the Restrictions table. View tabs, the pinned
 * toolbar, and the `json`/`html` modes are not flags — the wrapper locks those
 * through dedicated props (`availableModes`, `isEditorViewTabsVisible`,
 * `isToolbarPinned`).
 */
declare const PAPYRA_FEATURE_ENFORCED: FeatureFlagOverrides;
/**
 * The Papyra feature policy: curated defaults composed with an enforced set of
 * restrictions. Resolve caller overrides through {@link
 * PresetFeaturePolicy.resolve} so the enforced flags always have the final say.
 */
declare const papyraFeaturePolicy: PresetFeaturePolicy<"table" | "emoji" | "italic" | "bold" | "underline" | "contextMenu" | "floatingToolbar" | "code" | "image" | "link" | "list" | "strikethrough" | "subscript" | "superscript" | "history" | "horizontalRule" | "fontFamily" | "fontSize" | "lineHeight" | "textColor" | "textHighlight" | "codeIntelligence" | "blockFormat" | "draggableBlock" | "iframeEmbed" | "tabIndent" | "commandPalette" | "slashCommand" | "enterKeyBehavior" | "themeToggle" | "codeFormat" | "youTubeEmbed" | "customNode">;

/**
 * Copyright (c) Luthor Team and contributors.
 * Open source under the MIT License (LICENSE).
 * Fork it. Remix it. Ship it.
 * Build freely. Credit kindly.
 */

/**
 * The Papyra design-token contract.
 *
 * PapyraEditor never hardcodes a color or a font family. Every editorial
 * surface is bridged to one of the tokens below, and the host (Papyra, or any
 * note app reusing the preset) supplies the real values — typically light/dark
 * pairs, plus a per-note tint for {@link createPapyraThemeOverrides | colored}
 * notes. When a token is absent the preset falls back to Luthor's own
 * `--luthor-preset-*` base palette (defined in `core/preset-base.css`), so the
 * editor still renders a sensible light editorial default without a host.
 *
 * Because these tokens carry the active theme, they intentionally supersede
 * Luthor's built-in `data-editor-theme` light/dark palette: the host owns the
 * theme policy, the preset only exposes the seams.
 *
 * | Token | Drives |
 * | --- | --- |
 * | `--papyra-surface` | editor + floating-toolbar background |
 * | `--papyra-surface-muted` | table header, muted fills |
 * | `--papyra-text` | body ink, bold, list markers, quote ink |
 * | `--papyra-text-muted` | placeholder, muted captions, comments |
 * | `--papyra-text-heading` | heading ink (Marcellus) |
 * | `--papyra-border` | hairlines: table, horizontal rule, dividers |
 * | `--papyra-accent` | links accent base, checkboxes, quote border |
 * | `--papyra-accent-text` | link text |
 * | `--papyra-accent-contrast` | text on an accent fill |
 * | `--papyra-accent-surface` | tinted fills: quote background, selection |
 * | `--papyra-code-surface` | code-block background |
 * | `--papyra-font-body` | body type (Sora) |
 * | `--papyra-font-heading` | heading type (Marcellus) |
 * | `--papyra-font-mono` | inline + block code (Roboto Mono) |
 *
 * Font tokens are consumed in `papyra.css`; color tokens are bridged through
 * {@link PAPYRA_THEME_OVERRIDES}.
 */
declare const PAPYRA_THEME_TOKEN_NAMES: readonly ["--papyra-surface", "--papyra-surface-muted", "--papyra-text", "--papyra-text-muted", "--papyra-text-heading", "--papyra-border", "--papyra-accent", "--papyra-accent-text", "--papyra-accent-contrast", "--papyra-accent-surface", "--papyra-code-surface", "--papyra-font-body", "--papyra-font-heading", "--papyra-font-mono"];
/** A documented Papyra design token name. */
type PapyraThemeTokenName = (typeof PAPYRA_THEME_TOKEN_NAMES)[number];
/**
 * Marker class the wrapper carries for {@link createPapyraThemeOverrides |
 * colored} notes. `papyra.css` uses it to keep ink readable on a tinted paper.
 */
declare const PAPYRA_COLORED_VARIANT_CLASS = "luthor-preset-papyra--colored";
/**
 * The editorial token bridge: each Luthor theme override resolves to a Papyra
 * design token, falling back to a Luthor `--luthor-preset-*` base token so the
 * declaration is always valid and hex never lives in the preset. Syntax colors
 * default to a calm monochrome (ink / muted-ink); the host can paint a richer
 * palette through the `--papyra-syntax-*` hooks below.
 */
declare const PAPYRA_THEME_OVERRIDES: EditorThemeOverrides;
/**
 * Resolve the editor theme overrides for a PapyraEditor instance. The caller's
 * `editorThemeOverrides` are layered on top of {@link PAPYRA_THEME_OVERRIDES},
 * so a host can retune an individual token (or point one at a different design
 * token) without losing the rest of the bridge.
 *
 * @param callerOverrides - Per-instance overrides from the host.
 * @returns The merged, token-driven override map passed to the extensive editor.
 */
declare function resolvePapyraThemeOverrides(callerOverrides?: EditorThemeOverrides): EditorThemeOverrides;
/** Options accepted by {@link createPapyraThemeOverrides}. */
interface PapyraThemeOptions {
    /**
     * Light-lock for tinted ("colored") notes. When the host paints the paper
     * with a per-note tint, the editor must stay on its light editorial palette
     * regardless of the ambient app theme, or ink can wash out on the tint. The
     * wrapper forces `initialTheme="light"` and carries
     * {@link PAPYRA_COLORED_VARIANT_CLASS} so `papyra.css` can pin the ink.
     */
    colored?: boolean;
    /** Per-instance overrides layered on top of the bridge. */
    overrides?: EditorThemeOverrides;
}
/**
 * Build the resolved theme bundle for a PapyraEditor instance: the merged
 * override map plus the `initialTheme` the wrapper should hard-set. `colored`
 * notes are light-locked.
 */
declare function createPapyraThemeOverrides(options?: PapyraThemeOptions): {
    editorThemeOverrides: EditorThemeOverrides;
    initialTheme?: "light";
};

/**
 * Copyright (c) Luthor Team and contributors.
 * Open source under the MIT License (LICENSE).
 * Fork it. Remix it. Ship it.
 * Build freely. Credit kindly.
 */

/**
 * Configuration accepted by {@link createPapyraPreset}. At the skeleton stage it
 * forwards the {@link ExtensivePresetConfig} knobs the underlying extensions
 * understand. Papyra-specific tuning (theme, adapter, command set) arrives in
 * later sprints (E1+).
 */
type PapyraPresetConfig = ExtensivePresetConfig;
/**
 * Build the `papyra` preset, composed on top of the extensive preset. The
 * shared registry entry below is `createPapyraPreset()` with defaults.
 */
declare function createPapyraPreset(config?: PapyraPresetConfig): EditorPreset;
declare const papyraPreset: EditorPreset;

export { papyraPreset as A, resolvePapyraThemeOverrides as B, usePapyraAdapter as C, type ClassNameToken as D, type PresetFeatureOverrides as E, PresetFeaturePolicy as F, joinClassNames as G, type PapyraEditorAdapter as P, PAPYRA_AVAILABLE_MODES as a, PAPYRA_COLORED_VARIANT_CLASS as b, PAPYRA_FEATURE_DEFAULTS as c, PAPYRA_FEATURE_ENFORCED as d, PAPYRA_FOCUS_VARIANT_CLASS as e, PAPYRA_LOCKED_VARIANT_CLASS as f, PAPYRA_READONLY_MODES as g, PAPYRA_THEME_OVERRIDES as h, PAPYRA_THEME_TOKEN_NAMES as i, PapyraAdapterContext as j, type PapyraBlockAnchor as k, type PapyraBlockRef as l, PapyraEditor as m, type PapyraEditorProps as n, type PapyraEditorRef as o, type PapyraEditorVariant as p, type PapyraNoteRef as q, type PapyraNoteSearchResult as r, type PapyraOutlineHeading as s, type PapyraPresetConfig as t, type PapyraThemeOptions as u, type PapyraThemeTokenName as v, createFallbackPapyraAdapter as w, createPapyraPreset as x, createPapyraThemeOverrides as y, papyraFeaturePolicy as z };