/**
 * Type definitions for remake-blocks
 *
 * Supports 42 first-class callout types + disclosure widgets — each directive
 * maps to its own unique visual identity, CSS class, and default title.
 *
 * GFM standard (5):   NOTE, TIP, IMPORTANT, WARNING, CAUTION
 * Obsidian core (10): ABSTRACT, INFO, SUCCESS, QUESTION, FAILURE, DANGER, QUOTE, BUG, EXAMPLE, TODO
 * Promoted aliases (12): SUMMARY, TLDR, HINT, CHECK, DONE, HELP, FAQ, ATTENTION, FAIL, MISSING, ERROR, CITE
 * v1.6.0 promoted (15): DEFINITION, ASIDE, CORRECTION, UPDATE, FIGURE, FURTHER-READING,
 *                       PREREQUISITE, EXERCISE, SIDENOTE, TIMELINE, ANNOUNCEMENT,
 *                       BIBLIOGRAPHY, DRAFT, TRANSLATION, DISCUSSION, RETRO
 * Disclosure:         [!] — plain collapsible block with no color/icon
 * Custom:             User-defined via customCallouts option
 */
/**
 * All 42 built-in callout types — each is a distinct first-class type
 * with its own CSS class, icon, color palette, and default title.
 *
 * No alias resolution: every directive maps 1:1 to its own config.
 */
export type BuiltinCalloutType = "note" | "tip" | "important" | "warning" | "caution" | "abstract" | "info" | "success" | "question" | "failure" | "danger" | "quote" | "bug" | "example" | "todo" | "summary" | "tldr" | "hint" | "check" | "done" | "help" | "faq" | "attention" | "fail" | "missing" | "error" | "cite" | "definition" | "aside" | "correction" | "update" | "figure" | "further-reading" | "prerequisite" | "exercise" | "sidenote" | "timeline" | "announcement" | "bibliography" | "draft" | "translation" | "discussion" | "retro";
/**
 * v1.10.0+: Lucide icon names recognized by the per-callout `{icon="..."}`
 * override. Use this type in your own config to get autocomplete when
 * specifying icon names.
 *
 * The list below covers all icon keys in the plugin's internal LUCIDE_ICONS
 * map — 27 type-matched icons + 24 extra named icons added in v1.4.0.
 *
 * Note: this is a closed union of the icons the plugin ships. To use a
 * Lucide icon NOT in this list, cast with `as LucideIconName` (the runtime
 * lookup will fall back to the callout type's default icon if the name
 * isn't found).
 */
export type LucideIconName = "note" | "tip" | "important" | "warning" | "caution" | "abstract" | "info" | "success" | "question" | "failure" | "danger" | "quote" | "bug" | "example" | "todo" | "summary" | "tldr" | "hint" | "check" | "done" | "help" | "faq" | "attention" | "fail" | "missing" | "error" | "cite" | "rocket" | "heart" | "star" | "bell" | "flag" | "bookmark" | "lightbulb" | "fire" | "zap" | "shield" | "code" | "book" | "pencil" | "eye" | "globe" | "lock" | "key" | "clock" | "calendar" | "package" | "download" | "upload" | "link" | "settings" | "terminal" | "definition" | "aside" | "correction" | "update" | "figure" | "further-reading" | "prerequisite" | "exercise" | "sidenote" | "timeline" | "announcement" | "bibliography" | "draft" | "translation" | "discussion" | "retro";
/**
 * A custom callout type registered by the user.
 * Must be a non-empty string that doesn't clash with builtins.
 */
export type CustomCalloutType = string;
/**
 * Union of all possible callout type identifiers.
 */
export type CalloutType = BuiltinCalloutType | CustomCalloutType;
/**
 * Configuration for a single callout type (built-in or custom).
 */
export interface CalloutConfig {
    /** The callout type identifier, e.g. "note", "hint", or a custom name */
    type: CalloutType;
    /**
     * SVG icon string or emoji rendered in the callout header.
     * Can be an inline SVG, an emoji character, or empty string for no icon.
     */
    icon: string;
    /**
     * CSS class name(s) added to the callout container element.
     * Multiple classes are space-separated.
     */
    className: string;
    /**
     * Default title when the user does not provide a custom title
     * in the markdown syntax (e.g. `> [!NOTE]` without a trailing title).
     */
    defaultTitle: string;
    /**
     * Primary accent color for the callout border / icon tint.
     * Accepts any valid CSS color value.
     */
    color: string;
    /**
     * Background color for the callout body.
     * Accepts any valid CSS color value.
     */
    backgroundColor: string;
    /**
     * Icon color (defaults to `color` if not specified).
     */
    iconColor?: string;
}
/**
 * Options for the remake-blocks remark plugin.
 */
