//#region src/blocks.d.ts
interface SpacingValue {
  top: number;
  right: number;
  bottom: number;
  left: number;
}
interface BlockStyles {
  padding: SpacingValue;
  backgroundColor?: string;
}
interface BlockVisibility {
  desktop: boolean;
  mobile: boolean;
}
interface BaseBlock {
  id: string;
  type: string;
  styles: BlockStyles;
  visibility?: BlockVisibility;
  displayCondition?: {
    label: string;
    before: string;
    after: string;
    group?: string;
    description?: string;
  };
}
type ColumnLayout = "1" | "2" | "3" | "2-1" | "1-2";
/**
 * Optional outer frame for a section. When present, the section is rendered
 * inside an `mj-wrapper` — a full-width band (its own background + padding)
 * that frames the section, e.g. a white card sitting on a colored band.
 */
interface SectionWrapper {
  backgroundColor?: string;
  padding?: SpacingValue;
  /** Corner radius in px for the outer frame. Omitted/0 = square corners. */
  borderRadius?: number;
}
interface SectionBlock extends BaseBlock {
  type: "section";
  columns: ColumnLayout;
  children: Block[][];
  /**
   * Whether columns stack vertically on mobile. Absent or `true` keeps MJML's
   * default responsive behavior (columns stack below 480px). `false` renders
   * the columns inside an `<mj-group>` so they stay side-by-side on mobile,
   * proportionally shrunk to fit.
   */
  stackOnMobile?: boolean;
  /** Corner radius in px. Omitted/0 = square corners. */
  borderRadius?: number;
  /** Optional outer frame (rendered as an `mj-wrapper` around the section). */
  wrapper?: SectionWrapper;
}
type HeadingLevel = 1 | 2 | 3 | 4;
declare const HEADING_LEVEL_FONT_SIZE: Record<HeadingLevel, number>;
interface TitleBlock extends BaseBlock {
  type: "title";
  content: string;
  level: HeadingLevel;
  /** Text color. Unset = inherit the document-level `textColor`. */
  color?: string;
  textAlign: "left" | "center" | "right";
  fontFamily?: string;
}
interface ParagraphBlock extends BaseBlock {
  type: "paragraph";
  content: string;
}
interface ImageBlock extends BaseBlock {
  type: "image";
  src: string;
  alt: string;
  width: number | "full";
  /**
   * Height in pixels. Absent means the height is derived from the width, so the
   * image keeps its aspect ratio — setting both stretches it, since email
   * clients don't support `object-fit`.
   */
  height?: number;
  align: "left" | "center" | "right";
  linkUrl?: string;
  linkOpenInNewTab?: boolean;
  placeholderUrl?: string;
  decorative?: boolean;
}
interface ButtonBlock extends BaseBlock {
  type: "button";
  text: string;
  url: string;
  openInNewTab?: boolean;
  backgroundColor: string;
  textColor: string;
  borderRadius: number;
  fontSize: number;
  buttonPadding: SpacingValue;
  fontFamily?: string;
  width?: number | "full";
  /**
   * Placement of the button within its column. No visible effect when `width`
   * is `"full"`, since the button then spans the column.
   */
  align: "left" | "center" | "right";
}
interface DividerBlock extends BaseBlock {
  type: "divider";
  lineStyle: "solid" | "dashed" | "dotted";
  color: string;
  thickness: number;
  width: number | "full";
}
interface VideoBlock extends BaseBlock {
  type: "video";
  url: string;
  openInNewTab?: boolean;
  thumbnailUrl: string;
  alt: string;
  width: number | "full";
  /**
   * Height in pixels for the thumbnail. Absent means the height is derived from
   * the width, so the thumbnail keeps its aspect ratio — setting both stretches
   * it, since email clients don't support `object-fit`.
   */
  height?: number;
  align: "left" | "center" | "right";
  placeholderUrl?: string;
}
type SocialPlatform = "facebook" | "twitter" | "instagram" | "linkedin" | "youtube" | "tiktok" | "pinterest" | "email" | "whatsapp" | "telegram" | "discord" | "snapchat" | "reddit" | "github" | "dribbble" | "behance" | "website";
type SocialIconStyle = "solid" | "outlined" | "rounded" | "square" | "circle";
type SocialIconSize = "small" | "medium" | "large";
interface SocialIcon {
  id: string;
  platform: SocialPlatform;
  url: string;
}
interface SocialIconsBlock extends BaseBlock {
  type: "social";
  icons: SocialIcon[];
  iconStyle: SocialIconStyle;
  iconSize: SocialIconSize;
  spacing: number;
  align: "left" | "center" | "right";
}
interface SpacerBlock extends BaseBlock {
  type: "spacer";
  height: number;
}
interface HtmlBlock extends BaseBlock {
  type: "html";
  content: string;
}
interface MenuItemData {
  id: string;
  text: string;
  url: string;
  openInNewTab: boolean;
  bold: boolean;
  underline: boolean;
  color?: string;
}
interface MenuBlock extends BaseBlock {
  type: "menu";
  items: MenuItemData[];
  fontSize: number;
  fontFamily?: string;
  /** Base text/link color. Unset = inherit the document-level `textColor`. */
  color?: string;
  linkColor?: string;
  textAlign: "left" | "center" | "right";
  separator: string;
  separatorColor: string;
  spacing: number;
}
interface TableCellData {
  id: string;
  content: string;
}
interface TableRowData {
  id: string;
  cells: TableCellData[];
}
interface TableBlock extends BaseBlock {
  type: "table";
  rows: TableRowData[];
  hasHeaderRow: boolean;
  headerBackgroundColor?: string;
  borderColor: string;
  borderWidth: number;
  cellPadding: number;
  fontSize: number;
  fontFamily?: string;
  /** Text color. Unset = inherit the document-level `textColor`. */
  color?: string;
  textAlign: "left" | "center" | "right";
}
interface CountdownBlock extends BaseBlock {
  type: "countdown";
  targetDate: string;
  timezone: string;
  showDays: boolean;
  showHours: boolean;
  showMinutes: boolean;
  showSeconds: boolean;
  separator: ":" | "-" | " ";
  digitFontSize: number;
  digitColor: string;
  labelColor: string;
  labelFontSize: number;
  backgroundColor: string;
  fontFamily?: string;
  labelDays: string;
  labelHours: string;
  labelMinutes: string;
  labelSeconds: string;
  expiredMessage: string;
  expiredImageUrl: string;
  hideOnExpiry: boolean;
}
interface CustomBlock extends BaseBlock {
  type: "custom";
  customType: string;
  fieldValues: Record<string, unknown>;
  renderedHtml?: string;
  dataSourceFetched?: boolean;
}
type Block = SectionBlock | TitleBlock | ParagraphBlock | ImageBlock | ButtonBlock | DividerBlock | VideoBlock | SocialIconsBlock | SpacerBlock | HtmlBlock | MenuBlock | TableBlock | CountdownBlock | CustomBlock;
type BlockType = Block["type"];
//#endregion
//#region src/social.d.ts
/**
 * SVG glyph (24×24 path) + brand color for each social platform.
 *
 * Single source of truth shared by two consumers that render icons in
 * different formats: the editor draws them as inline SVG (`SocialIconSvg.vue`)
 * and `@templatical/renderer` rasterizes them to PNGs
 * (`scripts/rasterize-social.mjs`) because Outlook's Word engine has no SVG
 * support. Typing as `Record<SocialPlatform, ...>` makes adding a platform to
 * the union a compile error until its glyph is supplied here, keeping both
 * consumers in lockstep.
 */
interface SocialIconGlyph {
  /** SVG path data on a 24×24 viewBox. */
  path: string;
  /** Brand color as a 6-digit hex string. */
  color: string;
}
declare const SOCIAL_ICON_GLYPHS: Record<SocialPlatform, SocialIconGlyph>;
//#endregion
//#region src/saved-blocks.d.ts
/**
 * A reusable, user-authored group of blocks — saved from the canvas and
 * re-insertable into any template.
 *
 * Distinct from a *custom block* (`CustomBlockDefinition`), which is a
 * developer-defined block **type** with its own template and field schema.
 * A saved block is an instance-level snapshot of ordinary blocks.
 */
interface SavedBlock {
  /**
   * Store-assigned identifier. Returned by {@link SavedBlocksProvider.create}
   * — the editor never generates it, so the store stays the authority on
   * identity (database primary key, storage slug, etc.).
   */
  id: string;
  name: string;
  /**
   * Top-level blocks captured in this saved block. A `section` carries its own
   * `children`, so a whole section-with-columns round-trips as one entry.
   *
   * Blocks are re-identified on insert (via `cloneBlock`), so the IDs stored
   * here never collide with the blocks already on a canvas.
   */
  content: Block[];
  /**
   * Optional free-text grouping, surfaced in the browser as a filter.
   *
   * Flat and free-text by design — there is no category registry and no
   * nesting. The editor derives the set of available categories from the
   * entries it has loaded, so a category exists exactly as long as something
   * carries it; an entry without one is simply uncategorised.
   */
  category?: string;
  /**
   * Per-entry permission carve-outs. **Absent means allowed** — the provider's
   * `update` / `delete` already say whether the capability exists at all, so
   * these exist only to forbid it on *particular* entries (a shared block a
   * viewer may insert but not edit, someone else's block, a locked entry).
   *
   * Return them from your API alongside the row, where the answer is already
   * known — the editor never second-guesses them and never computes its own.
   * When one is `false` the corresponding control is not rendered for that
   * entry.
   */
  canUpdate?: boolean;
  canDelete?: boolean;
  /**
   * Store-assigned timestamps, used for display only: the browser shows a
   * relative "5m ago" label per entry (preferring `updatedAt`, falling back to
   * `createdAt`) with the absolute date on hover.
   *
   * They do **not** affect ordering — the editor renders whatever order
   * `list()` returns and never re-sorts. Both are optional; omit them and the
   * label is simply not shown.
   */
  createdAt?: string;
  updatedAt?: string;
}
/**
 * Parameters for {@link SavedBlocksProvider.list}. An object (rather than
 * positional arguments) so future filters can be added without breaking
 * existing provider implementations.
 *
 * **These are only sent by headless callers.** The editor's own browser calls
 * `list()` with no parameters and filters the loaded entries in memory — that
 * way a provider stays a dumb store and still gets a working search box and
 * category filter. They arrive only when you drive `useSavedBlocks`
 * yourself (see the guide's "Headless use"), so implement them if you want
 * server-side filtering for your own UI and ignore them otherwise.
 */
