//#region src/browser/dom.d.ts
export declare function getDocument(): Document | null;
export declare function getDocumentBody(doc?: Document): HTMLElement | null;
export declare function getDocumentElement(doc?: Document): HTMLElement | null;
export declare function readDocumentLanguage(doc?: Document): string;
export declare function isDocumentElementDark(doc?: Document, className?: string): boolean;
export declare function isElementInDocumentBody(element: Element, doc?: Document): boolean;
export declare function isEscapeKeyEvent(event: Event): boolean;
export declare function scrollToElement(container: ParentNode, selector: string, options?: ScrollIntoViewOptions): boolean;
//#endregion
//#region src/browser/iframe.d.ts
export declare function getIframeBodyHeight(iframe: HTMLIFrameElement | undefined, offset?: number): number;
//#endregion
//#region src/constants/code.d.ts
export declare const DEFAULT_SHIKI_LIGHT_THEME = "github-light";
export declare const DEFAULT_SHIKI_DARK_THEME = "github-dark";
export declare const CODE_META_START_LINE_PATTERN: RegExp;
export declare const CODE_META_NO_LINE_NUMBERS_PATTERN: RegExp;
export declare const LANGUAGE_ALIAS: Record<string, string>;
export declare const LANGUAGE_EXTENSIONS: Record<string, string>;
//#endregion
//#region src/constants/common.d.ts
export declare const ANIMATION_TYPES: readonly ['fade-in', 'blur-in', 'slide-up'];
export declare const DEFAULT_ANIMATION: "fade-in";
export declare const DEFAULT_ANIMATION_STAGGER = 40;
export declare const ANIMATION_SPLITS: readonly ['auto', 'word', 'char'];
export declare const DEFAULT_ANIMATION_SPLIT: "auto";
export declare const STREAM_MARKDOWN_PREFIX = "stream-markdown";
export declare const DISABLED_TRANSITION_NAME = "stream-markdown-disabled";
export declare const STREAM_MARKDOWN_CSS_VARIABLES: {
  readonly animationDuration: '--stream-markdown-animation-duration';
  readonly defaultTransitionDuration: '--default-transition-duration';
};
export declare const CARETS: {
  readonly block: ' ▋';
  readonly circle: ' ●';
};
export declare const DEFAULT_HARDEN_OPTIONS: HardenOptions;
export declare const SHADCN_SCHEMAS: readonly ['background', 'foreground', 'card', 'card-foreground', 'popover', 'popover-foreground', 'primary', 'primary-foreground', 'secondary', 'secondary-foreground', 'muted', 'muted-foreground', 'accent', 'accent-foreground', 'destructive', 'border', 'input', 'ring', 'chart-1', 'chart-2', 'chart-3', 'chart-4', 'chart-5', 'sidebar', 'sidebar-foreground', 'sidebar-primary', 'sidebar-primary-foreground', 'sidebar-accent', 'sidebar-accent-foreground', 'sidebar-border', 'sidebar-ring'];
//#endregion
//#region src/constants/i18n.d.ts
export declare const DEFAULT_LANGUAGE: SupportedLanguage;
export declare const SUPPORT_LANGUAGES: SupportedLanguage[];
//#endregion
//#region src/types/builtin.d.ts
export type BuiltinPreviewers = 'mermaid' | 'html';
export type BuiltinUIComponents = 'Alert' | 'Button' | 'Caret' | 'CodeBlock' | 'Dropdown' | 'ErrorComponent' | 'Icon' | 'Image' | 'Modal' | 'Segmented' | 'Spin' | 'Table' | 'Tooltip' | 'ZoomContainer';
export type CaretType = 'block' | 'circle';
export type AnimationType = typeof ANIMATION_TYPES[number] | (string & {});
export type AnimationSplit = typeof ANIMATION_SPLITS[number];
export type ResolvedAnimationSplit = Exclude<AnimationSplit, 'auto'>;
export interface SelectOption {
  label: string;
  value: string | number;
  icon?: string;
}
export type UIErrorVariant = 'vanilla' | 'image' | 'mermaid' | 'katex' | 'harden-image' | 'harden-link';
//#endregion
//#region src/types/cdn.d.ts
export type ModuleStrategy = 'esm' | 'umd';
export type CdnModule = 'shiki' | 'mermaid' | 'beautiful-mermaid' | 'katex' | 'katex-css';
export interface CdnOptions {
  baseUrl?: string;
  getUrl?: (module: CdnModule, version: string) => string | undefined;
  shiki?: boolean;
  mermaid?: ModuleStrategy | false;
  beautifulMermaid?: ModuleStrategy | false;
  katex?: ModuleStrategy | false;
}
export type SharedCdnModule = CdnModule;
export type SharedCdnOptions = CdnOptions;
//#endregion
//#region src/types/common.d.ts
export type MaybeArray<T> = T | T[];
export type MaybeGetter<T> = T | (() => T);
export type MaybePromise<T> = T | Promise<T>;
export type TextDirection = 'ltr' | 'rtl';
export type TextDirectionConfig = 'auto' | TextDirection;
//#endregion
//#region src/types/table.d.ts
export type TableFormat = 'csv' | 'tsv' | 'markdown';
export type CSVSeparator = ',' | ';' | '\t' | 'auto';
export interface TableData {
  headers: string[];
  rows: string[][];
}
//#endregion
//#region src/types/controls.d.ts
export type ZoomControlPosition = 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
export interface DownloadControlOptions {
  filename: string;
}
export type DownloadControlConfig = boolean | DownloadControlOptions;
export type TableControlsConfig<TTransformer = unknown> = boolean | {
  copy?: boolean | string;
  csvSeparator?: CSVSeparator;
  download?: DownloadControlConfig | string;
  fullscreen?: boolean;
  customize?: TTransformer;
};
export type CodeControlsConfig<TTransformer = unknown> = boolean | {
  collapse?: boolean;
  copy?: boolean;
  download?: DownloadControlConfig;
  fullscreen?: boolean;
  customize?: TTransformer;
};
export type ImageControlsConfig<TTransformer = unknown> = boolean | {
  preview?: boolean;
  download?: boolean;
  carousel?: boolean;
  flip?: boolean;
  rotate?: boolean;
  controlPosition?: ZoomControlPosition;
  customize?: TTransformer;
};
export type MermaidControlsConfig<TTransformer = unknown> = boolean | {
  download?: DownloadControlConfig;
  inlineInteractive?: boolean;
  position?: ZoomControlPosition;
  customize?: TTransformer;
};
export type ControlsConfig<TTableTransformer = unknown, TCodeTransformer = unknown, TImageTransformer = unknown, TMermaidTransformer = unknown> = boolean | {
  table?: boolean | TableControlsConfig<TTableTransformer>;
  code?: boolean | CodeControlsConfig<TCodeTransformer>;
  image?: boolean | ImageControlsConfig<TImageTransformer>;
  mermaid?: boolean | MermaidControlsConfig<TMermaidTransformer>;
};
//#endregion
//#region src/types/events.d.ts
export type DownloadEvent = UrlDownloadEvent | ContentDownloadEvent;
export interface UrlDownloadEvent {
  type: 'image';
  url: string;
}
export interface ContentDownloadEvent {
  type: 'code' | 'mermaid' | 'table';
  content: string;
}
//#endregion
//#region src/types/extensions.d.ts
export interface ExtensionRuntime {
  /** Prepare extension resources. Use a no-op when no preload work is needed. */
  preload: () => MaybePromise<void>;
  /** Release extension-owned resources. Use a no-op when resources are shared or permanent. */
  dispose: () => MaybePromise<void>;
}
export interface CodeToken {
  content: string;
  htmlStyle?: Record<string, string | number | undefined>;
}
export interface CodeHighlightResult {
  bg?: string;
  fg?: string;
  grammarState?: {
    lang?: string;
  };
  themeName?: string;
  tokens: CodeToken[][];
}
export interface CodeHighlightInput {
  code: string;
  isDark: boolean;
  language: string;
}
export interface CodeExtension extends ExtensionRuntime {
  highlight: (input: CodeHighlightInput) => Promise<CodeHighlightResult>;
  getTheme?: (isDark: boolean) => Promise<Record<string, unknown> | null>;
}
export interface MathRenderInput {
  code: string;
  displayMode: boolean;
}
export interface MathRenderResult {
  error?: string;
  html?: string;
}
export interface MathExtension<TParserPlugin = unknown, TErrorComponent = unknown> extends ExtensionRuntime {
  ensureCss?: () => MaybePromise<void>;
  errorComponent?: TErrorComponent;
  parserPlugin: TParserPlugin;
  render: (input: MathRenderInput) => Promise<MathRenderResult>;
}
export interface MermaidRenderInput {
  code: string;
  isDark: boolean;
  theme?: Record<string, unknown> | null;
}
export interface MermaidExtensionRenderResult {
  error?: string;
  supported?: boolean;
  svg?: string;
  valid: boolean;
}
export interface MermaidExtension<TErrorComponent = unknown> extends ExtensionRuntime {
  errorComponent?: TErrorComponent;
  render: (input: MermaidRenderInput) => Promise<MermaidExtensionRenderResult>;
  supports: (code: string) => boolean;
}
export interface StreamMarkdownExtensions<TParserPlugin = unknown, TComponent = unknown> {
  beautifulMermaid?: MermaidExtension<TComponent>;
  code?: CodeExtension;
  math?: MathExtension<TParserPlugin, TComponent>;
  mermaid?: MermaidExtension<TComponent>;
}
//#endregion
//#region src/types/i18n.d.ts
export interface LocaleConfig {
  button: {
    zoomIn: string;
    zoomOut: string;
    resetZoom: string;
    preview: string;
    source: string;
    collapse: string;
    copy: string;
    copied: string;
    download: string;
    minimize: string;
    maximize: string;
    flipY: string;
    flipX: string;
    rotateLeft: string;
    rotateRight: string;
    previous: string;
    next: string;
    back: string;
    confirm: string;
    cancel: string;
  };
  error: {
    vanilla: string;
    image: string;
    mermaid: string;
    katex: string;
    harden: string;
  };
  link: {
    title: string;
    description: string;
    copy: string;
    open: string;
  };
  dialog?: {
    fullscreen: string;
    imagePreview: string;
  };
}
export type SupportedLanguage = 'en-US' | 'zh-CN';
//#endregion
//#region src/types/options.d.ts
export type PreviewSegmentedPlacement = 'left' | 'center' | 'right' | 'auto';
export interface HtmlPreviewerOptions {
  autoHeight?: boolean;
  height?: number | string;
  maxHeight?: number | string;
  sandbox?: string;
}
export type PreviewerConfig<TComponent = unknown> = boolean | {
  placement?: PreviewSegmentedPlacement;
  progressive?: Record<string, boolean>;
  html?: HtmlPreviewerOptions;
  components?: {
    mermaid?: boolean | TComponent;
    html?: boolean | TComponent;
  } & Record<string, TComponent>;
};
export interface ImageOptions<TComponent = unknown> {
  fallback?: string;
  caption?: boolean;
  referrerPolicy?: ReferrerPolicy;
  errorComponent?: TComponent;
}
export type LinkFaviconResolver = (url: string) => MaybePromise<string | undefined>;
export interface LinkOptions {
  favicon?: boolean | LinkFaviconResolver;
  safetyCheck?: boolean;
  isTrusted?: (url: string) => Promise<boolean> | boolean;
}
export interface CodeOptions<TComponent = unknown> {
  variant?: CodeBlockVariant;
  languageIcon?: boolean;
  languageName?: boolean;
  lineNumbers?: boolean;
  maxHeight?: number | string;
  language?: Record<string, CodeOptionsLanguage<TComponent>>;
}
export type CodeBlockVariant = 'modern' | 'classic' | 'minimal';
export interface CodeOptionsLanguage<TComponent = unknown> extends Omit<CodeOptions<TComponent>, 'languageIcon'> {
  languageIcon?: boolean | TComponent;
}
export interface TableOptions {
  maxHeight?: number | string;
}
export interface HardenOptions<TComponent = unknown> {
  defaultOrigin?: string;
  allowedLinkPrefixes?: string[];
  allowedImagePrefixes?: string[];
  allowedProtocols?: string[];
  allowDataImages?: boolean;
  errorComponent?: TComponent;
}
export interface UIOptions {
  hideTooltip?: boolean;
}
//#endregion
//#region src/types/stream.d.ts
export interface StreamMarkdownContext<TControls = unknown, TPreviewers = unknown, THardenOptions = unknown, TCodeOptions = unknown, TImageOptions = unknown, TLinkOptions = unknown, TUIOptions = unknown, TExtensions = unknown> {
  controls?: TControls;
  previewers?: TPreviewers;
  hardenOptions?: THardenOptions;
  codeOptions?: TCodeOptions;
  tableOptions?: TableOptions;
  imageOptions?: TImageOptions;
  linkOptions?: TLinkOptions;
  uiOptions?: TUIOptions;
  extensions?: TExtensions;
  isDark?: boolean;
}
export interface StreamMarkdownHooks {
  beforeDownload?: (event: DownloadEvent) => MaybePromise<boolean>;
}
export interface StreamMarkdownViewProps<TMarkdownComponents = unknown, TIcons = unknown, TUIComponents = unknown, TCaret extends string = string> {
  mode?: 'static' | 'streaming';
  /** Force one text direction or detect it independently for each semantic block. */
  dir?: TextDirectionConfig;
  content?: string;
  components?: TMarkdownComponents;
  icons?: Partial<TIcons>;
  uiComponents?: Partial<TUIComponents>;
  locale?: string | LocaleConfig;
  enableAnimate?: boolean;
  animation?: AnimationType;
  animationSplit?: AnimationSplit;
  animationDuration?: number | string;
  animationStagger?: number;
  caret?: TCaret;
  themeElement?: () => HTMLElement | undefined;
}
export type StreamMarkdownProps<TMarkdownComponents = unknown, TIcons = unknown, TUIComponents = unknown, TCaret extends string = string, TControls = unknown, TPreviewers = unknown, THardenOptions = unknown, TCodeOptions = unknown, TImageOptions = unknown, TLinkOptions = unknown, TUIOptions = unknown, TExtensions = unknown> = StreamMarkdownContext<TControls, TPreviewers, THardenOptions, TCodeOptions, TImageOptions, TLinkOptions, TUIOptions, TExtensions> & StreamMarkdownViewProps<TMarkdownComponents, TIcons, TUIComponents, TCaret> & StreamMarkdownHooks;
//#endregion
//#region src/types/ui.d.ts
export type UIClassValue = string | string[] | Record<string, unknown>;
export type UIStyleValue = Record<string, string | number | undefined>;
export interface UIButtonProps<TComponent = unknown, TStyle = UIStyleValue, TClass = UIClassValue> {
  variant?: 'icon' | 'text';
  name: string;
  buttonClass?: TClass;
  buttonStyle?: TStyle;
  icon?: string | TComponent;
  iconWidth?: number;
  iconHeight?: number;
  iconClass?: TClass;
  iconStyle?: TStyle;
  options?: SelectOption[];
  announcement?: string;
}
export interface UIAlertProps {
  icon?: string;
  title?: string;
  description?: string;
  zIndex?: number;
  confirmText?: string;
  cancelText?: string;
  open?: boolean;
}
export interface UIDropdownProps {
  title?: string;
  options?: SelectOption[];
}
export interface UIErrorComponentProps<TComponent = unknown> {
  variant?: UIErrorVariant;
  showIcon?: boolean;
  icon?: string | TComponent;
  message?: string;
}
export interface UIIconProps<TComponent = unknown, TStyle = UIStyleValue, TClass = UIClassValue> {
  icon: string | TComponent;
  width?: number;
  height?: number;
  class?: TClass;
  style?: TStyle;
}
export interface UIImageProps<TNodeProps = unknown, TControls = unknown> {
  src?: string;
  alt?: string;
  title?: string;
  preview?: boolean;
  referrerPolicy?: ReferrerPolicy;
  margin?: number;
  controls?: TControls;
  transformHardenUrl?: (url: string) => string | null;
  nodeProps: TNodeProps;
  handleDownload?: (url: string) => Promise<void>;
}
export interface UIModalProps<TStyle = UIStyleValue> {
  title?: string;
  titleId?: string;
  ariaLabel?: string;
  zIndex?: number;
  modalStyle?: TStyle;
  headerStyle?: TStyle;
  transition?: string;
  close?: () => void;
  open?: boolean;
}
export interface UISegmentedProps<TStyle = UIStyleValue> {
  options?: SelectOption[];
  buttonStyle?: TStyle;
  value?: string;
}
export interface UITableProps {
  getAlign?: (index: number) => 'left' | 'center' | 'right';
  getDirection?: (cell: unknown) => TextDirection | undefined;
  headers?: unknown[];
  rows?: Array<{
    children: unknown[];
  }>;
}
export interface UITooltipProps {
  content?: string;
  trigger?: 'hover' | 'click';
  placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
  delay?: number | [number, number];
}
export interface UIZoomContainerProps<TStyle = UIStyleValue> {
  interactive?: boolean;
  showControl?: boolean;
  controlSize?: 'vanilla' | 'large';
  position?: ZoomControlPosition;
  containerStyle?: TStyle;
}
export type Control<TButtonProps extends object = UIButtonProps, TEvent = MouseEvent> = TButtonProps & {
  key: string;
  visible?: () => boolean;
  onClick: (event: TEvent, item?: SelectOption) => void;
};
export interface ControlDescriptor<TStyle = UIStyleValue> {
  key: string;
  labelKey?: string;
  label?: string;
  icon?: string;
  variant?: 'icon' | 'text';
  options?: SelectOption[];
  visible?: boolean;
  buttonStyle?: TStyle;
  iconStyle?: TStyle;
  iconWidth?: number;
  iconHeight?: number;
}
//#endregion
//#region src/types/view.d.ts
export type UIComponents<TComponent = unknown, TComponentName extends PropertyKey = string> = Record<TComponentName, TComponent>;
export type Icons<TComponent = unknown, TIconName extends PropertyKey = string, TOptionalIconName extends PropertyKey = never> = Record<TIconName, TComponent> & Partial<Record<TOptionalIconName, TComponent>> & Record<string, TComponent>;
export type ControlTransformer<TControl, TProps> = (builtin: TControl[], props: TProps) => TControl[];
//#endregion
//#region src/types/zoom.d.ts
export interface ZoomOptions {
  minZoom?: number;
  maxZoom?: number;
  zoomStep?: number;
  wheelSensitivity?: number;
  initialZoom?: number;
  initialTranslateX?: number;
  initialTranslateY?: number;
}
export interface ZoomState {
  zoom: number;
  translateX: number;
  translateY: number;
}
export interface ZoomPoint {
  x: number;
  y: number;
}
export interface ZoomRect {
  left: number;
  top: number;
  width: number;
  height: number;
}
export interface TouchZoomState {
  initialDistance: number;
  initialZoom: number;
  initialTranslateX: number;
  initialTranslateY: number;
  centerX: number;
  centerY: number;
}
export interface ZoomControlPositionStyle {
  top?: string;
  right?: string;
  bottom?: string;
  left?: string;
  transform?: string;
}
export interface MediumZoomTransformInput {
  rect: ZoomRect;
  naturalWidth: number;
  naturalHeight: number;
  viewportWidth: number;
  viewportHeight: number;
  margin: number;
}
export interface MediumZoomTransformResult {
  initialTransform: string;
  targetTransform: string;
}
export interface MediumZoomOutTransformInput {
  originalRect: ZoomRect;
  zoomRect: ZoomRect;
  currentTransform: string;
}
export interface WheelZoomInput {
  state: ZoomState;
  point: ZoomPoint;
  rect: ZoomRect;
  deltaY: number;
  ctrlKey?: boolean;
  metaKey?: boolean;
  options?: ZoomOptions;
}
export interface TouchZoomInput {
  state: ZoomState;
  rect: ZoomRect;
  touches: [ZoomPoint, ZoomPoint];
  options?: ZoomOptions;
}
export interface TouchZoomMoveInput {
  rect: ZoomRect;
  touches: [ZoomPoint, ZoomPoint];
  touchState: TouchZoomState;
  options?: ZoomOptions;
}
//#endregion
//#region src/utils/text.d.ts
export interface TextPart {
  key: string;
  value: string;
  whitespace: boolean;
  animationSplit: ResolvedAnimationSplit;
}
export declare function splitTextByWord(text: string): string[];
export declare function splitTextByChar(text: string): string[];
export declare function splitTextByAuto(text: string): string[];
export declare function resolveTextAnimationSplit(text: string, split?: AnimationSplit): ResolvedAnimationSplit;
export declare function splitText(text: string, split?: AnimationSplit): string[];
export declare function createTextParts(text: string, keyPrefix?: string, split?: AnimationSplit): TextPart[];
//#endregion
//#region src/utils/animation.d.ts
export interface AnimationSchedule {
  baseDelay: number;
  step: number;
}
export interface AnimationTimeline {
  beginPass: (now?: number) => number;
  commitPass: () => void;
  reset: () => void;
  take: (count: number, stagger: number, now: number) => AnimationSchedule;
}
export interface CreateAnimationTimelineOptions {
  now?: () => number;
}
export interface TextAnimationPassOptions {
  enabled: boolean;
  stagger: number;
}
export interface TextAnimationScheduler {
  beginPass: (options: TextAnimationPassOptions) => void;
  commitPass: (compareKeys?: (left: string, right: string) => number) => ReadonlyMap<string, number>;
  retain: (keys: ReadonlySet<string>) => void;
  schedule: (parts: TextPart[]) => ReadonlyMap<string, number>;
}
export declare function createAnimationTimeline(options?: CreateAnimationTimelineOptions): AnimationTimeline;
export declare function createTextAnimationScheduler(timeline?: AnimationTimeline): TextAnimationScheduler;
export declare function getTransitionName(animation: string): string;
export declare function normalizeAnimationDuration(duration: number | string | undefined): string | undefined;
//#endregion
//#region src/utils/cdn.d.ts
export declare function dynamicImport<T>(url: string): Promise<T>;
export declare function getModuleStrategy(option?: ModuleStrategy | boolean): ModuleStrategy;
export declare function isModuleEnabled(option?: ModuleStrategy | boolean): boolean;
export declare function getModuleFromImport<T>(module: T, globalVar: keyof Window | undefined): T | null;
//#endregion
//#region src/utils/code.d.ts
export declare function resolveCodeOptions<TComponent = unknown>(codeOptions: CodeOptions<TComponent> | undefined, language: string): CodeOptionsLanguage<TComponent>;
export declare function isCodeOptionEnabled(value: unknown, defaultValue?: boolean): boolean;
//#endregion
//#region src/utils/config.d.ts
export declare function getConfigValue<T = unknown>(config: unknown, key: string): T | undefined;
export declare function isConfigEnabled(config: unknown, key: string): boolean;
export declare function getDownloadFilename(config: unknown, type: 'code' | 'table' | 'mermaid', fallback: string): string;
export declare function filterVisibleItems<T extends {
  visible?: (() => boolean) | undefined;
}>(items: T[]): T[];
//#endregion
//#region src/utils/control.d.ts
export declare function resolveVisibleControls<TControl extends {
  visible?: (() => boolean) | undefined;
}, TProps>(config: unknown, type: string, builtinControls: TControl[], props: TProps): TControl[];
//#endregion
//#region src/utils/direction.d.ts
/** Detect direction from the majority of strong Unicode letters. */
export declare function detectTextDirection(text: string): TextDirection;
export declare function resolveTextDirection(text: string, direction: TextDirectionConfig | undefined): TextDirection | undefined;
//#endregion
//#region src/utils/env.d.ts
export declare function isClient(): boolean;
export declare function isServer(): boolean;
export declare function isSupportESM(): boolean;
//#endregion
//#region src/utils/file.d.ts
export declare function removeTrailingSlash(url: string): string;
export declare function save(filename: string, content: string | Blob, mimeType: string): void;
export declare function saveImage(url: string, alt?: string): Promise<void>;
/**
 * Mermaid output may be HTML-serialized. Serialize the SVG node as XML before
 * downloading so embedded HTML-style elements such as <br> use valid markup.
 */