export interface RemakeBlocksOptions {
    /**
     * Custom callout type definitions to register in addition to builtins.
     *
     * Each entry defines a new `[!TYPE]` directive that can be used in markdown.
     * If a custom callout's `type` matches a builtin, the builtin is overridden.
     *
     * @example
     * ```ts
     * customCallouts: [
     *   {
     *     type: "custom",
     *     icon: "🚀",
     *     className: "callout-custom",
     *     defaultTitle: "Custom",
     *     color: "#8b5cf6",
     *     backgroundColor: "#f5f3ff",
     *   },
     * ]
     * ```
     */
    customCallouts?: CalloutConfig[];
    /**
     * Tag name used for the outer callout container element.
     * @default "div"
     */
    calloutContainerTag?: string;
    /**
     * CSS class name added to the callout container.
     * @default "callout"
     */
    calloutClass?: string;
    /**
     * CSS class name added to the callout title element.
     * @default "callout-title"
     */
    calloutTitleClass?: string;
    /**
     * CSS class name added to the callout body element.
     * @default "callout-body"
     */
    calloutBodyClass?: string;
    /**
     * Whether to enhance regular blockquotes (those without a callout directive)
     * with improved styling via CSS classes.
     * @default true
     */
    enhanceBlockquotes?: boolean;
    /**
     * CSS class name added to enhanced blockquotes.
     * @default "blockquote-enhanced"
     */
    blockquoteClass?: string;
    /**
     * Whether to inject a data-callout-type attribute on the container
     * so users can target specific types in CSS (e.g. `[data-callout-type="hint"]`).
     * @default true
     */
    dataCalloutType?: boolean;
    /**
     * Regular expression used to detect callout directives inside blockquotes.
     * The first capture group must be the callout type, the second (optional)
     * capture group is the custom title.
     *
     * Defaults to a dynamically built regex matching all 27 builtins + any custom types.
     */
    calloutPattern?: RegExp;
    /**
     * Enable disclosure widget support.
     * When true, `[!]` directives create plain collapsible blocks.
     * @default true
     */
    enableDisclosures?: boolean;
    /**
     * CSS class name added to disclosure widget containers.
     * @default "disclosure"
     */
    disclosureClass?: string;
    /**
     * CSS class name added to the disclosure title/summary element.
     * @default "disclosure-title"
     */
    disclosureTitleClass?: string;
    /**
     * CSS class name added to the disclosure body element.
     * @default "disclosure-body"
     */
    disclosureBodyClass?: string;
    /**
     * Enable accordion grouping for consecutive disclosure widgets.
     * When 2+ `[!]` blocks appear consecutively, they are wrapped in
     * an accordion container where opening one closes the others.
     * @default true
     */
    enableAccordion?: boolean;
    /**
     * CSS class name added to the accordion wrapper container.
     * @default "disclosure-accordion"
     */
    accordionClass?: string;
    /**
     * Enable tree view styling for nested disclosure widgets.
     * Nested `[!]` blocks get `disclosure-tree` class + `data-depth`
     * attributes for indentation and visual tree lines.
     * @default true
     */
    enableTreeView?: boolean;
    /**
     * Allow raw HTML in markdown to pass through to the rendered callout body.
     *
     * **Default: `false` (safe-by-default).**
     *
     * When `false` (the default), raw HTML in markdown source is HTML-escaped
     * before being placed into the callout body. This prevents XSS attacks
     * from untrusted markdown content (e.g. `<img src=x onerror=alert(1)>`
     * is rendered as escaped text, not executed).
     *
     * When `true`, raw HTML in markdown is passed through verbatim to the
     * rendered HTML — matching the behavior of `remark-rehype`'s
     * `allowDangerousHtml` option. Use this only if you fully trust your
     * markdown source AND have run it through a sanitizer (e.g. rehype-sanitize).
     *
     * @default false
     * @security Only set this to `true` if your markdown source is trusted
     *   or has been sanitized.
     */
    allowDangerousHtml?: boolean;
    /**
     * Map of aliases for callout types. Aliases let users use shorter or
     * alternative names for builtin or custom callout types.
     *
     * Keys are the canonical type (must exist in builtins or `customCallouts`).
     * Values are arrays of alias names that will resolve to the canonical type.
     *
     * @example
     * ```ts
     * aliases: {
     *   note: ["n", "info-note"],
     *   tip: ["t"],
     * }
     * // Now `> [!N]` and `> [!INFO-NOTE]` render as `note` callouts.
     * ```
     *
     * @default undefined (no aliases)
     */
    aliases?: Record<string, string[]>;
    /**
     * Whether to render icons in the callout title.
     *
     * - `true` (default): render the icon (builtin SVG or custom icon)
     * - `false`: skip the icon entirely (no `<span class="callout-icon">`)
     *
     * Can be overridden per-callout via `> [!NOTE]{icon=false}` syntax.
     *
     * @default true
     */
    showIndicator?: boolean;
    /**
     * Default icon set for builtin callout types.
     *
     * - `"octicon"` (default): GitHub Octicons (current behavior)
     * - `"lucide"`: Lucide icons (matching rehype-callouts' Obsidian theme)
     * - `"emoji"`: Emoji icons (e.g. ℹ️ for note, 💡 for tip)
     * - `"none"`: No icons (equivalent to `showIndicator: false`)
     *
     * Custom callouts always use their configured `icon` regardless of this option.
     *
     * @default "octicon"
     */
    iconSet?: "octicon" | "lucide" | "emoji" | "none";
    /**
     * Visual density / appearance for callouts.
     *
     * - `"default"` (default): Full callout with title bar, icon, border, background.
     * - `"minimal"`: Reduced padding, smaller title, no background color.
     * - `"simple"`: No title bar — title appears as bold inline text above body.
     * - `"hidden"`: No title, no icon, just the body content with a left border.
     *
     * Can be overridden per-callout via `> [!NOTE]{appearance=minimal}` syntax.
     *
     * @default "default"
     */
    appearance?: "default" | "minimal" | "simple" | "hidden";
    /**
     * Tag names for the callout HTML structure. Override to customize the
     * output HTML elements (e.g. use `<div>` instead of `<aside>`).
     *
     * @default { container: "aside", title: "div", icon: "span", titleText: "span", body: "div" }
     */
    tags?: {
        container?: string;
        title?: string;
        icon?: string;
        titleText?: string;
        body?: string;
    };
    /**
     * Per-callout-type additional HTML attributes. Can be a static object
     * applied to all callouts of that type, or a function that returns
     * attributes dynamically based on the parsed callout.
     *
     * The returned object's keys become HTML attributes; values are strings
     * (or undefined to skip). Use this to add `dir`, `style`, custom `data-*`
     * attributes, etc.
     *
     * @example
     * ```ts
     * props: {
     *   note: { dir: "auto", "data-category": "info" },
     *   // or as a function:
     *   warning: (parsed) => ({ style: `--accent: ${parsed.collapsible ? "red" : "orange"}` }),
     * }
     * ```
     *
     * @default undefined
     */
    props?: Record<string, Record<string, string> | ((parsed: ParsedCallout) => Record<string, string>)>;
    /**
     * Custom render function (escape hatch). When provided, replaces the
     * default HTML rendering entirely. Use this for full control over output.
     *
     * The function receives the parsed callout, the resolved config, the
     * rendered body HTML, and the plugin options. It must return an HTML
     * string.
     *
     * **Security note:** the returned HTML is injected as raw HTML. You are
     * responsible for escaping user-supplied content (use the provided
     * `escapeHtml` helper from the `escapeHtml` export).
     *
     * @example
     * ```ts
     * build: (parsed, config, bodyHtml, options) => {
     *   return `<div class="my-callout my-callout-${parsed.type}">${bodyHtml}</div>`;
     * }
     * ```
     *
     * @default undefined (use built-in renderer)
     */
    build?: (parsed: ParsedCallout, config: CalloutConfig | undefined, bodyHtml: string, options: Required<RemakeBlocksOptions>) => string;
    /**
     * v1.3.0+: Enable `:::type[Title]` directive syntax (Starlight/Docusaurus compat).
     *
     * When `true`, the plugin detects `:::type` blocks in markdown and renders
     * them as callouts. This allows content portability with Starlight, Docusaurus,
     * MkDocs Material, and other tools that use the directive syntax.
     *
     * Supported syntax:
     * - `:::note` ... `:::` — basic callout
     * - `:::note[Custom Title]` ... `:::` — with custom title
     * - `:::note{fold=-}` ... `:::` — with overrides (same as `> [!NOTE]-`)
     * - `::::note` ... `::::` — 4-colon variant (for nesting)
     * - `:::note[Title]{#my-id .custom-class data-type="example"}` — v1.4.0+ full attributes
     *
     * The directive syntax can be used alongside the standard `> [!NOTE]` syntax.
     *
     * @default false (opt-in for backward compatibility)
     */
    enableDirectiveSyntax?: boolean;
    /**
     * v1.4.0+: Internationalization (i18n) label overrides.
     *
     * Override the default title for any callout type. Useful for non-English
     * documentation sites where you want "Note" to display as "注意", "Hinweis",
     * "メモ", etc.
     *
     * Keys are callout type names (lowercase). Values are the replacement title.
     * Applies to ALL 27 builtin types AND custom callout types.
     *
     * @example
     * ```ts
     * remakeBlocks({
     *   labels: {
     *     note: "注意",
     *     tip: "ヒント",
     *     warning: "警告",
     *     caution: "危険",
     *     important: "重要",
     *   }
     * })
     * ```
     *
     * @default undefined (use built-in English titles)
     */
    labels?: Record<string, string>;
    /**
     * v1.4.0+: Enable MkDocs Material admonition syntax (`!!!` / `???` / `???+`).
     *
     * When `true`, the plugin detects MkDocs-style admonition syntax and renders
     * them as callouts. This enables content portability with MkDocs Material.
     *
     * Supported syntax:
     * - `!!! note` ... — non-collapsible callout
     * - `??? note` ... — collapsed callout (same as `> [!NOTE]-`)
     * - `???+ note` ... — expanded collapsible callout (same as `> [!NOTE]+`)
     * - `!!! note "Custom Title"` — with custom title
     * - `!!! note ""` — no title (strips default)
     *
     * The body is indented 4 spaces under the directive.
     *
     * @default false (opt-in for backward compatibility)
     */
    enableMkDocsSyntax?: boolean;
    /**
     * v1.7.0+: CSS cascade layer strategy for the plugin's injected styles.
     *
     * Modern sites (2024+) typically use `@layer` to control cascade priority.
     * Injecting unlayered CSS into a layered stylesheet will override every
     * layered rule — the "unlayered always wins" pitfall. This option lets the
     * plugin play nicely with sites that already declare layers.
     *
     * - `'inline'` (default, backward-compatible): injects CSS unlayered.
     * - `'layer'`: wraps the plugin's CSS in `@layer <cssLayer> { ... }`.
     *   If the layer isn't already declared on the page, a `@layer <cssLayer>;`
     *   declaration is emitted first so the layer exists.
     * - `'import'`: the plugin does NOT inject any CSS; the user must import
     *   `@dr-ishaan/remake-blocks/styles.css` themselves (typically with
     *   `@import '@dr-ishaan/remake-blocks/styles.css' layer(components);`).
     *
     * @default 'inline'
     */
    cssInjection?: "inline" | "layer" | "import";
    /**
     * Name of the CSS cascade layer to use when `cssInjection: 'layer'`.
     *
     * @default 'components'
     */
    cssLayer?: string;
    /**
     * v1.7.0+: Design-token bridge. Provide 4 base values and the plugin
     * derives all `--callout-*` layout/typography variables from them.
     *
     * This is a "compute the rest" shortcut. Per-variable overrides via the
     * existing `themeVars` option (if present) still take precedence.
     *
     * The plugin emits a `:root` block (or scoped equivalent) that defines:
     *   --callout-bg          = tokens.bg
     *   --callout-text         = tokens.text
     *   --callout-border       = tokens.border
     *   --callout-radius       = tokens.radius
     *   --callout-title-size   = computed from text (1em)
     *   --callout-body-size    = computed from text (0.9375em)
     *   --callout-icon-size    = computed from radius (1.5 × radius-ish)
     *   --callout-padding-y    = computed from radius (radius × 0.75)
     *   --callout-padding-x    = computed from radius (radius × 1.5)
     *
     * @example
     * ```ts
     * remakeBlocks({
     *   tokens: {
     *     bg: 'var(--bg-elevated)',
     *     text: 'var(--ink)',
     *     border: 'var(--rule)',
     *     radius: 'var(--radius-card)',
     *   }
     * })
     * ```
     *
     * @default undefined (no derived tokens emitted)
     */
    tokens?: {
        bg: string;
        text: string;
        border: string;
        radius: string;
    };
    /**
     * v1.7.0+: Per-callout-type token override.
     *
     * For each entry, the plugin generates `--callout-{type}-accent`,
     * `--callout-{type}-bg`, and `--callout-{type}-border` (derived via
     * `color-mix(in oklch, accent 25%, transparent)`).
     *
     * This is the "give each type its own color identity" hook — the bundled
     * themes already ship per-type palettes, but this option lets you remap
     * individual types to your site's design tokens without rewriting CSS.
     *
     * @example
     * ```ts
     * remakeBlocks({
     *   typeTokens: {
     *     note:       { accent: 'var(--brand)', bg: 'color-mix(in oklch, var(--brand) 8%, var(--bg))' },
     *     warning:    { accent: 'oklch(72% 0.15 55)' },
     *     definition: { accent: 'var(--c-purple)', bg: 'color-mix(in oklch, var(--c-purple) 8%, var(--bg))' },
     *   }
     * })
     * ```
     *
     * @default undefined (use bundled theme palettes)
     */
    typeTokens?: Record<string, {
        accent: string;
        bg?: string;
        border?: string;
    }>;
    /**
     * v1.7.0+: Dark-mode selector strategy.
     *
     * The bundled themes target `@media (prefers-color-scheme: dark)` plus
     * `[data-theme="dark"]` / `[data-theme="dim"]`. If your site uses a
     * different dark-mode signal (e.g. `.dark` class, `[data-mode="night"]`),
     * configure it here so the plugin can emit a matching selector override.
     *
     * @default { strategy: 'media' }
     */
    darkMode?: {
        /** Strategy: 'media' (default) | 'attribute' | 'class' | 'custom' */
        strategy?: "media" | "attribute" | "class" | "custom";
        /** For 'attribute' strategy: the attribute name. @default 'data-theme' */
        attribute?: string;
        /** For 'attribute' strategy: the value that triggers dark mode. @default 'dark' */
        attributeValue?: string;
        /** For 'class' strategy: the class name. @default 'dark' */
        class?: string;
        /** For 'custom' strategy: the full CSS selector. e.g. ':root[data-mode="night"]' */
        customSelector?: string;
    };
    /**
     * v1.7.0+: CSS containment scope.
     *
     * Prefix every generated selector with this scope. Useful for sites that
     * only want callout styles to apply inside `.prose` or `article.post` —
     * prevents leaking into headers, sidebars, and other page chrome.
     *
     * Note: this only affects CSS generated by the v1.7.0 token/typeToken/darkMode
     * options. The bundled theme files are NOT auto-scoped (they target `:root`).
     * For full scoping, use `cssInjection: 'import'` and wrap the import yourself.
     *
     * @default undefined (no scoping)
     */
    scope?: string;
    /**
     * v1.8.0+: Type enable/disable allowlist / blocklist.
     *
     * Not every site wants all 42 builtin types. This option lets you opt in
     * to a specific subset (allowlist) or exclude specific types (blocklist).
     * Disabled types render as plain enhanced blockquotes (no callout styling,
     * no callout class) — so authors can't accidentally use types the site
     * hasn't styled.
     *
     * - `enable`: only the listed types render as callouts. All others fall
     *   back to plain blockquotes.
     * - `disable`: the listed types fall back to plain blockquotes. All others
     *   render as callouts.
     *
     * `enable` and `disable` are mutually exclusive — setting both throws at
     * plugin initialization time.
     *
     * Type names are matched case-insensitively. Custom types registered via
     * `customCallouts` are also subject to this filter.
     *
     * @example
     * ```ts
     * // Only these 6 types render as callouts:
     * remakeBlocks({
     *   types: { enable: ['note', 'tip', 'warning', 'summary', 'aside', 'definition'] }
     * })
     *
     * // Disable these 5 types:
     * remakeBlocks({
     *   types: { disable: ['bug', 'todo', 'missing', 'fail', 'error'] }
     * })
     * ```
     *
     * @default undefined (all 42 builtins + customs are enabled)
     */
    types?: {
        /** Allowlist — only these types render as callouts. */
        enable?: string[];
        /** Blocklist — these types fall back to plain blockquotes. */
        disable?: string[];
    };
    /**
     * v1.8.0+: Per-type default collapse state.
     *
     * Sets the default collapsibility for callout types whose markdown
     * directive does NOT include an explicit `+` or `-` fold marker.
     *
     * Per-callout markers always override the default:
     *   - `> [!FAQ]+` → expanded (overrides `defaultCollapse.faq: true`)
     *   - `> [!FAQ]-` → collapsed (overrides `defaultCollapse.faq: false`)
     *   - `> [!FAQ]`  → uses `defaultCollapse.faq` (or stays non-collapsible
     *                   if no default is set for that type)
     *
     * Applies to builtin AND custom callout types. Disclosure widgets (`[!]`)
     * are always collapsible and are NOT affected by this option.
     *
     * @example
     * ```ts
     * remakeBlocks({
     *   defaultCollapse: {
     *     faq: true,        // FAQ callouts default to collapsed
     *     summary: true,    // Summary callouts default to collapsed
     *     aside: false,     // (explicit no-op — same as omitting)
     *   }
     * })
     * ```
     *
     * @default undefined (per-callout choice — same as v1.7.0)
     */
    defaultCollapse?: Record<string, boolean>;
    /**
     * v1.8.0+: Syntax mode selection.
     *
     * Controls which markdown syntaxes the plugin recognizes. The three
     * supported syntaxes are:
     *
     * - GFM (default, always on): `> [!NOTE]` blockquote directives
     * - Directive: `:::note[Title]{...}` ... `:::` (Starlight/Docusaurus)
     * - MkDocs: `!!! note` / `??? note` / `???+ note` (MkDocs Material)
     *
     * The three syntaxes don't conflict — a single document can mix all of
     * them without issues. Use `'auto'` to enable all three together.
     *
     * - `'auto'`: enables directive + MkDocs alongside the always-on GFM
     *   syntax. Equivalent to `{ enableDirectiveSyntax: true,
     *   enableMkDocsSyntax: true }`.
     * - `'gfm'`: only GFM (backward-compatible default).
     * - Array form: `['gfm', 'directive']` — explicit selection.
     *
     * Backward compatibility: if `enableDirectiveSyntax` or
     * `enableMkDocsSyntax` are explicitly set, they take precedence over
     * `syntax`. This preserves v1.3.0 / v1.4.0 behavior.
     *
     * @example
     * ```ts
     * remakeBlocks({ syntax: 'auto' })  // all three syntaxes
     * remakeBlocks({ syntax: ['gfm', 'directive'] })  // GFM + directive only
     * ```
     *
     * @default undefined (GFM only — backward compatible)
     */
    syntax?: "auto" | "gfm" | ("gfm" | "directive" | "mkdocs")[];
    /**
     * v1.9.0+: SVG icon inlining strategy.
     *
     * Controls how callout icons are rendered in the HTML output. The default
     * (`'inline'`) bloats HTML on pages with many callouts — each callout
     * gets a full `<svg>...</svg>` inline. The `'sprite'` strategy emits one
     * `<svg>` sprite at the top of the document with `<symbol>` definitions,
     * then references them via `<use href="#rb-icon-{type}"/>` — dramatically
     * reducing HTML size for callout-heavy pages.
     *
     * - `'inline'` (default, backward-compatible): full SVG inlined per callout.
     * - `'sprite'`: one `<svg style="display:none">` sprite with `<symbol>` per
     *   unique type, then `<svg><use href="#rb-icon-{type}"/></svg>` per callout.
     *   The sprite is emitted as a raw HTML node at the top of the document.
     * - `'none'`: no icons rendered (same as `iconSet: 'none'` but applied
     *   per-callout rather than globally).
     *
     * **Sprite mode caveats:**
     * - The sprite is emitted as an `html` node at the very top of the document
     *   tree, BEFORE any other content. It uses `style="display:none"` so it
     *   doesn't affect layout.
     * - `<use href="..."/>` references require the sprite to be in the same
     *   document. If you extract callout HTML to a different page, the sprite
     *   must travel with it.
     * - Custom callout types and per-callout `{icon="rocket"}` overrides are
     *   also added to the sprite (each gets its own `<symbol>`).
     *
     * @example
     * ```ts
     * remakeBlocks({ icons: { strategy: 'sprite' } })
     * ```
     *
     * @default { strategy: 'inline' }
     */
    icons?: {
        /** Icon rendering strategy. @default 'inline' */
        strategy?: "inline" | "sprite" | "none";
    };
    /**
     * v1.9.0+: Generate a minimal theme CSS containing only the base styles
     * and the enabled callout types.
     *
     * When `true`, the plugin generates a complete-but-minimal theme CSS
     * string (available via `generateMinimalThemeCss(opts)`) that contains:
     * - Base callout layout (structural rules)
     * - Per-type CSS variables + class rules for ONLY the enabled types
     * - Dark mode overrides for ONLY the enabled types
     *
     * Use this INSTEAD of importing the full bundled `styles.css` when you've
     * set `types.enable` or `types.disable` to a small subset. For a 5-type
     * allowlist, this reduces theme CSS from ~28KB to ~5KB.
     *
     * **Important:** this option does NOT automatically replace the bundled
     * theme. You must:
     * 1. Set `cssInjection: 'import'` to disable auto-injection of the full theme.
     * 2. Import `generateMinimalThemeCss` from the package root.
     * 3. Inject the generated CSS yourself (or use the Astro integration's
     *    `injectStyles: false` + manual injection).
     *
     * @default false
     */
    cssMinimalTheme?: boolean;
    /**
     * v1.10.0+: Emit developer-mode warnings to `console.warn`.
     *
     * Catches common authoring mistakes at build time:
     * - Unknown callout type (`> [!TYPO]` → "Unknown callout type 'TYPO'.
     *   Did you mean 'TIP'?")
     * - Missing body content (`> [!NOTE]` with no body → "Callout has no
     *   body content")
     * - Duplicate callout IDs (two callouts with the same `{#id}`)
     * - Invalid directive attributes (`> [!NOTE]{invalid}` → "Invalid
     *   directive attributes")
     * - Custom callout config validation (missing required fields like
     *   `className`, `color`, `defaultTitle`)
     *
     * Warnings are emitted via `console.warn` — production builds should
     * strip `console.warn` calls via their bundler (Vite, esbuild, SWC).
     * Alternatively, set this to `false` to disable explicitly.
     *
     * @default true in development (when `process.env.NODE_ENV !== 'production'`),
     *          false otherwise. Set explicitly to override.
     */
    devWarnings?: boolean;
    /**
     * v1.10.0+: Validate `customCallouts` config at plugin initialization
     * time. Throws with a descriptive error if any config entry is missing
     * required fields (`type`, `icon`, `className`, `defaultTitle`, `color`,
     * `backgroundColor`).
     *
     * When `false` (pre-v1.10.0 behavior), incomplete configs are silently
     * filled with safe defaults via `normalizeCalloutConfig`. Set to `true`
     * for strict validation — recommended for library authors and CI builds.
     *
     * @default false (backward compatible — silent normalization)
     */
    strictConfigValidation?: boolean;
    /**
     * v2.0.0+: Per-callout-type ARIA `role` attribute override.
     *
     * By default, all callouts use `role="note"` (the WCAG-correct role for
     * static supplementary content). This option lets you assign different
     * roles to specific types — most commonly `role="alert"` for types that
     * should be announced immediately by screen readers, or `role="status"`
     * for important-but-non-urgent supplementary content.
     *
     * **WCAG warning:** `role="alert"` causes screen readers to announce the
     * content unprompted the moment it appears. Only use it for content that
     * changes dynamically (e.g. a live form-validation error). For static
     * warnings in article content, `role="note"` with a visually distinct
     * style is the correct choice — the reader chooses when to engage.
     *
     * Allowed values per WAI-ARIA 1.2:
     * - `"note"` (default) — static supplementary content
     * - `"status"` — advisory information that's important but not urgent
     * - `"alert"` — important + time-sensitive (announces immediately)
     * - `"none"` — strip the role attribute entirely (rare; use when the
     *   callout is purely decorative and shouldn't be announced)
     *
     * @example
     * ```ts
     * remakeBlocks({
     *   roles: {
     *     important: 'status',      // important but non-urgent
     *     announcement: 'status',
     *     // Do NOT set warning: 'alert' for static article content.
     *   }
     * })
     * ```
     *
     * @default undefined (all types use role="note")
     */
    roles?: Record<string, "note" | "status" | "alert" | "none">;
    /**
     * v2.0.0+: Emit screen-reader-only text for icon-only callouts.
     *
     * When `true`, the plugin prepends a `<span class="sr-only">{TypeTitle}:</span>`
     * element inside the callout title. This ensures screen readers announce
     * the callout type (e.g. "Warning:") even when the visual title is just
     * an icon or when `appearance="minimal"` hides the title text.
     *
     * The plugin injects a small CSS rule for `.sr-only` (the standard
     * visually-hidden pattern) when this option is enabled, so it works
     * out-of-the-box without requiring user CSS.
     *
     * **When to enable:** if you use `appearance="minimal"` or icon-only
     * callout variants, or if your audience relies heavily on screen readers.
     *
     * @default false
     */
    srIconText?: boolean;
    /**
     * v2.0.0+: WAI-ARIA accordion keyboard pattern for grouped disclosures.
     *
     * When 2+ `[!]` disclosure widgets appear consecutively, the plugin wraps
     * them in an accordion container (existing behavior). This option adds
     * the full WAI-ARIA accordion keyboard pattern:
     *
     * - `Tab` moves focus between accordion headers (native `<summary>`)
     * - `Enter` / `Space` toggles the current panel (native `<details>`)
     * - `Arrow Up` / `Arrow Down` moves focus between accordion headers
     * - `Home` / `End` jumps to the first / last header
     *
     * Native `<details>`/`<summary>` already handles Enter/Space and Tab. The
     * arrow-key + Home/End navigation is added by `accordion.js` (the runtime
     * script the plugin injects). When this option is `false`, only the native
     * keyboard behavior applies (no arrow-key navigation).
     *
     * The accordion container gets `role="accordion"` and each header gets
     * `aria-expanded` reflecting its open state.
     *
     * @default true
     */
    ariaAccordion?: boolean;
    /**
     * v2.1.0+: Per-type default title customization.
     *
     * Override the default title for any callout type without using the full
     * `i18n.labels` option. This is a dedicated shortcut for the common case
     * of customizing titles (e.g. "Note" → "Heads up") without engaging the
     * i18n system.
     *
     * **Precedence** (highest to lowest):
     *   1. Per-callout custom title in markdown (`> [!NOTE] My Title`)
     *   2. `defaultTitles[type]` (this option)
     *   3. `labels[type]` (the v1.4.0 i18n option — kept for backward compat)
     *   4. `config.defaultTitle` (the builtin or customCallouts default)
     *
     * Setting both `defaultTitles` and `labels` for the same type is allowed
     * but redundant — `defaultTitles` wins. Use `defaultTitles` for new code;
     * `labels` remains for i18n-focused configurations.
     *
     * @example
     * ```ts
     * remakeBlocks({
     *   defaultTitles: {
     *     note: 'Heads up',
     *     warning: 'Watch out',
     *     tip: 'Pro tip',
     *     summary: 'TL;DR',
     *     definition: 'Term',
     *     aside: 'Aside',
     *   }
     * })
     * ```
     *
     * @default undefined (use config.defaultTitle, then labels, then builtin)
     */
    defaultTitles?: Record<string, string>;
}
/**
 * Options for the `remake-blocks` Astro integration.
 *
 * Extends the remark plugin options with integration-level settings
 * such as CSS injection.
 */