interface SavedBlocksListParams {
  /** Free-text filter over the saved block's `name`. */
  search?: string;
  /** Exact-match filter over {@link SavedBlock.category}. */
  category?: string;
}
/** Payload for {@link SavedBlocksProvider.create}. */
interface SavedBlockInput {
  name: string;
  content: Block[];
  category?: string;
}
/**
 * Partial patch for {@link SavedBlocksProvider.update}. Only the keys present
 * are being changed — `category: ""` clears the category, whereas omitting the
 * key leaves it alone.
 */
type SavedBlockPatch = Partial<{
  name: string;
  content: Block[];
  category: string;
}>;
/**
 * Storage contract for saved blocks. Implement it to back the editor's saved
 * blocks UI with your own persistence — the editor owns the save dialog, the
 * browser, and insertion; you own the transport.
 *
 * Pass an implementation as `savedBlocks` to `init()`. When omitted, the
 * feature stays off entirely and none of its UI renders.
 *
 * Every method may reject; the editor surfaces the failure through the
 * editor's `onError` callback and leaves its in-memory list untouched.
 *
 * **Each mutation can be turned off by passing `false` instead of a function.**
 * The editor then hides the affordance rather than letting the user try and
 * fail. They are required rather than optional precisely so that disabling is a
 * decision you state, never something you get by forgetting a method. Setting
 * all three yields a **read-only library**: users still browse, preview and
 * insert, because insertion only touches the canvas and never your store.
 *
 * ```ts
 * const provider: SavedBlocksProvider = {
 *   list: ({ search } = {}) =>
 *     fetch(`/api/saved-blocks?search=${search ?? ""}`).then((r) => r.json()),
 *   create: (input) =>
 *     fetch("/api/saved-blocks", {
 *       method: "POST",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify(input),
 *     }).then((r) => r.json()),
 *   update: (id, patch) =>
 *     fetch(`/api/saved-blocks/${id}`, {
 *       method: "PUT",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify(patch),
 *     }).then((r) => r.json()),
 *   delete: (id) =>
 *     fetch(`/api/saved-blocks/${id}`, { method: "DELETE" }).then(() => undefined),
 * };
 * ```
 */
interface SavedBlocksProvider {
  /**
   * Fetch saved blocks. The editor calls this with no arguments and expects
   * everything the current user may see — scoping the result per user, tenant
   * or permission is yours to do here. {@link SavedBlocksListParams} is only
   * populated by headless callers; honouring it is optional.
   *
   * The one method that cannot be disabled: without it the feature has nothing
   * to show.
   */
  list(params?: SavedBlocksListParams): Promise<SavedBlock[]>;
  /**
   * Persist a new saved block and return it with its store-assigned `id`, or
   * `false` to disable saving entirely — the block chrome's bookmark action
   * disappears and no pick session can be started.
   */
  create: false | ((input: SavedBlockInput) => Promise<SavedBlock>);
  /**
   * Apply a partial update and return the stored result, or `false` to disable
   * editing entirely. Renaming is `update(id, { name })` and recategorising is
   * `update(id, { category })` — there are no separate methods for either.
   *
   * To allow editing in general but forbid it on particular entries, keep the
   * function and set {@link SavedBlock.canUpdate} to `false` on those.
   */
  update: false | ((id: string, patch: SavedBlockPatch) => Promise<SavedBlock>);
  /**
   * Remove a saved block, resolving once the store has applied the delete, or
   * `false` to disable deletion entirely. Per-entry exceptions go through
   * {@link SavedBlock.canDelete}.
   */
  delete: false | ((id: string) => Promise<void>);
}
//#endregion
//#region src/defaults.d.ts
type BlockDefaultsFor<T> = Partial<Omit<T, "id" | "type">>;
interface BlockDefaults {
  title?: BlockDefaultsFor<TitleBlock>;
  paragraph?: BlockDefaultsFor<ParagraphBlock>;
  image?: BlockDefaultsFor<ImageBlock>;
  button?: BlockDefaultsFor<ButtonBlock>;
  divider?: BlockDefaultsFor<DividerBlock>;
  section?: BlockDefaultsFor<SectionBlock>;
  video?: BlockDefaultsFor<VideoBlock>;
  social?: BlockDefaultsFor<SocialIconsBlock>;
  spacer?: BlockDefaultsFor<SpacerBlock>;
  html?: BlockDefaultsFor<HtmlBlock>;
  menu?: BlockDefaultsFor<MenuBlock>;
  table?: BlockDefaultsFor<TableBlock>;
  countdown?: BlockDefaultsFor<CountdownBlock>;
}
type TemplateDefaults = Partial<TemplateSettings>;
declare const TITLE_BLOCK_DEFAULTS: BlockDefaultsFor<TitleBlock>;
declare const PARAGRAPH_BLOCK_DEFAULTS: BlockDefaultsFor<ParagraphBlock>;
declare const IMAGE_BLOCK_DEFAULTS: BlockDefaultsFor<ImageBlock>;
declare const BUTTON_BLOCK_DEFAULTS: BlockDefaultsFor<ButtonBlock>;
declare const DIVIDER_BLOCK_DEFAULTS: BlockDefaultsFor<DividerBlock>;
declare const SECTION_BLOCK_DEFAULTS: BlockDefaultsFor<SectionBlock>;
declare const VIDEO_BLOCK_DEFAULTS: BlockDefaultsFor<VideoBlock>;
declare const SOCIAL_ICONS_BLOCK_DEFAULTS: BlockDefaultsFor<SocialIconsBlock>;
declare const SPACER_BLOCK_DEFAULTS: BlockDefaultsFor<SpacerBlock>;
declare const HTML_BLOCK_DEFAULTS: BlockDefaultsFor<HtmlBlock>;
declare const MENU_BLOCK_DEFAULTS: BlockDefaultsFor<MenuBlock>;
declare const TABLE_BLOCK_DEFAULTS: BlockDefaultsFor<TableBlock>;
declare const COUNTDOWN_BLOCK_DEFAULTS: BlockDefaultsFor<CountdownBlock>;
declare const DEFAULT_BLOCK_DEFAULTS: Required<BlockDefaults>;
declare const DEFAULT_TEMPLATE_DEFAULTS: TemplateDefaults;
declare function deepMergeDefaults<T extends object>(base: T, overrides: Partial<T>): T;
//#endregion
//#region src/template.d.ts
interface TemplateSettings {
  width: number;
  backgroundColor: string;
  /**
   * Document-level default text color: the `<mj-text>` default in the rendered
   * MJML, inherited by every text block (Title, Paragraph, Menu, Table) that
   * doesn't set its own `color`. Required, defaulting to `#1a1a1a` (see
   * `DEFAULT_TEMPLATE_DEFAULTS`); customize the default per-consumer via
   * `templateDefaults`. A block's explicit `color` or an inline text-color
   * mark overrides it.
   */
  textColor: string;
  /**
   * Document-level link color: emitted as the global `a { color }` rule in the
   * rendered MJML, so it cascades to every link — rich-text and menu alike.
   * Optional: when unset, links inherit the surrounding text color
   * (`color: inherit`), preserving the pre-#352 default. A per-block or
   * per-item color (a Menu item's `color`, `MenuBlock.linkColor`) still
   * overrides it.
   */
  linkColor?: string;
  /**
   * Whether links are underlined document-wide: drives the global
   * `a { text-decoration }` rule (`underline` when true, `none` when false).
   * Required, defaulting to `true` (see `DEFAULT_TEMPLATE_DEFAULTS`) — the
   * common, more accessible email default. Applies to body (rich-text) links;
   * buttons and menu items carry their own inline `text-decoration` and are
   * unaffected. Set `false` to render links without an underline.
   */
  linkUnderline: boolean;
  fontFamily: string;
  preheaderText?: string;
  /**
   * BCP-47 language code for the rendered email's `<html lang>`. Drives
   * screen-reader pronunciation. Default `'en'` via `DEFAULT_TEMPLATE_DEFAULTS`.
   */
  locale: string;
}
interface TemplateContent {
  blocks: Block[];
  settings: TemplateSettings;
}
declare function createDefaultTemplateContent(defaultFontFamily?: string, templateDefaults?: TemplateDefaults): TemplateContent;
//#endregion
//#region src/test-email.d.ts
/**
 * What a {@link TestEmailProvider} receives when the user asks to send a test.
 */
interface TestEmailPayload {
  recipient: string;
  /**
   * The editor's current content, exactly as `getContent()` would return it.
   * Always present.
   */
  content: TemplateContent;
  /**
   * The template rendered to MJML.
   *
   * Present only when {@link TestEmailProvider.includeMjml} is set **and**
   * `@templatical/renderer` resolved. Always guard for absence: opting in
   * without the renderer installed still sends, just without this field (the
   * editor logs one warning naming the package).
   *
   * You still have to compile MJML to HTML — the editor never does, and
   * deliberately doesn't bundle a compiler.
   */
  mjml?: string;
  /**
   * Echo of {@link TestEmailProvider.allowedRecipients}, present only when one
   * was configured.
   *
   * **Untrusted.** It is read out of the browser and carries no signature, so it
   * is not authoritative about anything. Two things it is genuinely useful for:
   * keeping one `send` implementation portable between your own backend and
   * Templatical Cloud, and comparing it against `recipient` server-side — a
   * mismatch means the client was tampered with or is buggy, which is worth
   * logging. Never treat it *as* the allowlist; that list belongs on your
   * server.
   */
  allowedRecipients?: string[];
}
/**
 * Sending contract for test emails. Implement it to let users send a test of the
 * template they're editing through your own infrastructure — the editor owns the
 * trigger, the dialog, recipient validation and the sending/success/error
 * states; you own delivery.
 *
 * Pass an implementation as `testEmail` to `init()`. When omitted the feature
 * stays off entirely and no trigger renders.
 *
 * ```ts
 * const provider: TestEmailProvider = {
 *   send: ({ recipient, content }) =>
 *     fetch("/api/test-email", {
 *       method: "POST",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify({ recipient, content }),
 *     }).then((r) => {
 *       if (!r.ok) throw new Error("Could not send the test email");
 *     }),
 * };
 * ```
 */
