import { S as MarkdownTableMode } from "./types.base-bTa1ro6X.js";

//#region src/markdown/ir.d.ts
type MarkdownStyle = "bold" | "italic" | "strikethrough" | "code" | "code_block" | "spoiler" | "blockquote";
type MarkdownStyleSpan = {
  start: number;
  end: number;
  style: MarkdownStyle;
  language?: string;
};
type MarkdownLinkSpan = {
  start: number;
  end: number;
  href: string;
};
type MarkdownIR = {
  text: string;
  styles: MarkdownStyleSpan[];
  links: MarkdownLinkSpan[];
};
type MarkdownTableData = {
  headers: string[];
  rows: string[][];
};
type MarkdownTableMeta = MarkdownTableData & {
  placeholderOffset: number;
};
type MarkdownParseOptions = {
  linkify?: boolean;
  enableSpoilers?: boolean;
  headingStyle?: "none" | "bold";
  blockquotePrefix?: string;
  autolink?: boolean; /** How to render tables (off|bullets|code|block). Default: off. */
  tableMode?: MarkdownTableMode;
};
declare function sliceMarkdownIR(ir: MarkdownIR, start: number, end: number): MarkdownIR;
declare function markdownToIR(markdown: string, options?: MarkdownParseOptions): MarkdownIR;
declare function markdownToIRWithMeta(markdown: string, options?: MarkdownParseOptions): {
  ir: MarkdownIR;
  hasTables: boolean;
  tables: MarkdownTableMeta[];
};
declare function chunkMarkdownIR(ir: MarkdownIR, limit: number): MarkdownIR[];
//#endregion
//#region src/markdown/render-aware-chunking.d.ts
type RenderedMarkdownChunk<TRendered> = {
  rendered: TRendered;
  source: MarkdownIR;
};
type RenderMarkdownIRChunksWithinLimitOptions<TRendered> = {
  ir: MarkdownIR;
  limit: number;
  measureRendered: (rendered: TRendered) => number;
  renderChunk: (ir: MarkdownIR) => TRendered;
};
declare function renderMarkdownIRChunksWithinLimit<TRendered>(options: RenderMarkdownIRChunksWithinLimitOptions<TRendered>): RenderedMarkdownChunk<TRendered>[];
//#endregion
//#region src/markdown/render.d.ts
type RenderStyleMarker = {
  open: string | ((span: MarkdownStyleSpan) => string);
  close: string;
};
type RenderStyleMap = Partial<Record<MarkdownStyle, RenderStyleMarker>>;
type RenderLink = {
  start: number;
  end: number;
  open: string;
  close: string;
};
type RenderOptions = {
  styleMarkers: RenderStyleMap;
  escapeText: (text: string) => string;
  buildLink?: (link: MarkdownLinkSpan, text: string) => RenderLink | null;
};
declare function renderMarkdownWithMarkers(ir: MarkdownIR, options: RenderOptions): string;
//#endregion
//#region src/shared/text/code-regions.d.ts
interface CodeRegion {
  start: number;
  end: number;
}
declare function findCodeRegions(text: string): CodeRegion[];
declare function isInsideCode(pos: number, regions: CodeRegion[]): boolean;
//#endregion
//#region src/shared/text/reasoning-tags.d.ts
type ReasoningTagMode = "strict" | "preserve";
type ReasoningTagTrim = "none" | "start" | "both";
declare function hasOrphanReasoningCloseBoundary(params: {
  before: string;
  after: string;
}): boolean;
declare function stripReasoningTagsFromText(text: string, options?: {
  mode?: ReasoningTagMode;
  trim?: ReasoningTagTrim;
}): string;
//#endregion
//#region src/shared/text/strip-markdown.d.ts
/**
 * Strip lightweight markdown formatting from text while preserving readable
 * plain-text structure for TTS and channel fallbacks.
 */
declare function stripMarkdown(text: string): string;
//#endregion
//#region src/terminal/safe-text.d.ts
/**
 * Normalize untrusted text for single-line terminal/log rendering.
 */
declare function sanitizeTerminalText(input: string): string;
//#endregion
//#region src/utils/directive-tags.d.ts
type InlineDirectiveParseResult = {
  text: string;
  audioAsVoice: boolean;
  replyToId?: string;
  replyToExplicitId?: string;
  replyToCurrent: boolean;
  hasAudioTag: boolean;
  hasReplyTag: boolean;
};
type InlineDirectiveParseOptions = {
  currentMessageId?: string;
  stripAudioTag?: boolean;
  stripReplyTags?: boolean;
};
type StripInlineDirectiveTagsResult = {
  text: string;
  changed: boolean;
};
type DisplayMessageWithContent = {
  content?: unknown;
} & Record<string, unknown>;
declare function stripInlineDirectiveTagsForDisplay(text: string): StripInlineDirectiveTagsResult;
declare function sanitizeReplyDirectiveId(rawReplyToId?: string): string | undefined;
declare function stripInlineDirectiveTagsForDelivery(text: string): StripInlineDirectiveTagsResult;
/**
 * Strips inline directive tags from text content while preserving message shape.
 * Empty post-strip text stays empty-string to preserve caller semantics.
 * Returns the input message reference (including the original content array) when
 * no text part changed, and reuses unchanged text-part references in mixed content,
 * so identity-equality consumers avoid spurious churn.
 */
declare function stripInlineDirectiveTagsFromMessageForDisplay(message: DisplayMessageWithContent | undefined): DisplayMessageWithContent | undefined;
declare function parseInlineDirectives(text?: string, options?: InlineDirectiveParseOptions): InlineDirectiveParseResult;
//#endregion
//#region src/utils/chunk-items.d.ts
declare function chunkItems<T>(items: readonly T[], size: number): T[][];
//#endregion
export { MarkdownStyleSpan as A, RenderMarkdownIRChunksWithinLimitOptions as C, MarkdownLinkSpan as D, MarkdownIR as E, markdownToIRWithMeta as F, sliceMarkdownIR as I, MarkdownTableMeta as M, chunkMarkdownIR as N, MarkdownParseOptions as O, markdownToIR as P, renderMarkdownWithMarkers as S, renderMarkdownIRChunksWithinLimit as T, isInsideCode as _, sanitizeReplyDirectiveId as a, RenderStyleMap as b, stripInlineDirectiveTagsFromMessageForDisplay as c, ReasoningTagMode as d, ReasoningTagTrim as f, findCodeRegions as g, CodeRegion as h, parseInlineDirectives as i, MarkdownTableData as j, MarkdownStyle as k, sanitizeTerminalText as l, stripReasoningTagsFromText as m, DisplayMessageWithContent as n, stripInlineDirectiveTagsForDelivery as o, hasOrphanReasoningCloseBoundary as p, InlineDirectiveParseResult as r, stripInlineDirectiveTagsForDisplay as s, chunkItems as t, stripMarkdown as u, RenderLink as v, RenderedMarkdownChunk as w, RenderStyleMarker as x, RenderOptions as y };