export interface AstroRemakeBlocksOptions extends RemakeBlocksOptions {
    /**
     * Whether to automatically inject the default callout styles into every page.
     * Set to `false` if you want to import `remake-blocks/styles.css`
     * manually for more control.
     * @default true
     */
    injectStyles?: boolean;
}
/**
 * Parsed result from a callout directive line.
 * @internal
 */
export interface ParsedCallout {
    /** The callout type (lowercased) — always the directive itself */
    type: CalloutType | "disclosure" | "pull" | "epigraph";
    /** Custom title provided after the directive, or undefined */
    customTitle?: string;
    /** The remaining content on the first line after the directive */
    remainingContent?: string;
    /** Whether the callout is collapsible */
    collapsible: boolean;
    /** Whether a collapsible callout starts expanded (+) or collapsed (-) */
    collapsibleOpen: boolean;
    /** Whether this is a disclosure widget (plain collapsible, no color/icon) */
    isDisclosure: boolean;
    /** v1.5.0+: Whether this is a pull quote (special rendering, no callout class) */
    isPullQuote: boolean;
    /** v1.5.0+: Whether this is an epigraph (special rendering, centered small) */
    isEpigraph: boolean;
    /** Per-callout overrides parsed from `{key=value}` syntax. v1.2.0+. */
    overrides?: {
        icon?: boolean;
        appearance?: "default" | "minimal" | "simple" | "hidden";
        /** v1.3.0+: inline floating behavior. `inline` floats left, `inline-end` floats right. */
        inline?: "inline" | "inline-end";
        /** v1.4.0+: per-callout named icon (e.g. "rocket" → Lucide rocket icon). */
        iconName?: string;
    };
    /** v1.4.0+: directive attributes parsed from `{#id .class key="value"}` syntax. */
    directiveAttrs?: {
        id?: string;
        classes?: string[];
        attrs?: Record<string, string>;
    };
}
/**
 * Configuration map used internally for O(1) callout type lookup.
 * @internal
 */
export type CalloutConfigMap = Map<CalloutType, CalloutConfig>;
//# sourceMappingURL=types.d.ts.map