interface TestEmailProvider {
  /**
   * Deliver a test of the current template.
   *
   * Resolve on success — the dialog confirms, then closes. Reject with a
   * **user-presentable** message on failure: the dialog renders `error.message`
   * inline and stays open so the user can retry.
   */
  send(payload: TestEmailPayload): Promise<void>;
  /**
   * Also render the template to MJML and pass it as
   * {@link TestEmailPayload.mjml}, saving you a `renderToMjml()` call.
   *
   * **Requires `@templatical/renderer`**, an optional peer dependency. If it
   * isn't installed the send still happens with JSON only and one warning is
   * logged — opting in never breaks sending. A *rendering* failure is different:
   * that fails the send, because it means the template itself is broken and
   * silently sending without the MJML would hide it.
   */
  includeMjml?: boolean;
  /**
   * Restrict who may be sent to:
   *
   * - **omitted** — the dialog accepts free text, validated for shape only;
   * - **one entry** — a read-only field, pre-filled with it;
   * - **several** — a picker of exactly those addresses;
   * - **empty array** — nobody may be sent to, so the feature reports itself
   *   unavailable and no trigger renders. `[]` is read as a decision, not as
   *   "unset".
   *
   * A picker constraint, **not a security boundary**: this array lives in the
   * user's browser and is trivially edited there. Validate the recipient on your
   * server regardless of what the dialog offered.
   */
  allowedRecipients?: string[];
  /**
   * Pre-fills the recipient field. Ignored when it isn't in
   * {@link allowedRecipients}.
   */
  defaultRecipient?: string;
}
//#endregion
//#region src/templates.d.ts
/**
 * A stored template: its identity, an optional human-readable name, and the
 * content the editor edits.
 *
 * The store owns `id` — it is returned by {@link TemplatesProvider.create} and
 * never generated by the editor, so identity stays a property of your storage
 * (database primary key, slug, document id).
 */
interface Template {
  id: string;
  /**
   * Optional display name, shown in the editor header and editable inline.
   *
   * Optional because a store may not have a name column, in which case the
   * header renders nothing to edit. A rename is persisted as an ordinary
   * `save(id, { name })` patch — there is no separate rename method.
   */
  name?: string;
  /**
   * When your store created the template, ISO 8601.
   *
   * A fallback for {@link Template.updatedAt}: the header prefers `updatedAt`
   * and reads this only in its absence, so a store that records creation but not
   * modification still shows something.
   */
  createdAt?: string;
  /**
   * When your store last wrote the template, ISO 8601.
   *
   * Display-only — the header renders it as a relative label ("Updated 5m ago")
   * with the absolute date on hover. Both timestamps are absent from
   * {@link TemplatePatch}, so the editor never writes them: they are yours to
   * set, and the value the editor shows is whatever `load` or `save` returned.
   * Absent, or a value that does not parse, renders nothing.
   */
  updatedAt?: string;
  content: TemplateContent;
}
/**
 * Partial patch for {@link TemplatesProvider.save}. Only the keys present are
 * being changed, so a rename can travel without content and vice versa.
 *
 * A patch (rather than bare content) because retrofitting `save(id, content)`
 * into `save(id, patch)` later would break every implementation — the same
 * reasoning, and the same shape, as `SavedBlockPatch`.
 */
type TemplatePatch = Partial<{
  name: string;
  content: TemplateContent;
}>;
/**
 * Storage contract for the template itself — the save/load lifecycle around
 * whatever the editor is editing.
 *
 * Deliberately **not** CRUD: there is no `list` and no `delete`, and the editor
 * has no template browser. Choosing *which* template to open belongs to your
 * own application, which then hands the id to `editor.load(id)`.
 *
 * Pass an implementation as `templates` to `init()`. When omitted, the header's
 * name field, save button and save-status indicator do not render, and
 * `create()` / `load()` / `save()` reject with an explanatory error.
 *
 * Every method may reject; the editor reports the failure through `onError`,
 * surfaces it in the header, and leaves its state untouched — nothing is marked
 * saved that wasn't.
 *
 * **Each mutation can be turned off by passing `false` instead of a function**,
 * mirroring `SavedBlocksProvider`. They are required rather than optional
 * precisely so that disabling is a decision you state, never something you get
 * by forgetting a method. `save: false` yields a genuine read-only mode (a
 * template still loads and can be edited locally, there is simply nothing to
 * persist); `create: false` yields a no-new-templates mode.
 *
 * ```ts
 * const provider: TemplatesProvider = {
 *   load: (id) => fetch(`/api/templates/${id}`).then((r) => r.json()),
 *   create: (input) =>
 *     fetch("/api/templates", {
 *       method: "POST",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify(input),
 *     }).then((r) => r.json()),
 *   save: (id, patch) =>
 *     fetch(`/api/templates/${id}`, {
 *       method: "PATCH",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify(patch),
 *     }).then((r) => r.json()),
 * };
 * ```
 */
interface TemplatesProvider {
  /**
   * Fetch a template by id. The one method that cannot be disabled: without it
   * there is nothing to open.
   */
  load(id: string): Promise<Template>;
  /**
   * Persist a new template and return it with its store-assigned `id`, or
   * `false` to disable creation entirely.
   */
  create: false | ((input: {
    name?: string;
    content: TemplateContent;
  }) => Promise<Template>);
  /**
   * Apply a partial update to an existing template and return the stored
   * result, or `false` to disable saving entirely — the editor then hides both
   * the save button and the save-status indicator.
   */
  save: false | ((id: string, patch: TemplatePatch) => Promise<Template>);
}
//#endregion
//#region src/merge-tags.d.ts
interface SyntaxPreset {
  value: RegExp;
  logic: RegExp;
}
type SyntaxPresetName = "liquid" | "handlebars" | "mailchimp" | "ampscript";
declare const SYNTAX_PRESETS: Record<SyntaxPresetName, SyntaxPreset>;
/**
 * Resolves the autocomplete trigger string for a syntax preset.
 * Returns null when the syntax doesn't match any built-in preset
 * (custom regex syntax — autocomplete cannot be enabled safely).
 */
declare function getSyntaxTriggerChar(syntax: SyntaxPreset): string | null;
/**
 * Resolves the closing delimiter for a syntax preset (e.g. `}}` for liquid,
 * `|*` for mailchimp). The autocomplete trigger detector uses it to tell an
 * open tag (`{{first`) from a completed one (`{{first_name}}`) so the popup
 * doesn't reappear over a finished tag. Returns null for custom syntaxes —
 * the same set for which `getSyntaxTriggerChar` returns null.
 */
declare function getSyntaxClosingChar(syntax: SyntaxPreset): string | null;
declare function resolveSyntax(syntax?: SyntaxPresetName | SyntaxPreset): SyntaxPreset;
declare function isMergeTagValue(value: string, syntax: SyntaxPreset): boolean;
declare function getMergeTagLabel(value: string, mergeTags: MergeTag[]): string;
declare function resolveHtmlMergeTagLabels(html: string, mergeTags: MergeTag[]): string;
/**
 * The example value configured for `value`, or `undefined` when the tag is
 * unknown or declares none. Unlike `getMergeTagLabel`, which falls back to the
 * raw token, absence is reported as `undefined` so callers can choose their own
 * fallback — Sample mode falls back to the label, never to a raw token.
 */
declare function getMergeTagSample(value: string, mergeTags: MergeTag[]): string | undefined;
/**
 * Rewrite rich-text HTML for the previews' Sample mode.
 *
 * A tag **with** a sample is replaced by that value as bare text, wrapper and
 * all — dropping the `<span>` is what removes the merge-tag highlight, so the
 * value reads as ordinary content. A tag **without** one keeps its span and
 * shows its label, so it stays visibly dynamic; that difference is deliberate,
 * and it doubles as a signal that a sample is still unset.
 *
 * The unwrapped output is inert — `data-merge-tag` is gone from it — so this
 * result must only ever reach a preview surface, never `getContent()`, an
 * export or a send.
 */
declare function substituteHtmlMergeTagSamples(html: string, mergeTags: MergeTag[]): string;
/**
 * Whether any configured tag declares a `sample`.
 *
 * Gates the whole feature: with no samples anywhere the previews' Sample view
 * would be identical to the Label view, so the editor defaults to Label and
 * renders no toggle. That keeps the feature invisible until a consumer opts in.
 */
declare function hasMergeTagSamples(mergeTags: MergeTag[]): boolean;
/**
 * Replace declared tokens with their sample values in a plain string — used for
 * values that reach no label-resolving component, namely `html` block content
 * and custom-block field values.
 *
 * Matching is on the exact configured `value`, so consumer text cannot
 * false-positive and `href="{{link}}"` resolves correctly. Tags without a
 * sample are left untouched, which is what keeps a missing sample visible.
 */
