/**
 * Discord Markdown elements {@link strip} and {@link toHTML} can act on.
 * All are removed/rendered by default; shared across the package so element
 * names stay consistent between the plain-text stripper and the HTML
 * renderer.
 */
type MarkdownElement = "bold" | "italic" | "underline" | "strikethrough" | "spoiler" | "code" | "codeBlock" | "blockQuote" | "header" | "subtext" | "list" | "link" | "embedLink" | "silent";

/**
 * Options for {@link strip}.
 */
interface StripOptions {
    /**
     * Elements to leave untouched instead of removing. Default: `[]` (every
     * element is removed).
     */
    disable?: MarkdownElement[];
}
/**
 * Strip Discord Markdown formatting from text, leaving plain text behind.
 *
 * Built on {@link parse}: covers the syntax described in Discord's Markdown
 * 101 article (bold, italic, underline, strikethrough, spoilers, code/code
 * blocks, block quotes, headers, subtext, lists, masked links) plus
 * suppressed embed links (`<https://example.com>`) and a leading `@silent`
 * marker.
 *
 * Mentions (`<@id>`, `<@!id>`, `<@&id>`, `<@$id>`, `<#id>`, `</command:id>`),
 * custom emoji (`<:name:id>`, `<a:name:id>`) and timestamps
 * (`<t:unix:style>`) are left untouched, since their raw IDs carry no
 * displayable information on their own.
 *
 * Every element in {@link MarkdownElement} is removed by default; pass its
 * name in `options.disable` to leave it untouched instead.
 */
declare function strip(text: string, options?: StripOptions): string;

/**
 * Options for {@link toHTML}.
 */
interface ToHTMLOptions {
    /**
     * Elements to leave as literal (HTML-escaped) text instead of rendering.
     * Default: `[]` (every element is rendered).
     */
    disable?: MarkdownElement[];
}
/**
 * Render Discord Markdown to an HTML string.
 *
 * Built on {@link parse}: all text is HTML-escaped per-segment (via
 * `escape-html`), so the result is safe to insert into a page as-is; only
 * the tags this function generates itself are ever emitted as raw markup.
 * Masked links and suppressed embed links are only turned into `<a>` tags
 * when their URL is `http(s)`; anything else is left as literal escaped
 * text.
 *
 * Covers the same syntax as {@link strip} (bold, italic, underline,
 * strikethrough, spoilers, code/code blocks, block quotes, headers,
 * subtext, lists, masked links, suppressed embed links, `@silent`), mapped
 * to `<strong>`, `<em>`, `<u>`, `<s>`, `<span class="spoiler">`, `<code>`,
 * `<pre><code>`, `<blockquote>`, `<h1>`-`<h3>`, `<span class="subtext">`,
 * `<ul>`/`<ol>` and `<a>` respectively.
 *
 * Mentions, custom emoji and timestamps are left as literal text, same as
 * {@link strip}. Line breaks are preserved as-is (not converted to `<br>`,
 * except to join lines within a single block quote); render the result
 * with `white-space: pre-wrap` or convert newlines yourself.
 *
 * Every element in {@link MarkdownElement} is rendered by default; pass
 * its name in `options.disable` to leave it as literal text instead.
 */
declare function toHTML(text: string, options?: ToHTMLOptions): string;

/** Discord timestamp display style, i.e. the `X` in `<t:unix:X>`. */
type TimestampStyle = "t" | "T" | "d" | "D" | "f" | "F" | "R";
/** Options for {@link formatTimestamp}. */
interface FormatTimestampOptions {
    /** BCP 47 locale. Default: the runtime's default locale. */
    locale?: string;
}
/**
 * Format a Discord timestamp's epoch seconds and style (the `unix` and `X`
 * in `<t:unix:X>`) into a display string.
 *
 * This is deliberately separate from {@link strip}/{@link toHTML}, which
 * leave `<t:unix:style>` tokens untouched — use {@link parse} to pull the
 * `epoch`/`style` out of a message, then call this to render them, since
 * the desired locale/format is caller-specific.
 *
 * `style` defaults to `"f"` (short date/time), matching Discord's own
 * default when a message omits it.
 */
declare function formatTimestamp(epochSeconds: number, style?: TimestampStyle, options?: FormatTimestampOptions): string;

/**
 * Element kinds {@link parse} can tag a token with. A superset of
 * {@link MarkdownElement}: adds the Discord-specific tokens `strip`/`toHTML`
 * leave untouched (mentions, custom emoji, timestamps, slash commands),
 * `"boldItalic"` for the combined `***text***` marker (only removed/rendered
 * by `strip`/`toHTML` when both `"bold"` and `"italic"` are enabled), and
 * `"text"` for plain literal spans.
 */
type ParsedElement = MarkdownElement | "boldItalic" | "timestamp" | "mention" | "globalMention" | "roleMention" | "channelMention" | "gameMention" | "emoji" | "slashCommand" | "text";
/**
 * A span of the original text tagged with what it is. Tokens partition the
 * input exactly: sorted by `start`, contiguous, no gaps or overlaps.
 */
interface Token {
    element: ParsedElement;
    /** Inclusive start index into the original text. */
    start: number;
    /** Exclusive end index into the original text. */
    end: number;
    /** The exact original substring, markup included (e.g. `"**bold**"`). */
    raw: string;
    /**
     * The substring with its markup peeled off and any backslash-escaped
     * markdown characters (`\*`) resolved to their literal form (e.g.
     * `"bold"`, or `"*literal*"` from the escaped input `"\*literal\*"`).
     */
    content: string;
    /** Header level 1-3. Only set for `"header"` tokens. */
    level?: number;
    /** Whether a list item uses a number (`1.`) rather than a bullet. Only set for `"list"` tokens. */
    ordered?: boolean;
    /** The fenced code block's language tag, if any. Only set for `"codeBlock"` tokens. */
    lang?: string;
    /** The link target. Only set for `"link"`/`"embedLink"` tokens. */
    url?: string;
    /** Unix epoch seconds. Only set for `"timestamp"` tokens. */
    epoch?: number;
    /** Display style (`t`/`T`/`d`/`D`/`f`/`F`/`R`). Only set for `"timestamp"` tokens. */
    style?: TimestampStyle;
}
/**
 * Tokenize Discord Markdown text without removing or rendering anything.
 * The single source of truth for recognizing Discord Markdown — both
 * {@link strip} and {@link toHTML} are built on top of this.
 *
 * Returns a flat, non-overlapping list of tokens covering the entire input
 * (plain-text spans are tagged `"text"`), each with its position in the
 * original string. Deeply nested markup (e.g. emphasis nested inside a
 * code span) is not decomposed further — each token describes only its
 * outermost construct, consistent with the regex-based (not full
 * CommonMark) approach.
 *
 * A leading `@silent` marker is tagged as its own `"silent"` token.
 * Mentions, custom emoji, timestamps and slash command mentions are tagged
 * with their own element (not left as inert `"text"`), so callers can
 * resolve/format them — e.g. pass a `"timestamp"` token's `epoch`/`style`
 * to {@link formatTimestamp}.
 */
declare function parse(text: string): Token[];

export { FormatTimestampOptions, MarkdownElement, ParsedElement, StripOptions, TimestampStyle, ToHTMLOptions, Token, formatTimestamp, parse, strip, toHTML };