export declare function serializeSvgForDownload(svgString: string): string;
export declare function svgToPngBlob(svgString: string, options?: {
  scale?: number;
}): Promise<Blob> | null;
//#endregion
//#region src/utils/getter.d.ts
export declare function resolveGetter<T>(value: MaybeGetter<T> | undefined): T | undefined;
//#endregion
//#region src/utils/harden.d.ts
export declare function transformUrl(url: unknown, allowedPrefixes: string[], defaultOrigin: string, allowDataImages?: boolean, isImage?: boolean, allowedProtocols?: string[]): string | null;
export declare function transformHardenedUrl<TComponent = unknown>(url: string | undefined, hardenOptions?: HardenOptions<TComponent>, options?: {
  defaults?: HardenOptions<TComponent>;
  isImage?: boolean;
  loading?: boolean;
}): string | null;
//#endregion
//#region src/utils/i18n.d.ts
export declare function getI18nText(messages: unknown, key: string): string;
export declare function isSupportedLanguage(language: string): language is SupportedLanguage;
export declare function resolveSupportedLanguage(language?: string): SupportedLanguage;
export declare function loadLocaleConfig(language: string | LocaleConfig): Promise<LocaleConfig>;
export declare function resolveLocaleLanguage(language: string | LocaleConfig): SupportedLanguage;
export declare function resolveLocaleInput(locale: string | LocaleConfig | undefined, options?: {
  htmlLanguage?: string;
  navigatorLanguage?: string;
}): string | LocaleConfig;
//#endregion
//#region src/utils/idle.d.ts
export type IdleCallbackId = number | ReturnType<typeof globalThis.setTimeout>;
export declare function createIdleCallback(): {
  request: (cb: IdleRequestCallback, timeout?: number) => IdleCallbackId;
  cancel: (id: IdleCallbackId) => void;
};
//#endregion
//#region src/utils/medium-zoom.d.ts
export declare function calculateMediumZoomTransforms({ rect, naturalWidth, naturalHeight, viewportWidth, viewportHeight, margin }: MediumZoomTransformInput): MediumZoomTransformResult;
export declare function calculateMediumZoomOutTransform({ originalRect, zoomRect, currentTransform }: MediumZoomOutTransformInput): string;
//#endregion
//#region src/utils/overlay.d.ts
export declare const OVERLAY_CONTAINER_ID = "stream-markdown-overlay";
export declare function getOverlayContainer(): HTMLElement | null;
//#endregion
//#region src/utils/style.d.ts
export declare function normalizeCssSize(size: number | string | undefined): string | undefined;
export declare function resolveScrollableMaxHeight(maxHeight: number | string | undefined): string | undefined;
//#endregion
//#region src/utils/table.d.ts
export type TableAlign = 'left' | 'center' | 'right';
export declare function resolveTableAlign(align: Array<TableAlign | null | undefined> | undefined, index: number): TableAlign;
export declare function getTableCellNodes<TNode = unknown>(cell: TNode | {
  children?: TNode[];
}): TNode[];
export declare function extractTableDataFromElement(tableElement: HTMLElement): TableData;
export declare function getTableCsvSeparator(config: unknown): CSVSeparator;
export declare function tableDataToCSV(data: TableData, separator?: CSVSeparator): string;
export declare function tableDataToTSV(data: TableData): string;
export declare function escapeMarkdownTableCell(cell: string): string;
export declare function tableDataToMarkdown(data: TableData): string;
//#endregion
//#region src/utils/theme.d.ts
export declare function normalizeThemeVariableValue(value: string): string | undefined;
export declare function resolveThemeVariables(schemas: readonly string[], getPropertyValue: (name: string) => string): Record<string, string>;
//#endregion
//#region src/utils/version.d.ts
export declare function stripVersionRangePrefix(version: string): string;
//#endregion
//#region src/utils/zoom.d.ts
export declare function resolveZoomOptions(options?: ZoomOptions): Required<ZoomOptions>;
export declare function clampZoom(value: number, minZoom: number, maxZoom: number): number;
export declare function createZoomState(options?: ZoomOptions): ZoomState;
export declare function zoomInState(state: ZoomState, options?: ZoomOptions): ZoomState;
export declare function zoomOutState(state: ZoomState, options?: ZoomOptions): ZoomState;
export declare function resetZoomState(options?: ZoomOptions): ZoomState;
export declare function setZoomState(state: ZoomState, value: number, options?: ZoomOptions): ZoomState;
export declare function createDragStart(point: ZoomPoint, state: ZoomState): ZoomPoint;
export declare function createDraggedState(point: ZoomPoint, dragStart: ZoomPoint): Pick<ZoomState, 'translateX' | 'translateY'>;
export declare function getTouchDistance(firstTouch: ZoomPoint, secondTouch: ZoomPoint): number;
export declare function createTouchZoomState({ state, rect, touches }: TouchZoomInput): TouchZoomState;
export declare function createTouchMovedState({ rect, touches, touchState, options }: TouchZoomMoveInput): ZoomState;
export declare function createWheelZoomState({ state, point, rect, deltaY, ctrlKey, metaKey, options }: WheelZoomInput): ZoomState | null;
export declare function createZoomTransformStyle(state: ZoomState): {
  transform: string;
};
export declare function resolveZoomControlPosition(position: ZoomControlPosition): ZoomControlPositionStyle;
//#endregion
//#region src/browser/medium-zoom.d.ts
export declare function cloneMediumZoomElement(original: HTMLElement): HTMLElement;
export declare function mountMediumZoomClone(cloned: HTMLElement, container?: HTMLElement): boolean;
export declare function unmountMediumZoomClone(cloned: HTMLElement): void;
export declare function setMediumZoomOriginalVisibility(original: HTMLElement, visible: boolean): void;
export declare function readMediumZoomElementTransform(element: HTMLElement): string;
export declare function calculateMediumZoomInTransforms(options: {
  original: HTMLElement;
  cloned: HTMLElement;
  margin: number;
}): ReturnType<typeof calculateMediumZoomTransforms>;
export declare function prepareMediumZoomInClone(cloned: HTMLElement, initialTransform: string): void;
export declare function playMediumZoomInClone(cloned: HTMLElement, targetTransform: string): void;
export declare function prepareMediumZoomOutClone(options: {
  cloned: HTMLElement;
  zoomElement: HTMLElement;
  currentTransform: string;
}): void;
export declare function playMediumZoomOutClone(options: {
  cloned: HTMLElement;
  original: HTMLElement;
  zoomElement: HTMLElement;
  currentTransform: string;
}): void;
//#endregion
//#region src/browser/overlay.d.ts
export declare function ensureOverlayContainer(options: {
  isDark: boolean;
  cssVariables?: Record<string, string>;
}): HTMLElement | null;
export declare function createOverlayContainer(isDark: boolean): HTMLElement;
export declare function syncOverlayContainerTheme(overlayContainer: HTMLElement | null, options: {
  isDark: boolean;
  cssVariables?: Record<string, string>;
}): void;
//#endregion
//#region src/browser/svg.d.ts
export interface SvgIntrinsicSize {
  width: number;
  height: number;
}
export declare function getSvgIntrinsicSize(svgElement: SVGSVGElement): SvgIntrinsicSize | null;
export declare function calculateSvgContainerHeight(svgSize: SvgIntrinsicSize, containerWidth: number): number;
export declare function measureSvgContainerHeight(container: HTMLElement, selector?: string): number | null;
//#endregion
//#region src/browser/theme.d.ts
export declare function resolveThemeElement(element?: () => HTMLElement | undefined): HTMLElement | undefined;
export declare function readThemeVariables(element?: HTMLElement): Record<string, string>;
//#endregion
//#region src/browser/window.d.ts
export declare function openExternalUrl(url: string, target?: string): void;
//#endregion
//#region src/browser/zoom.d.ts
export interface BrowserWheelZoomInput {
  event: WheelEvent;
  element: Element;
  state: ZoomState;
  options?: ZoomOptions;
}
export interface BrowserTouchZoomInput {
  event: TouchEvent;
  element: Element;
  state: ZoomState;
}
export interface BrowserTouchZoomMoveInput {
  event: TouchEvent;
  element: Element;
  touchState: TouchZoomState;
  options?: ZoomOptions;
}
export declare function createZoomPoint(clientX: number, clientY: number): ZoomPoint;
export declare function createPointerDragStart(event: PointerEvent, state: ZoomState): ZoomPoint;
export declare function createPointerDraggedState(event: PointerEvent, dragStart: ZoomPoint): Pick<ZoomState, 'translateX' | 'translateY'>;
export declare function capturePointerForNonMouseEvent(event: PointerEvent): boolean;
export declare function createBrowserWheelZoomState({ event, element, state, options }: BrowserWheelZoomInput): ZoomState | null;
export declare function createBrowserTouchZoomState({ event, element, state }: BrowserTouchZoomInput): TouchZoomState | null;
export declare function createBrowserTouchMovedState({ event, element, touchState, options }: BrowserTouchZoomMoveInput): ZoomState | null;
//#endregion
//#region src/core/code.d.ts
export interface CodePreviewableOptions<TComponent = unknown> {
  previewers?: PreviewerConfig<TComponent>;
  language: string;
  nodeLoading?: boolean;
  hasMermaid?: boolean;
  progressiveRender?: boolean;
  isPreviewComponent?: (component: unknown) => boolean;
}
export interface CodeMaxHeightOptions<TComponent = unknown> {
  mode: 'preview' | 'source';
  codeOptions?: CodeOptions<TComponent>;
  language: string;
}
export interface CodeBlockControlDescriptorOptions {
  collapsed: boolean;
  fullscreen: boolean;
  copied: boolean;
  language: string;
  showCollapse: boolean;
  showCopy: boolean;
  showDownload: boolean;
  showFullscreen: boolean;
  downloadOptions?: SelectOption[];
}
export interface CodeBlockControlState {
  collapsed: boolean;
  fullscreen: boolean;
}
export interface CodeBlockControlActionOptions {
  key: string;
  select?: SelectOption;
  filename?: string;
  state: CodeBlockControlState;
  node: CodeBlockNode;
  language: string;
  beforeDownload?: (event: DownloadEvent) => MaybePromise<boolean>;
  copyText?: (content: string) => MaybePromise<void>;
  onCopied?: (content: string) => void;
  saveFile?: (filename: string, content: string | Blob, mimeType: string) => MaybePromise<void>;
  saveMermaid?: (format: 'svg' | 'png', code: string, filename?: string) => MaybePromise<void>;
}
export interface CodeBlockNode {
  value: string;
  lang?: string | null;
  meta?: string;
  loading?: boolean;
}
export interface CodeBlockModeState {
  mode: 'preview' | 'source';
}
export interface CodeOptionsModel<TComponent = unknown> {
  languageCodeOptions: CodeOptionsLanguage<TComponent>;
  variant: CodeBlockVariant;
  showLanguageIcon: boolean;
  showLanguageName: boolean;
  showLineNumbers: boolean;
  showLanguageTitle: boolean;
}
export interface CodeBlockModelOptions<TComponent = unknown> {
  node: CodeBlockNode;
  codeOptions?: CodeOptions<TComponent>;
  previewers?: PreviewerConfig<TComponent>;
  controls?: unknown;
  hasMermaid?: boolean;
  mode: 'preview' | 'source';
  isPreviewComponent?: (component: unknown) => boolean;
}
export interface CodeBlockModel<TComponent = unknown> extends CodeOptionsModel<TComponent> {
  language: string;
  progressiveRender: boolean;
  previewPlacement: PreviewSegmentedPlacement;
  previewable: boolean;
  inlineInteractive: boolean;
  maxHeight?: string;
  downloadOptions: SelectOption[];
}
export declare function resolveCodeLanguage(lang?: string | null): string;
export declare function createCodeOptionsModel<TComponent = unknown>(codeOptions: CodeOptions<TComponent> | undefined, language: string): CodeOptionsModel<TComponent>;
export declare function createCodeBlockModel<TComponent = unknown>(options: CodeBlockModelOptions<TComponent>): CodeBlockModel<TComponent>;
export declare function shouldProgressivelyRenderPreview<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined, language: string): boolean;
export declare function resolvePreviewPlacement<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined, showLanguageTitle: boolean): PreviewSegmentedPlacement;
export declare function isCodePreviewable<TComponent = unknown>(options: CodePreviewableOptions<TComponent>): boolean;
export declare function resolveCodePreviewComponent<TComponent = unknown>(language: string, previewers: PreviewerConfig<TComponent> | undefined, builtinPreviewers: Partial<Record<string, TComponent>>, isPreviewComponent?: (component: unknown) => boolean): TComponent | undefined;
export declare function resolveCodeMaxHeight<TComponent = unknown>(options: CodeMaxHeightOptions<TComponent>): string | undefined;
export declare function getCodeDownloadOptions(language: string, hasMermaid: boolean): SelectOption[];
export declare function createCodeBlockControlDescriptors(options: CodeBlockControlDescriptorOptions): ControlDescriptor[];
export declare function getCodeFileExtension(language: string): string | undefined;
export declare function createCodeRendererModel(node: CodeBlockNode): {
  code: string;
  lang: string;
  languageClass: string;
  lines: string[];
  noLineNumbers: boolean;
  startLine: number;
};
export declare function syncCodeBlockMode(state: CodeBlockModeState, previewable: boolean): CodeBlockModeState;
export declare function handleCodeBlockControlAction(options: CodeBlockControlActionOptions): Promise<CodeBlockControlState>;
//#endregion
//#region src/core/floating.d.ts
export type FloatingDelay = number | [number, number];
export interface FloatingPositionState {
  x?: number | null;
  y?: number | null;
  strategy?: 'absolute' | 'fixed';
}
export declare function resolveFloatingDelay(delay?: FloatingDelay): {
  show: number;
  hide: number;
};
export declare function createFloatingStyle(state: FloatingPositionState): {
  position: "absolute" | "fixed";
  top: string;
  left: string;
};
export declare function isClickInsideFloating(target: Node, referenceEl?: HTMLElement, floatingEl?: HTMLElement): boolean;
//#endregion
//#region src/core/html.d.ts
export type HtmlPreviewMeasurementMode = 'dom' | 'message' | 'fallback';
export declare const DEFAULT_HTML_PREVIEW_SANDBOX = "allow-scripts";
export declare const DEFAULT_HTML_PREVIEW_HEIGHT = 360;
export declare const HTML_PREVIEW_HEIGHT_MESSAGE_TYPE = "stream-markdown:html-preview-height";
export declare const MAX_HTML_PREVIEW_AUTO_HEIGHT = 1000;
export declare function createHtmlPreviewModel(node: CodeBlockNode): {
  code: string;
};
export declare function getHtmlPreviewSandboxTokens(sandbox: string): Set<string>;
export declare function resolveHtmlPreviewSandbox<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined): string;
export declare function resolveHtmlPreviewAutoHeight<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined): boolean;
export declare function resolveHtmlPreviewHeight<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined): string;
export declare function resolveHtmlPreviewMaxHeight<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined): string | undefined;
export declare function resolveHtmlPreviewMaxHeightValue<TComponent = unknown>(previewers: PreviewerConfig<TComponent> | undefined): number | undefined;
export declare function resolveHtmlPreviewMeasurementMode(sandbox: string, autoHeight: boolean): HtmlPreviewMeasurementMode;
export declare function createHtmlPreviewSrcdoc(code: string): string;
export declare function getHtmlPreviewMessageHeight(data: unknown, offset?: number, maxHeight?: number): number | undefined;
export declare function clampHtmlPreviewHeight(height: number, maxHeight?: number): number;
//#endregion
//#region src/core/image.d.ts
export interface ImageRenderNode {
  url: string;
  alt?: string | null;
  title?: string | null;
  loading?: boolean;
}
export interface ImageModelOptions<TComponent = unknown> {
  node: ImageRenderNode;
  imageOptions?: ImageOptions<TComponent>;
  fallbackAttempted?: boolean;
  imageLoaded?: boolean;
  isHardenUrl?: boolean;
  loadError?: boolean;
}
export declare function createImageModel<TComponent = unknown>(options: ImageModelOptions<TComponent>): {
  readonly isLoading: boolean;
  readonly fallback: string;
  readonly imageSrc: string;
  readonly alt: string;
  readonly title: string;
  readonly showCaption: boolean;
  readonly figureWidth: "100%" | "auto";
  readonly showSpin: boolean;
  readonly showImage: boolean;
  readonly showError: boolean;
  readonly errorVariant: "harden-image" | "image";
};
//#endregion
//#region src/core/image-preview.d.ts
export interface ImagePreviewTransformState {
  scaleX: number;
  scaleY: number;
  rotate: number;
}
export interface ImagePreviewIconAvailability {
  arrowRight?: boolean;
  flipVertical?: boolean;
  rotateRight?: boolean;
}
export interface ImagePreviewModelOptions {
  sources?: string[];
  src?: string;
  controls?: unknown;
  transformHardenUrl?: (url: string) => string | null;
  hasDownload?: boolean;
  preview?: boolean;
  loaded?: boolean;
  hasElement?: boolean;
  state?: Partial<ImagePreviewTransformState>;
  icons?: ImagePreviewIconAvailability;
  elementStyle?: UIStyleValue;
}
export type ImagePreviewControlKey = 'download' | 'previous' | 'next' | 'flipX' | 'flipY' | 'rotateLeft' | 'rotateRight';
export interface ImagePreviewControlDescriptor extends ControlDescriptor {
  key: ImagePreviewControlKey;
}
export declare function createImagePreviewSources(sources?: string[], transformHardenUrl?: (url: string) => string | null): string[];
export declare function resolveImageControlPosition(controls: unknown): ZoomControlPosition;
export declare function createImagePreviewTransformState(state?: Partial<ImagePreviewTransformState>): ImagePreviewTransformState;
export declare function flipImagePreviewHorizontal(state: ImagePreviewTransformState): ImagePreviewTransformState;
export declare function flipImagePreviewVertical(state: ImagePreviewTransformState): ImagePreviewTransformState;
export declare function rotateImagePreviewLeft(state: ImagePreviewTransformState): ImagePreviewTransformState;
export declare function rotateImagePreviewRight(state: ImagePreviewTransformState): ImagePreviewTransformState;
export declare function resetImagePreviewTransformState(): ImagePreviewTransformState;
export declare function createImagePreviewTransformStyle(state?: Partial<ImagePreviewTransformState>, elementStyle?: UIStyleValue): UIStyleValue;
export declare function createImagePreviewControlDescriptors(options: Pick<ImagePreviewModelOptions, 'controls' | 'hasDownload' | 'icons'> & {
  imageCount?: number;
  imageSrc?: string;
}): ImagePreviewControlDescriptor[];
export declare function createImagePreviewModel(options: ImagePreviewModelOptions): {
  sources: string[];
  controlPosition: ZoomControlPosition;
  canOpen: boolean;
  transformState: ImagePreviewTransformState;
  imageStyle: UIStyleValue;
  controls: ImagePreviewControlDescriptor[];
};
//#endregion
//#region src/core/link.d.ts
export declare function resolveLinkFaviconUrl(url: string, favicon?: LinkOptions['favicon']): Promise<string | undefined> | string | undefined;
//#endregion
//#region src/core/math.d.ts
export interface MathRenderNode {
  value: string;
  display: boolean;
  loading?: boolean;
}
export interface MathRendererModelOptions {
  node: MathRenderNode;
  installed: boolean;
  renderFlag?: boolean;
  renderingCode?: string;
  errorMessage?: string;
}
export interface MathRendererState {
  html: string;
  errorMessage: string;
  renderFlag: boolean;
  renderingCode: string;
}
export interface MathRendererResult {
  html?: string;
  error?: string;
}
export declare function createMathRendererModel(options: MathRendererModelOptions): {
  code: string;
  loading: boolean;
  isDisplayMode: boolean;
  error: boolean;
};
export declare function createMathRendererState(state?: Partial<MathRendererState>): MathRendererState;
export declare function applyMathRendererResult(state: MathRendererState, code: string, result: MathRendererResult): MathRendererState;
//#endregion
//#region src/core/mermaid.d.ts
export interface MermaidRenderState {
  renderFlag: boolean;
  renderAttempt: boolean;
}
export interface MermaidPreviewControllerState extends MermaidRenderState {
  svg?: string;
  error?: string;
  measuredHeight: number;
}
export interface MermaidRenderResult {
  valid: boolean;
  svg?: string;
  error?: string;
}
export interface MermaidPreviewModelOptions {
  code: string;
  nodeLoading?: boolean;
  svg?: string;
  renderFlag?: boolean;
  minHeight?: number;
  containerHeight?: number | string;
  measuredHeight?: number;
  controls?: unknown;
}
export declare function createMermaidPreviewModel(options: MermaidPreviewModelOptions): {
  code: string;
  loading: boolean;
  showControl: boolean;
  controlPosition: ZoomControlPosition;
  minHeight: number;
  height: string;
};
export declare function resolveMermaidInlineInteractive(controls: unknown): boolean;
export declare function resolveMermaidControlPosition(controls: unknown): ZoomControlPosition;
export declare function resolveMermaidContainerHeight(containerHeight?: number | string, measuredHeight?: number): string;
export declare function createMermaidRenderState(state?: Partial<MermaidRenderState>): MermaidRenderState;
export declare function createMermaidPreviewControllerState(state?: Partial<MermaidPreviewControllerState>): MermaidPreviewControllerState;
export declare function startMermaidRenderAttempt(state: MermaidPreviewControllerState): MermaidPreviewControllerState;
export declare function startMermaidRenderAttempt(state: MermaidRenderState): MermaidRenderState;
export declare function applyMermaidRenderResult(state: MermaidPreviewControllerState, result: MermaidRenderResult): MermaidPreviewControllerState;
export declare function setMermaidMeasuredHeight(state: MermaidPreviewControllerState, measuredHeight: number): MermaidPreviewControllerState;
export declare function shouldEagerRenderMermaidAfterLoading(state: MermaidRenderState, currentLoading: boolean, previousLoading: boolean | undefined): boolean;
//#endregion
//#region src/core/root.d.ts
export type StreamMarkdownMode = 'static' | 'streaming';
export declare function resolveEnableAnimate(mode: StreamMarkdownMode, enableAnimate?: boolean): boolean;
export declare function resolveEnableCaret(mode: StreamMarkdownMode, caret?: string): boolean;
export declare function resolveAnimation(animation?: AnimationType): AnimationType;
export declare function resolveAnimationSplit(animationSplit?: AnimationSplit): AnimationSplit;
export declare function resolveAnimationStagger(animationStagger?: number): number;
export declare function resolveCaret(caret?: string): string | undefined;
export declare function createRootStyle(cssVariables: Record<string, string>, animationDuration?: number | string): Record<string, string>;
//#endregion
//#region src/core/table.d.ts
export interface TableContent {
  content: string;
  mimeType: string;
  extension: string;
}
export interface TableControlState {
  fullscreen: boolean;
}
export interface TableControlActionOptions {
  key: string;
  select?: SelectOption;
  filename?: string;
  state: TableControlState;
  getContent: (format: TableFormat) => TableContent | null;
  beforeDownload?: (event: DownloadEvent) => MaybePromise<boolean>;
  copyContent?: (content: string) => MaybePromise<void>;
  onCopied?: (content: string) => void;
  saveFile?: (filename: string, content: string | Blob, mimeType: string) => MaybePromise<void>;
}
export interface TableControlDescriptorOptions {
  copied: boolean;
  fullscreen: boolean;
  showCopy: boolean;
  showDownload: boolean;
  showFullscreen: boolean;
  options?: SelectOption[];
}
export declare const TABLE_FORMAT_OPTIONS: SelectOption[];
export declare function getTableContent(format: TableFormat, tableData: TableData, csvSeparator?: CSVSeparator): TableContent;
export declare function createTableControlDescriptors(options: TableControlDescriptorOptions): ControlDescriptor[];
export declare function handleTableControlAction(options: TableControlActionOptions): Promise<TableControlState>;
//#endregion
//#region src/core/ui.d.ts
export interface ErrorModelOptions {
  variant?: UIErrorVariant;
  message?: string;
  icon?: unknown;
  hasIcon?: (name: string) => boolean;
}
export declare function createErrorModel(options?: ErrorModelOptions): {
  variant: UIErrorVariant;
  icon: {};
  messageKey: string;
  message: string | undefined;
  isHarden: boolean;
};
export declare function createIconModel(options: {
  width?: number;
  height?: number;
}): {
  width: number;
  height: number;
  style: {
    width: string;
    height: string;
  };
};
export declare function createSegmentedModel<TStyle = Record<string, unknown>>(options: {
  options?: SelectOption[];
  value?: string;
  buttonStyle?: TStyle;
}): {
  value: string;
  items: SelectOption[];
  isActive(item: SelectOption): boolean;
  getButtonStyle(item: SelectOption): {
    paddingBlock: string;
    backgroundColor: string | undefined;
  };
};
export declare function createPreviewSegmentedOptions(t: (key: string) => string): SelectOption[];
export declare function createZoomContainerModel(options: {
  zoom: number;
  position: Parameters<typeof resolveZoomControlPosition>[0];
  controlSize?: 'vanilla' | 'large';
}): {
  zoomPercent: string;
  controlsPosition: ZoomControlPositionStyle;
  controlButtonProps: {
    iconWidth?: undefined;
    iconHeight?: undefined;
    buttonStyle?: undefined;
  } | {
    iconWidth: number;
    iconHeight: number;
    buttonStyle: {
      fontSize: string;
    };
  };
  controls: ControlDescriptor<UIStyleValue>[];
};
export declare function createZoomControlDescriptors(zoom: number, controlSize?: 'vanilla' | 'large'): ControlDescriptor[];
export declare function createZoomControlButtonProps(controlSize?: 'vanilla' | 'large'): {
  iconWidth?: undefined;
  iconHeight?: undefined;
  buttonStyle?: undefined;
} | {
  iconWidth: number;
  iconHeight: number;
  buttonStyle: {
    fontSize: string;
  };
};
//#endregion