declare function substituteTextMergeTagSamples(text: string, mergeTags: MergeTag[]): string;
declare function containsMergeTag(value: string, syntax: SyntaxPreset): boolean;
declare function isLogicMergeTagValue(value: string, syntax: SyntaxPreset): boolean;
declare function getLogicMergeTagKeyword(value: string, syntax: SyntaxPreset): string;
declare function resolveHtmlLogicMergeTagLabels(html: string, syntax: SyntaxPreset): string;
//#endregion
//#region src/config.d.ts
type ViewportSize = "desktop" | "mobile";
type UiTheme = "light" | "dark" | "auto";
interface CustomFont {
  name: string;
  url: string;
  fallback?: string;
}
interface FontsConfig {
  defaultFallback?: string;
  defaultFont?: string;
  customFonts?: CustomFont[];
  /**
   * Restrict which of the seven built-in fonts the font picker offers.
   *
   * - `true` / omitted — every built-in is offered (the default).
   * - `false` — no built-ins; the picker lists only `customFonts`. Use this to
   *   keep authors on an embedded brand kit's typefaces.
   * - `string[]` — an allowlist of built-in names to keep, matched
   *   case-insensitively (`['Georgia', 'arial']`). A name that isn't a built-in
   *   is logged with a warning and skipped — consistent with how
   *   `paletteBlocks` treats an unknown entry — so a typo narrows the list
   *   rather than silently offering all seven.
   *
   * Independent of `customFonts`: excluding the built-ins never removes a custom
   * font, and a custom font can still be the `defaultFont` when every built-in
   * is excluded. Filtering the picker never affects rendering — content already
   * using an excluded built-in still resolves to its proper fallback stack.
   */
  builtIns?: boolean | string[];
}
interface ColorsConfig {
  /**
   * Preset colors rendered as a clickable grid inside every color picker
   * popover. Each entry is a hex string (`'#0b5cff'`); clicking one applies it,
   * and the preset matching the current value is marked selected (matched
   * case-insensitively). The grid supplements the wheel and hex input unless
   * `allowCustom` is `false`.
   */
  presets?: string[];
  /**
   * Allow free-form color entry — the wheel and hex input — alongside the
   * presets. Defaults to `true`.
   *
   * Set to `false` together with `presets` to lock authors to the preset
   * palette: the popover then offers only the preset grid, with no wheel or hex
   * field (a white-label / brand-kit constraint). Ignored with a warning when
   * no `presets` are configured — hiding the only inputs would leave the picker
   * with no way to choose a color.
   */
  allowCustom?: boolean;
}
interface ExportResult {
  html: string;
  mjml: string;
}
interface MergeTag {
  label: string;
  value: string;
  /**
   * Optional grouping label used by the built-in merge tag picker to
   * section the list. When no tag in the configured array carries
   * `group`, the picker renders a plain flat list with no headers.
   * Ignored by the renderer and by typing-autocomplete.
   */
  group?: string;
  /**
   * Optional helper text shown beneath the tag in the built-in merge
   * tag picker. Not rendered anywhere else (toolbar, autocomplete,
   * MJML output) and not stored on the inserted document node.
   */
  description?: string;
  /**
   * Example value shown in place of this tag on preview surfaces — e.g.
   * `"Ada"` for `{{first_name}}` — so a preview reads like a delivered
   * email instead of a list of field names.
   *
   * Display-only, and only in the previews' Sample mode: never written to
   * the template, never sent, never present in MJML output. Setting it is
   * the whole opt-in; there is no accompanying flag. A tag without a
   * sample keeps showing its `label`.
   */
  sample?: string;
}
interface MediaResult {
  url: string;
  alt?: string;
}
interface MergeTagsConfig {
  syntax?: SyntaxPresetName | SyntaxPreset;
  tags?: MergeTag[];
  onRequest?: () => Promise<MergeTag | null>;
  /**
   * Enables typing-based autocomplete in rich text blocks and in every
   * merge-tag-enabled input/textarea field (toolbars, template settings,
   * custom-block text fields). When the user types the syntax opener
   * (e.g. `{{`), a popup lists matching `tags`. Both surfaces share the
   * same popup, so behavior is identical.
   *
   * Defaults to `true`. Effective only when `tags` is non-empty AND
   * `syntax` matches a built-in preset (custom regex syntaxes cannot be
   * mapped to a trigger string and silently disable autocomplete).
   */
  autocomplete?: boolean;
}
/**
 * A standalone logic tag — a control-flow token (e.g. `{% else %}`) inserted
 * at the cursor. Distinct from data merge tags; rendered as a keyword badge.
 */
interface LogicTag {
  label: string;
  value: string;
  /** Optional grouping label used to section the logic picker. */
  group?: string;
  /** Optional helper text shown beneath the tag in the picker. */
  description?: string;
}
/**
 * A paired logic construct — an opening tag (`before`) and its matching closer
 * (`after`), e.g. `{% if vip %}` … `{% endif %}`. Selecting one inserts both
 * pills at once, wrapping the selection (or with the caret placed between
 * them). Shares its `before`/`after` shape with `DisplayCondition`.
 */
interface LogicPair {
  label: string;
  /** Opening logic tag, including delimiters (e.g. `{% if vip %}`). */
  before: string;
  /** Closing logic tag, including delimiters (e.g. `{% endif %}`). */
  after: string;
  /** Optional grouping label used to section the logic picker. */
  group?: string;
  /** Optional helper text shown beneath the pair in the picker. */
  description?: string;
}
/**
 * Standalone logic-tag configuration, independent of `mergeTags`. `tags` are
 * single control-flow tokens inserted at the cursor; `pairs` are open/close
 * constructs inserted around the selection. Both appear in the built-in logic
 * picker, grouped together by `group`. Typed/pasted logic highlighting is
 * always on regardless of this.
 */
interface LogicTagsConfig {
  tags?: LogicTag[];
  pairs?: LogicPair[];
  /**
   * Consumer-owned picker. When set, the "Insert logic" affordance calls this
   * instead of the built-in logic picker — return the chosen tag/pair (or
   * `null` to cancel). Mirrors `MergeTagsConfig.onRequest`; lets consumers use
   * their own UI and custom syntax. Precedence: `onRequest` → built-in picker.
   */
  onRequest?: () => Promise<LogicTag | LogicPair | null>;
}
interface DisplayCondition {
  label: string;
  before: string;
  after: string;
  group?: string;
  description?: string;
}
interface DisplayConditionsConfig {
  conditions: DisplayCondition[];
  allowCustom?: boolean;
}
interface ThemeOverrides {
  bg?: string;
  bgElevated?: string;
  bgHover?: string;
  bgActive?: string;
  border?: string;
  borderLight?: string;
  text?: string;
  textMuted?: string;
  textDim?: string;
  primary?: string;
  primaryHover?: string;
  primaryLight?: string;
  secondary?: string;
  secondaryHover?: string;
  secondaryLight?: string;
  success?: string;
  successLight?: string;
  warning?: string;
  warningLight?: string;
  danger?: string;
  dangerLight?: string;
  canvasBg?: string;
  dark?: Omit<ThemeOverrides, "dark">;
}
declare class SdkError extends Error {
  readonly statusCode?: number | undefined;
  constructor(message: string, statusCode?: number | undefined);
  get isNotFound(): boolean;
  get isUnauthorized(): boolean;
  get isServerError(): boolean;
}
//#endregion
//#region src/render.d.ts
/**
 * Everything a {@link RenderProvider} needs to render a template, handed over as
 * one object so the editor's obligations are stated rather than implied.
 *
 * The editor guarantees the payload is **render-complete**: whatever a backend
 * cannot know by itself has already been resolved into it.
 */
interface RenderPayload {
  /**
   * The template to render, with every custom block's `renderedHtml` already
   * filled in.
   *
   * This is the part a server genuinely cannot do: a custom block's HTML comes
   * from the consumer's liquid template plus the block's field values, and the
   * template registration lives in the browser. A renderer that receives a
   * custom block with neither a resolver nor `renderedHtml` omits it silently,
   * so pre-rendering is a contract obligation, not an optimisation.
   *
   * A defensive copy — mutating it does not touch what the user is editing.
   */
  content: TemplateContent;
  /**
   * The fonts the editor is actually rendering with: the custom faces it
   * resolved, plus the fallback stack to use for anything unmatched.
   *
   * Optional on the type so a headless caller can omit it; the editor always
   * sends it, because a font list assembled from `init({ fonts })` is not
   * something a backend can reconstruct from `content` alone.
   */
  fonts?: {
    customFonts: CustomFont[];
    defaultFallback: string;
  };
}
/**
 * Rendering backend — how a template becomes MJML, and how MJML becomes the HTML
 * that gets sent.
 *
 * Deliberately separate from `TemplatesProvider`: saving and rendering run
 * at different frequencies (autosave would compile MJML on every debounce tick),
 * fail in different ways, and are wanted by different callers. Rendering is never
 * a field on a save result.
 *
 * Pass an implementation as `render` to `init()` or `initCloud()`. **Every method
 * is independently optional**, and each one the editor resolves on its own:
 *
 * | Call | Order |
 * |---|---|
 * | `editor.toMjml()` | {@link toMjml} → the local `@templatical/renderer` → throw |
 * | `editor.toHtml()` | {@link toHtml} → `toMjml()`'s result + {@link compileMjml} → throw |
 *
 * **There is no local HTML path, ever.** The SDK does not bundle an MJML
 * compiler, so `toHtml()` without either `toHtml` or `compileMjml` rejects with
 * an explanatory error rather than guessing.
 *
 * ```ts
 * // The cheapest useful implementation: one dumb mjml2html endpoint, and the
 * // editor gains `toHtml()` while still rendering MJML locally.
 * const editor = await init({
 *   container,
 *   render: {
 *     compileMjml: (mjml) =>
 *       fetch("/api/mjml", { method: "POST", body: mjml }).then((r) => r.text()),
 *   },
 * });
 *
 * const html = await editor.toHtml();
 * ```
 */
interface RenderProvider {
  /**
   * Render the template to MJML source. Wins over the bundled renderer — a
   * backend can render block types or refinements the browser cannot (a
   * server-generated countdown GIF, a composited video thumbnail), so its output
   * is treated as authoritative.
   */
  toMjml?(payload: RenderPayload): Promise<string>;
  /**
   * Render the template straight to sending-ready HTML, skipping the MJML round
   * trip. Implement this when your backend already owns the whole pipeline.
   */
  toHtml?(payload: RenderPayload): Promise<string>;
  /**
   * Compile MJML to HTML. A dumb `mjml2html` endpoint — it needs no knowledge of
   * the block model, which is exactly the point: MJML compilation is a commodity
   * (an off-the-shelf service, a container, a CLI shell-out), whereas rendering
   * Templatical JSON is not.
   *
   * This is the cheap tier, and the reason the interface has three methods
   * instead of two: without it, every non-Node backend that wants HTML would have
   * to stand up a Node sidecar first.
   */
  compileMjml?(mjml: string): Promise<string>;
}
//#endregion
//#region src/version-history.d.ts
/**
 * One recorded version of a template.
 *
 * Called a *version* rather than a snapshot deliberately: "snapshot" is an
 * implementation word, and it collides with the editor's undo/redo history,
 * which is a different thing entirely (in-session, unsaved, per-keystroke).
 */
interface TemplateVersion {
  /** Store-assigned. The editor never generates one. */
  id: string;
  /** ISO 8601. Drives the relative-time label in the history dropdown. */
  createdAt: string;
  /**
   * Recorded by a save rather than by a person. Drives the "auto" badge, and is
   * where a future filter would key off.
   */
  isAutomatic?: boolean;
  /** Short human label, when your store lets someone name a version. */
  label?: string;
  author?: {
    id?: string;
    name?: string;
  };
  /**
   * Optional eager content — a **cache hint**, never an alternative to
   * {@link VersionHistoryProvider.get}.
   *
   * When present the editor previews this version instantly and never calls
   * `get` for it. Evaluated **per entry**, so a provider may hydrate the recent
   * versions and omit the older ones.
   *
   * This exists because scrubbing through history is synchronous: once the
   * preview is open, stepping to another version swaps the canvas in the same
   * tick. A provider that eager-loads keeps that; one that omits `content` pays
   * a single round-trip the first time each version is visited, and the editor
   * caches it thereafter.
   */
  content?: TemplateContent;
}
/**
 * Page request for {@link VersionHistoryProvider.list}.
 *
 * The editor always calls `list` bare — it loads one page and renders it. Both
 * fields exist for headless callers and for providers that page their own
 * storage; a provider free to return everything at once may ignore them.
 */
interface VersionHistoryListParams {
  /** Maximum entries to return. A provider may return fewer, never more. */
  limit?: number;
  /**
   * Opaque cursor taken from a previous result's
   * {@link VersionHistoryListResult.nextCursor}.
   */
  cursor?: string;
}
/**
 * What {@link VersionHistoryProvider.list} resolves to.
 *
 * An envelope rather than a bare array **so that adding pagination never breaks
 * an implementation**: a cursor has somewhere to live from day one. Reserving
 * only the params object would have solved the request side and left the
 * response side needing a breaking change.
 */
interface VersionHistoryListResult {
  /**
   * The versions to offer, newest first. The editor renders this order verbatim
   * and never re-sorts — ordering is your store's call.
   */
  versions: TemplateVersion[];
  /**
   * Cursor for the next page, or absent when this is the last one. Opaque to
   * the editor: pass it back as {@link VersionHistoryListParams.cursor}.
   * A provider that returns its whole history at once omits it.
   */
  nextCursor?: string;
}
/**
 * Storage contract for a template's version history.
 *
 * Pass an implementation as `versionHistory` to `init()` or `initCloud()`. With
 * no provider the history control does not render and none of its UI is
 * downloaded.
 *
 * **The editor never creates versions on its own.** Whoever implements
 * `TemplatesProvider.save` decides whether a save also records a version, which
 * keeps throttling, retention and dedupe policy on the side that pays for the
 * storage. {@link create} is for versions a *person* asks for.
 *
 * ```ts
 * const provider: VersionHistoryProvider = {
 *   list: (templateId) =>
 *     fetch(`/api/templates/${templateId}/versions`).then((r) => r.json()),
 *   get: (templateId, versionId) =>
 *     fetch(`/api/templates/${templateId}/versions/${versionId}`)
 *       .then((r) => r.json())
 *       .then((v) => v.content),
 *   create: false,
 *   // No atomic restore endpoint? Compose it: read the old content, save it.
 *   restore: async (templateId, versionId) => {
 *     const content = await provider.get(templateId, versionId);
 *     return templates.save(templateId, { content });
 *   },
 * };
 * ```
 */
interface VersionHistoryProvider {
  /** One page of versions. See {@link VersionHistoryListResult}. */
  list(templateId: string, params?: VersionHistoryListParams): Promise<VersionHistoryListResult>;
  /**
   * Fetch one version's content. **The operation, and always required** — the
   * editor must always be able to obtain a version's content.
   * {@link TemplateVersion.content} is the optimisation, and optimisations don't
   * get to be mandatory.
   */
  get(templateId: string, versionId: string): Promise<TemplateContent>;
  /**
   * Record the current content as a version on demand, or `false` to disable
   * it — the editor then offers no way to create one by hand, and the history
   * is whatever `save` recorded.
   *
   * `false`-able and required rather than optional, mirroring
   * `SavedBlocksProvider` and `TemplatesProvider`: disabling is a decision you
   * state, never something you get by forgetting a method.
   */
  create: false | ((templateId: string, content: TemplateContent, meta?: {
    label?: string;
  }) => Promise<TemplateVersion>);
  /**
   * Make a past version current and return the resulting template, or `false`
   * to make history read-only — versions can then be browsed and previewed, but
   * the Restore action does not render.
   *
   * **History is append-only:** a restore adds an entry rather than rewriting
   * one, so undo stays coherent and two backends can't disagree about what
   * history looks like afterwards. A store with no atomic endpoint composes it
   * in one line — `get` the old content, then `save` it — accepting two
   * round-trips and a narrower failure window.
   */
  restore: false | ((templateId: string, versionId: string) => Promise<Template>);
}
//#endregion
//#region src/comments.d.ts
/**
 * Who wrote a comment, or resolved one.
 *
 * The same shape as {@link EditorUser}, and deliberately so — a comment's author
 * is whoever was editing. It is a separate name only because a store returns
 * authors it did not get from this session.
 */
interface CommentAuthor {
  id: string;
  name: string;
}
/**
 * One comment — a thread root, or a reply to one.
 *
 * Threads are **one level deep**: a root carries {@link replies}, and a reply
 * never does. That is what the editor renders, and flattening a deeper tree is
 * your store's problem rather than the editor's.
 */
interface Comment {
  /** Store-assigned. The editor never generates one. */
  id: string;
  body: string;
  author: CommentAuthor;
  /** ISO 8601. */
  createdAt: string;
  /**
   * ISO 8601, present only when the body has been edited since. Drives the
   * "(edited)" marker, so a store that stamps it on creation makes every comment
   * look edited.
   */
  updatedAt?: string;
  /**
   * The block this comment is anchored to, or `null` for a comment about the
   * template as a whole.
   */
  blockId?: string | null;
  /** The thread root this is a reply to, or `null` for a root. */
  parentId?: string | null;
  /** ISO 8601 when resolved; `null` or absent while the thread is open. */
  resolvedAt?: string | null;
  /** Who resolved it. Absent when unresolved, or when your store doesn't track it. */
  resolvedBy?: CommentAuthor | null;
  /** Replies to this root, oldest first. Absent or empty on a reply. */
  replies?: Comment[];
}
/** What {@link CommentsProvider.create} is asked to store. */
interface CommentInput {
  body: string;
  /** Omitted for a template-level comment. */
  blockId?: string;
  /** Omitted for a thread root. */
  parentId?: string;
}
/**
 * Partial patch for {@link CommentsProvider.update}. A patch rather than a bare
 * body, matching `TemplatePatch` and `SavedBlockPatch` — retrofitting one later
 * would break every implementation, and only the shape is being paid for now.
 */
type CommentPatch = Partial<{
  body: string;
}>;
/**
 * Reserved filter object for {@link CommentsProvider.list}.
 *
 * Empty today. The editor always calls `list` bare and narrows in memory
 * (unresolved / all / this block), so the provider decides *what is visible*
 * and the editor decides how it is filtered within that.
 *
 * **Not a pagination hook, and comments deliberately has none.** `useComments`
 * derives `unresolvedCount` (the header badge) and `commentCountByBlock` (the
 * per-block canvas indicators) over the *whole* loaded list. A partial page
 * would make both under-report silently — wrong rather than slow. Correct
 * paging would mean moving counts and filtering server-side, which is a
 * redesign, not a `loadMore()`. A long-lived template caps its own growth by
 * having `list()` stop returning resolved threads past some age; the panel
 * hides those by default anyway. Contrast {@link VersionHistoryListParams},
 * which does page: its list is a flat menu with nothing aggregating over it.
 */
interface CommentsListParams {}
/**
 * One remote change, as reported by {@link CommentsProvider.subscribe}.
 *
 * A discriminated union rather than a `{ type, comment }` pair, because a delete
 * has no comment to carry — only the id, plus the parent so the editor knows
 * which list to remove it from without looking it up first.
 */
type CommentChange = {
  type: "created";
  comment: Comment;
} | {
  type: "updated";
  comment: Comment;
} | {
  type: "deleted";
  commentId: string;
  parentId?: string | null;
};
type CommentEventType = "created" | "updated" | "deleted" | "resolved" | "unresolved";
/**
 * What `onComment` receives — every change the editor applied, local or remote.
 *
 * Distinct from {@link CommentChange}: that is what a *transport* reports inward,
 * this is what the editor reports outward, and it separates `resolved` /
 * `unresolved` from a plain `updated` because a consumer notifying a team cares
 * about the difference.
 */
interface CommentEvent {
  type: CommentEventType;
  comment: Comment;
}
/**
 * Storage contract for **comments** — the review conversation on a template.
 *
 * Pass an implementation as `comments` to `init()`. With no provider the panel,
 * its trigger and the per-block indicators do not render and none of that UI is
 * downloaded.
 *
 * Comments also need to know **who is commenting**, which is not part of this
 * contract: it is the top-level `user` config key, because collaboration presence
 * will want the same answer and a provider-local copy would be the first thing to
 * drift. With no `user` the feature reports itself unavailable — an
 * unattributable comment is worse than no comment feature.
 *
 * **Each mutation can be turned off by passing `false` instead of a function**,
 * mirroring `SavedBlocksProvider`, `TemplatesProvider` and
 * `VersionHistoryProvider`. They are required rather than optional precisely so
 * that disabling is a decision you state, never something you get by forgetting a
 * method. All four `false` yields a read-only review: existing threads are
 * browsable and jump-to-block still works, with no way to add, edit, delete or
 * resolve.
 *
 * ```ts
 * const provider: CommentsProvider = {
 *   list: (templateId) =>
 *     fetch(`/api/templates/${templateId}/comments`).then((r) => r.json()),
 *   create: (templateId, input) =>
 *     fetch(`/api/templates/${templateId}/comments`, {
 *       method: "POST",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify(input),
 *     }).then((r) => r.json()),
 *   update: (templateId, commentId, patch) =>
 *     fetch(`/api/templates/${templateId}/comments/${commentId}`, {
 *       method: "PATCH",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify(patch),
 *     }).then((r) => r.json()),
 *   delete: async (templateId, commentId) => {
 *     await fetch(`/api/templates/${templateId}/comments/${commentId}`, {
 *       method: "DELETE",
 *     });
 *   },
 *   setResolved: (templateId, commentId, resolved) =>
 *     fetch(`/api/templates/${templateId}/comments/${commentId}/resolve`, {
 *       method: "POST",
 *       headers: { "Content-Type": "application/json" },
 *       body: JSON.stringify({ resolved }),
 *     }).then((r) => r.json()),
 * };
 * ```
 */
interface CommentsProvider {
  /**
   * The thread roots to show, each with its `replies`. The editor renders this
   * order verbatim and never re-sorts — ordering is your store's call.
   *
   * The one method that cannot be disabled: without it there is nothing to show.
   */
  list(templateId: string, params?: CommentsListParams): Promise<Comment[]>;
  /**
   * Store a new comment or reply and return it with its store-assigned `id`, or
   * `false` to make the review read-only.
   */
  create: false | ((templateId: string, input: CommentInput) => Promise<Comment>);
  /**
   * Apply a partial update and return the stored result, or `false` to disable
   * editing — the pencil action then does not render on any comment.
   */
  update: false | ((templateId: string, commentId: string, patch: CommentPatch) => Promise<Comment>);
  /**
   * Remove a comment (and, for a root, its replies), or `false` to disable
   * deletion. Resolves to nothing: there is no post-delete state to report.
   */
  delete: false | ((templateId: string, commentId: string) => Promise<void>);
  /**
   * Mark a thread resolved or reopened and return the stored result, or `false`
   * to disable it.
   *
   * Takes the **target state** rather than toggling, so the call is idempotent
   * and a store that receives two clicks in flight cannot end up inverted.
   */
  setResolved: false | ((templateId: string, commentId: string, resolved: boolean) => Promise<Comment>);
  /**
   * **Optional.** Push remote changes into the open panel, so a colleague's
   * comment appears without a reload.
   *
   * Realtime is separable from comments rather than a prerequisite for them:
   * without this the feature works exactly as it does with it, you just don't see
   * someone else's comment until the list is next read. Returns an unsubscribe
   * function; the editor calls it when the template changes and on teardown.
   *
   * ```ts
   * subscribe: (templateId, onChange) => {
   *   const source = new EventSource(`/api/templates/${templateId}/comments/stream`);
   *   source.onmessage = (e) => onChange(JSON.parse(e.data) as CommentChange);
   *   return () => source.close();
   * }
   * ```
   *
   * Your own writes may echo back through here. That is fine and needs no
   * de-duplication on your side: a `created` for a comment already in the list is
   * ignored, and an `updated` replaces it in place.
   */
  subscribe?: (templateId: string, onChange: (change: CommentChange) => void) => () => void;
}
//#endregion
//#region src/user.d.ts
/**
 * Who is using the editor right now — `init({ user })`.
 *
 * A **top-level config key, not part of any provider.** Comments are the first
 * feature to need it (the panel decides which comments may be edited or deleted
 * by comparing `id` against each author, and a new comment is attributed to
 * `name`), but collaboration presence will want exactly the same answer. Putting
 * it on the comments provider would guarantee a second, drifting copy the moment
 * the second feature landed.
 *
 * Features that need an identity **report themselves unavailable without one**
 * rather than falling back to an anonymous author. An unattributable comment is
 * worse than no comment feature — the same reasoning that makes an explicitly
 * empty `TestEmailProvider.allowedRecipients` disable the feature instead of
 * degrading to free text.
 *
 * Not a security boundary: this identifies the user to the editor's UI, in the
 * user's own browser. Whatever your provider writes must be attributed
 * server-side, from the session your backend already trusts.
 */
interface EditorUser {
  /**
   * Stable identifier, compared against `Comment.author.id`. Whatever your
   * backend calls a user — a primary key, a UUID, an email.
   */
  id: string;
  /** Display name, shown on the comments this session writes. */
  name: string;
}
//#endregion
//#region src/guards.d.ts
declare function isSection(block: Block): block is SectionBlock;
declare function isTitle(block: Block): block is TitleBlock;
declare function isParagraph(block: Block): block is ParagraphBlock;
declare function isImage(block: Block): block is ImageBlock;
declare function isButton(block: Block): block is ButtonBlock;
declare function isDivider(block: Block): block is DividerBlock;
declare function isVideo(block: Block): block is VideoBlock;
declare function isSocialIcons(block: Block): block is SocialIconsBlock;
declare function isSpacer(block: Block): block is SpacerBlock;
declare function isHtml(block: Block): block is HtmlBlock;
declare function isMenu(block: Block): block is MenuBlock;
declare function isTable(block: Block): block is TableBlock;
declare function isCountdown(block: Block): block is CountdownBlock;
declare function isCustomBlock(block: Block): block is CustomBlock;
//#endregion
//#region src/custom-blocks.d.ts
type CustomBlockFieldType = "text" | "textarea" | "image" | "color" | "number" | "select" | "boolean" | "repeatable";
interface CustomBlockFieldBase {
  key: string;
  label: string;
  required?: boolean;
  placeholder?: string;
  readOnly?: boolean;
}
interface CustomBlockTextField extends CustomBlockFieldBase {
  type: "text";
  default?: string;
}
interface CustomBlockTextareaField extends CustomBlockFieldBase {
  type: "textarea";
  default?: string;
}
interface CustomBlockImageField extends CustomBlockFieldBase {
  type: "image";
  default?: string;
}
/**
 * A color-picker field. Beyond the shared field props it accepts the same flat
 * `presets` / `allowCustom` pair as the editor-wide `colors` config (their
 * shapes are derived from `ColorsConfig`, so the two can't drift), scoping this
 * one field to a color *role* — e.g. a button-color field offering only the
 * brand's accent/ink pair while other color fields inherit the global palette.
 *
 * **Narrowing only — of the author's freedom, not the palette.** A field can
 * restrict what authors may do (lock this field, or give it its own `presets`),
 * but never unlock what the editor locked. Its `presets` *replace* the
 * editor-wide grid rather than intersecting it, so a locked field may offer
 * colors outside `colors.presets`:
 *
 * - `presets` — entries are validated exactly like editor-level presets
 *   (`#rgb` / `#rrggbb` hex; invalid ones are skipped with a console warning
 *   naming the block and field). A non-empty valid list replaces the editor's
 *   palette for this field; leaving it unset, passing `[]`, or passing only
 *   invalid entries all inherit the editor's palette.
 * - `allowCustom` — `false` locks this field to its palette even while the rest
 *   of the editor allows free-form entry. `true` cannot unlock a field when the
 *   editor-wide `colors.allowCustom` is `false`; it is ignored with a warning.
 *
 * @see https://docs.templatical.com/guide/custom-blocks
 */
interface CustomBlockColorField extends CustomBlockFieldBase, Pick<ColorsConfig, "presets" | "allowCustom"> {
  type: "color";
  default?: string;
}
interface CustomBlockNumberField extends CustomBlockFieldBase {
  type: "number";
  default?: number;
  min?: number;
  max?: number;
  step?: number;
}
interface SelectOption {
  label: string;
  value: string;
}
interface CustomBlockSelectField extends CustomBlockFieldBase {
  type: "select";
  options: SelectOption[];
  default?: string;
}
interface CustomBlockBooleanField extends CustomBlockFieldBase {
  type: "boolean";
  default?: boolean;
}
interface CustomBlockRepeatableField extends CustomBlockFieldBase {
  type: "repeatable";
  fields: Exclude<CustomBlockField, CustomBlockRepeatableField>[];
  default?: Record<string, unknown>[];
  minItems?: number;
  maxItems?: number;
}
type CustomBlockField = CustomBlockTextField | CustomBlockTextareaField | CustomBlockImageField | CustomBlockColorField | CustomBlockNumberField | CustomBlockSelectField | CustomBlockBooleanField | CustomBlockRepeatableField;
interface CustomBlockDefinition {
  type: string;
  name: string;
  icon?: string;
  description?: string;
  fields: CustomBlockField[];
  template: string;
  dataSource?: DataSourceConfig;
  /**
   * Default block styles applied when a new instance of this custom block is
   * created. Deep-merged over the built-in defaults — only specify the fields
   * you want to override. Controls both the editor canvas wrapper and the
   * rendered MJML/email output.
   *
   * @example
   * defaultStyles: {
   *   padding: { top: 0, right: 0, bottom: 0, left: 0 },
   * }
   */
  defaultStyles?: Partial<BlockStyles>;
  /**
   * Optional CSS rules attached to this custom block definition. Emitted once
   * (deduped across instances) into `<mj-head><mj-style>…</mj-style></mj-head>`
   * in the rendered MJML, and adopted into the editor canvas (shadow root or
   * light-DOM mount) so authored responsive/hover/font behavior previews
   * inside the editor.
   *
   * Use this for media queries, hover states, or any CSS that should apply
   * once per definition rather than per block instance. Class names are not
   * scoped by the SDK — namespace them yourself (e.g. `.tplc-<type>-<el>`) to
   * avoid collisions with other definitions or built-in editor styles.
   *
   * @example
   * stylesheet: `
   *   @media (max-width: 480px) {
   *     .tplc-image-text-cell { display: block !important; width: 100% !important; }
   *   }
   * `
   */
  stylesheet?: string;
}
interface DataSourceFetchContext {
  fieldValues: Record<string, unknown>;
  blockId: string;
}
interface DataSourceConfig {
  label: string;
  onFetch: (context: DataSourceFetchContext) => Promise<Record<string, unknown> | null>;
}
//#endregion
//#region src/factory.d.ts
declare function generateId(): string;
declare function createTitleBlock(partial?: Partial<TitleBlock>): TitleBlock;
declare function createParagraphBlock(partial?: Partial<ParagraphBlock>): ParagraphBlock;
declare function createImageBlock(partial?: Partial<ImageBlock>): ImageBlock;
declare function createButtonBlock(partial?: Partial<ButtonBlock>): ButtonBlock;
declare function createDividerBlock(partial?: Partial<DividerBlock>): DividerBlock;
declare function createSectionBlock(partial?: Partial<SectionBlock>): SectionBlock;
declare function createVideoBlock(partial?: Partial<VideoBlock>): VideoBlock;
declare function createSocialIconsBlock(partial?: Partial<SocialIconsBlock>): SocialIconsBlock;
declare function createSpacerBlock(partial?: Partial<SpacerBlock>): SpacerBlock;
declare function createHtmlBlock(partial?: Partial<HtmlBlock>): HtmlBlock;
declare function createMenuBlock(partial?: Partial<MenuBlock>): MenuBlock;
declare function createTableBlock(partial?: Partial<TableBlock>): TableBlock;
declare function createCountdownBlock(partial?: Partial<CountdownBlock>): CountdownBlock;
declare function createCustomBlock(definition: CustomBlockDefinition): CustomBlock;
declare function createBlock(type: BlockType, blockDefaults?: BlockDefaults): Block;
declare function cloneBlock(block: Block): Block;
//#endregion
//#region src/events.d.ts
declare class EventEmitter<TEvents extends Record<string, unknown> = Record<string, unknown>> {
  private handlers;
  on<K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void): () => void;
  off<K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void): void;
  emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
  removeAllListeners(event?: keyof TEvents): void;
  listenerCount(event: keyof TEvents): number;
}
//#endregion
//#region src/clone.d.ts
/**
 * Cycle-safe deep clone via a JSON round-trip.
 *
 * A naked `JSON.stringify` throws `Converting circular structure to JSON`
 * if the tree is self-referencing — e.g. a DOM element carrying a Sortable
 * expando back-ref (`HTMLDivElement.SortableXXX -> instance -> el -> div`)
 * leaks into block data through a drag handler inside a section. Both the
 * editor's public `getContent()` export path and the history snapshot path
 * must tolerate that: we drop the offending back-ref from the clone rather
 * than throw. Losing a transient DOM expando is harmless; the block data is
 * intact.
 *
 * The `WeakSet` replacer omits any object already seen on the current path,
 * which covers every cyclic shape. Template content is tree-shaped (and is
 * serialized to JSON for storage anyway), so dropping repeated references
 * never costs real data.
 */
declare function safeClone<T>(value: T): T;
//#endregion
//#region src/html-scan.d.ts
/**
 * Minimal, allocation-free primitives for reading an HTML open tag out of a
 * markup string. They exist because merge-tag markup is rewritten from a raw
 * string in two packages — `@templatical/types` (label / sample resolution for
 * the previews) and `@templatical/renderer` (converting spans back to tokens on
 * export) — and both need the same two answers: where does this open tag end,
 * and what is the value of one of its attributes.
 *
 * Both are hand-written character scans rather than regexes. A regex over an
 * attribute string with no closing quote backtracks across the whole input,
 * which is the ReDoS class the span scanners were rewritten to avoid; a scan
 * that only moves forward cannot.
 */
/**
 * Index of the `>` that closes the open tag whose name ends at `from`, or `-1`
 * when the tag never closes.
 *
 * Quote-aware: a `>` inside a quoted attribute value does not end the tag.
 * That matters because a consumer may configure a merge-tag syntax whose tag
 * values contain `<` / `>` — Smarty-style `<% $email %>` — and HTML attribute
 * serialization escapes only `&`, `"` and U+00A0, so those characters reach the
 * markup literally. A plain `indexOf(">")` stops mid-attribute there and every
 * caller downstream sees a truncated attribute string.
 *
 * An unterminated quote yields `-1` rather than a guessed tag end: callers
 * treat that as "not markup I can rewrite" and emit the input untouched, which
 * is the safe answer for malformed HTML.
 */
declare function findOpenTagEnd(html: string, from: number): number;
/**
 * The value of the `name` attribute within an open tag's attribute string (the
 * text between the tag name and its closing `>`), or `null` when the attribute
 * is absent or its quoted value is never closed.
 *
 * Handles double-quoted, single-quoted and unquoted values, and matches the
 * attribute name case-insensitively, as HTML does. The value is
 * entity-decoded, because that is what the attribute means: the editor
 * serializes a tag value of `<% $email %>` as
 * `data-merge-tag="&lt;% $email %&gt;"`, and every caller compares the result
 * against a configured merge-tag token written in raw characters.
 */
declare function getTagAttrValue(attrs: string, name: string): string | null;
//#endregion
//#region src/preview-resolution.d.ts
/**
 * Context handed to `resolvePreview`.
 *
 * `recipient` is present only on surfaces that have one — the test-email
 * dialog — and absent in the editor's own preview mode. Treat its absence as
 * "no particular recipient", not as an error: a resolver should still return
 * something renderable, typically its own default or sample data.
 */
interface PreviewResolveContext {
  /**
   * The template as it currently stands. Already a copy — mutating it has no
   * effect on the editor, and returning it unchanged is a valid no-op.
   */
  content: TemplateContent;
  /** The address the preview is being shown for, when the surface has one. */
  recipient?: string;
}
/**
 * Resolves a template for display on preview surfaces — typically substituting
 * merge tags and **evaluating logic tags** against real data.
 *
 * Logic tags are the reason this hook exists. `MergeTag.sample` already covers
 * value tags client-side, but branching (`{% if %}` … `{% endif %}`) cannot be
 * evaluated in a browser for every supported syntax — mailchimp and ampscript
 * logic are server-side dialects — so only the consumer's own backend can do it.
 *
 * Display-only. The returned content reaches preview surfaces and nothing else:
 * it is never written to the editor's state, never returned from
 * `getContent()`, never sent, and never exported. Rejecting is safe — the
 * preview falls back to the unresolved template and says so.
 */
type ResolvePreview = (context: PreviewResolveContext) => Promise<TemplateContent>;
/**
 * Whether `value` is shaped enough like `TemplateContent` to render.
 *
 * A resolver is consumer code returning data that often came from an HTTP
 * response, so the declared return type guarantees nothing at runtime. A
 * mis-shaped result is treated as a resolution failure — the preview degrades
 * to the unresolved template — rather than throwing inside the render.
 */
declare function isRenderableTemplateContent(value: unknown): value is TemplateContent;
//#endregion
//#region ../media-library/src/types.d.ts
interface StorageInfo {
  used_bytes: number;
  limit_bytes: number;
}
interface MediaCategoryData {
  mime_types: string[];
  extensions: string[];
}
interface MediaConfig {
  use_media_library: boolean;
  categories: Record<string, MediaCategoryData>;
  max_file_size: number;
}
//#endregion
//#region src/cloud.d.ts
/**
 * Cloud's wire shape for one version — snake_case, i.e. what the API returns,
 * not a contract shape. `createCloudVersionHistoryProvider` maps it to the
 * camelCase `TemplateVersion` a consumer's provider also returns.
 */
interface TemplateVersionResponse {
  id: string;
  template_id: string;
  content: TemplateContent;
  is_autosave: boolean;
  created_at: string;
}
/**
 * Cloud's wire shape for one comment — snake_case, i.e. what the API returns,
 * not a contract shape. `createCloudCommentsProvider` maps it to the camelCase
 * `Comment` a consumer's provider also returns.
 *
 * Same split as `TemplateVersionResponse` → `TemplateVersion`, and for the same
 * reason: a wire format is one backend's business, and putting it in the contract
 * would make every BYO implementer speak Cloud's dialect.
 */
interface CommentResponse {
  id: string;
  template_id: string;
  block_id: string | null;
  parent_id: string | null;
  body: string;
  author_identifier: string;
  author_name: string;
  resolved_at: string | null;
  resolved_by_identifier: string | null;
  resolved_by_name: string | null;
  created_at: string;
  updated_at: string;
  replies: CommentResponse[];
}
type FindingSeverity = "high" | "medium" | "low";
type ScoringCategory = "spam" | "readability" | "accessibility" | "bestPractices";
interface ScoringFinding {
  id: string;
  severity: FindingSeverity;
  message: string;
  blockId: string | null;
  category: ScoringCategory;
  suggestion: string;
}
interface CategoryScore {
  score: number;
  findings: ScoringFinding[];
}
interface ScoringResult {
  score: number;
  categories: Record<ScoringCategory, CategoryScore>;
}
interface HealthCheckResult {
  api: {
    ok: boolean;
    latency: number;
  };
  websocket: {
    ok: boolean;
    error?: string;
  };
  auth: {
    ok: boolean;
    error?: string;
  };
  overall: boolean;
}
interface TokenData {
  token: string;
  expires_at: number;
  project_id: string;
  tenant: string;
  test_email?: {
    allowed_emails: string[];
    signature: string;
  };
  user?: {
    id: string;
    name: string;
    signature: string;
  };
}
interface AuthRequestOptions {
  method?: "GET" | "POST";
  headers?: Record<string, string>;
  body?: Record<string, unknown>;
  credentials?: RequestCredentials;
}
interface AuthConfig {
  url: string;
  baseUrl?: string;
  requestOptions?: AuthRequestOptions;
  onError?: (error: Error) => void;
}
interface TestEmailConfig {
  allowedEmails: string[];
  signature: string;
}
interface UserConfig {
  id: string;
  name: string;
  signature: string;
}
interface DirectAuthConfig {
  mode: "direct";
  clientId: string;
  clientSecret: string;
  tenant: string;
  baseUrl?: string;
}
interface ProxyAuthConfig {
  mode: "proxy";
  url: string;
  baseUrl?: string;
  requestOptions?: AuthRequestOptions;
}
type SdkAuthConfig = DirectAuthConfig | ProxyAuthConfig;
interface Collaborator {
  id: string;
  name: string;
  color: string;
  selectedBlockId: string | null;
}
type McpOperation = "add_block" | "update_block" | "delete_block" | "move_block" | "update_settings" | "set_content" | "update_block_style";
interface McpOperationPayload {
  operation: McpOperation;
  data: Record<string, unknown>;
  timestamp: number;
}
interface AiConfig {
  chat?: boolean;
  scoring?: boolean;
  designToTemplate?: boolean;
  rewrite?: boolean;
}
interface McpConfig {
  enabled: boolean;
  onOperation?: (payload: McpOperationPayload) => void;
}
interface CollaborationConfig {
  enabled: boolean;
  onCollaboratorJoined?: (collaborator: Collaborator) => void;
  onCollaboratorLeft?: (collaborator: Collaborator) => void;
  onBlockLocked?: (event: {
    blockId: string;
    collaborator: Collaborator;
  }) => void;
  onBlockUnlocked?: (event: {
    blockId: string;
    collaborator: Collaborator;
  }) => void;
}
interface WebSocketServerConfig {
  host: string;
  port: number;
  app_key: string;
}
interface ApiResponse<T> {
  data: T;
}
interface ApiError {
  message: string;
  errors?: Record<string, string[]>;
}
/**
 * Cloud's entitlement flags — the one thing in the SDK that is deliberately
 * **not** an interface a consumer could implement. Everything else is a
 * provider; this is Cloud's commercial layer sitting above the provider set,
 * which is exactly where the OSS/commercial line is drawn.
 *
 * **A flag is legitimate only when it meters a resource Cloud itself buys.**
 * Four kinds of gate do not belong here, however tempting:
 *
 * - Editor *capability* the OSS build grants free — fonts, theming, custom
 *   blocks, autosave. Gating it leaves a paying customer worse off than a free
 *   one.
 * - Declining to use a Cloud service — a consumer's own media storage, for
 *   instance. Charging for the *absence* of a Cloud cost is backwards, which is
 *   why the media tier is limits-only.
 * - Anything a browser flag cannot enforce: HTML output belongs to the server
 *   render, MJML export is unenforceable because `@templatical/renderer` is MIT
 *   (whoever holds the JSON holds the MJML), and headless access is a
 *   server-side auth question.
 * - Anything config already decides — `branding: false` hides the footer on any
 *   plan without an entitlement's help.
 *
 * Quantity limits are the honest lever — see {@link PlanLimits}.
 */
interface PlanFeatures {
  /** Inference spend, per call. */
  ai_generation: boolean;
  /** Realtime connection capacity. */
  collaboration: boolean;
  /** Storage plus realtime fan-out. */
  commenting: boolean;
  /** Storage for saved blocks. */
  saved_modules: boolean;
  /** Sending cost and deliverability reputation. */
  test_email: boolean;
}
interface PlanLimits {
  max_file_size_mb: number;
  max_templates: number | null;
  media_categories: string[];
  storage_limit_bytes: number;
}
interface PlanConfig {
  features: PlanFeatures;
  limits: PlanLimits;
  template_count: number;
  plan: string;
  media: MediaConfig;
  storage: StorageInfo;
  websocket: WebSocketServerConfig;
  accessibility?: {
    blockOnError?: boolean;
  };
}
interface AiChatMessage {
  id: string;
  role: "user" | "assistant";
  content: string;
  timestamp: number;
}
interface CreateCommentData {
  body: string;
  blockId?: string;
  parentId?: string;
  authorIdentifier: string;
  authorName: string;
}
interface UpdateCommentData {
  body: string;
}
interface AiGenerateOptions {
  conversationId?: string;
}
interface AiStreamEvent {
  type: "text" | "done" | "error";
  text?: string;
  content?: TemplateContent;
  conversationId?: string;
  error?: string;
}
interface RewriteData {
  text: string;
  instruction: string;
  blockId: string;
}
interface AiScoreOptions {
  fixFindingId?: string;
}
//#endregion
export { type AiChatMessage, type AiConfig, type AiGenerateOptions, type AiScoreOptions, type AiStreamEvent, type ApiError, type ApiResponse, type AuthConfig, type AuthRequestOptions, BUTTON_BLOCK_DEFAULTS, type BaseBlock, type Block, type BlockDefaults, type BlockStyles, type BlockType, type BlockVisibility, type ButtonBlock, COUNTDOWN_BLOCK_DEFAULTS, type CategoryScore, type CollaborationConfig, type Collaborator, type ColorsConfig, type ColumnLayout, type Comment, type CommentAuthor, type CommentChange, type CommentEvent, type CommentEventType, type CommentInput, type CommentPatch, type CommentResponse, type CommentsListParams, type CommentsProvider, type CountdownBlock, type CreateCommentData, type CustomBlock, type CustomBlockBooleanField, type CustomBlockColorField, type CustomBlockDefinition, type CustomBlockField, type CustomBlockFieldBase, type CustomBlockFieldType, type CustomBlockImageField, type CustomBlockNumberField, type CustomBlockRepeatableField, type CustomBlockSelectField, type CustomBlockTextField, type CustomBlockTextareaField, type CustomFont, DEFAULT_BLOCK_DEFAULTS, DEFAULT_TEMPLATE_DEFAULTS, DIVIDER_BLOCK_DEFAULTS, type DataSourceConfig, type DataSourceFetchContext, type DirectAuthConfig, type DisplayCondition, type DisplayConditionsConfig, type DividerBlock, type EditorUser, EventEmitter, type ExportResult, type FindingSeverity, type FontsConfig, HEADING_LEVEL_FONT_SIZE, HTML_BLOCK_DEFAULTS, type HeadingLevel, type HealthCheckResult, type HtmlBlock, IMAGE_BLOCK_DEFAULTS, type ImageBlock, type LogicPair, type LogicTag, type LogicTagsConfig, MENU_BLOCK_DEFAULTS, type McpConfig, type McpOperation, type McpOperationPayload, type MediaResult, type MenuBlock, type MenuItemData, type MergeTag, type MergeTagsConfig, PARAGRAPH_BLOCK_DEFAULTS, type ParagraphBlock, type PlanConfig, type PlanFeatures, type PlanLimits, type PreviewResolveContext, type ProxyAuthConfig, type RenderPayload, type RenderProvider, type ResolvePreview, type RewriteData, SECTION_BLOCK_DEFAULTS, SOCIAL_ICONS_BLOCK_DEFAULTS, SOCIAL_ICON_GLYPHS, SPACER_BLOCK_DEFAULTS, SYNTAX_PRESETS, type SavedBlock, type SavedBlockInput, type SavedBlockPatch, type SavedBlocksListParams, type SavedBlocksProvider, type ScoringCategory, type ScoringFinding, type ScoringResult, type SdkAuthConfig, SdkError, type SectionBlock, type SectionWrapper, type SelectOption, type SocialIcon, type SocialIconGlyph, type SocialIconSize, type SocialIconStyle, type SocialIconsBlock, type SocialPlatform, type SpacerBlock, type SpacingValue, type SyntaxPreset, type SyntaxPresetName, TABLE_BLOCK_DEFAULTS, TITLE_BLOCK_DEFAULTS, type TableBlock, type TableCellData, type TableRowData, type Template, type TemplateContent, type TemplateDefaults, type TemplatePatch, type TemplateSettings, type TemplateVersion, type TemplateVersionResponse, type TemplatesProvider, type TestEmailConfig, type TestEmailPayload, type TestEmailProvider, type ThemeOverrides, type TitleBlock, type TokenData, type UiTheme, type UpdateCommentData, type UserConfig, VIDEO_BLOCK_DEFAULTS, type VersionHistoryListParams, type VersionHistoryListResult, type VersionHistoryProvider, type VideoBlock, type ViewportSize, type WebSocketServerConfig, cloneBlock, containsMergeTag, createBlock, createButtonBlock, createCountdownBlock, createCustomBlock, createDefaultTemplateContent, createDividerBlock, createHtmlBlock, createImageBlock, createMenuBlock, createParagraphBlock, createSectionBlock, createSocialIconsBlock, createSpacerBlock, createTableBlock, createTitleBlock, createVideoBlock, deepMergeDefaults, findOpenTagEnd, generateId, getLogicMergeTagKeyword, getMergeTagLabel, getMergeTagSample, getSyntaxClosingChar, getSyntaxTriggerChar, getTagAttrValue, hasMergeTagSamples, isButton, isCountdown, isCustomBlock, isDivider, isHtml, isImage, isLogicMergeTagValue, isMenu, isMergeTagValue, isParagraph, isRenderableTemplateContent, isSection, isSocialIcons, isSpacer, isTable, isTitle, isVideo, resolveHtmlLogicMergeTagLabels, resolveHtmlMergeTagLabels, resolveSyntax, safeClone, substituteHtmlMergeTagSamples, substituteTextMergeTagSamples };
//# sourceMappingURL=index.d.ts.map