@atom63/slides 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1284 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode, HTMLAttributes, ImgHTMLAttributes } from 'react';
+import { S as SlideLayout, a as SlideDeckItem } from './template-registry-BOJP4rlI.js';
+export { P as ParsedSlide, b as SlideDeckMeta, c as SlotDef, d as SlotGroupDef, e as SlotKind, T as TemplateCategory, f as TemplateDef, g as TemplateName, h as getTemplate, l as listTemplates, t as templateNames, i as templateRegistry } from './template-registry-BOJP4rlI.js';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+
+interface SlideGateProvider {
+    fetchConfigured: (slug: string) => Promise<boolean>;
+    gateEnvVarName: (slug: string) => string;
+    isUnlocked: (slug: string) => boolean;
+    setUnlocked: (slug: string) => void;
+    verify: (slug: string, code: string) => Promise<boolean>;
+}
+
+/** Presenter script for the current slide — hidden on stage, surfaced in panels. */
+declare function TalkTrack({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace TalkTrack {
+    var displayName: string;
+}
+/** Hidden marker that sets the frame section label for this and following slides. */
+declare function Section({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace Section {
+    var displayName: string;
+}
+declare function Slide({ children, layout }: {
+    children: ReactNode;
+    layout?: SlideLayout;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace Slide {
+    var displayName: string;
+}
+/** Small uppercase label — monospace, tracked-out. */
+declare function Overline({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare namespace Overline {
+    var displayName: string;
+}
+/** Small muted text — attribution, dates, metadata. */
+declare function Caption({ children, reveal, index, }: {
+    children: ReactNode;
+    reveal?: boolean;
+    index?: number;
+}): react_jsx_runtime.JSX.Element;
+declare namespace Caption {
+    var displayName: string;
+}
+/** Thin decorative line — not a slide break. */
+declare function Divider$1(): react_jsx_runtime.JSX.Element;
+declare namespace Divider$1 {
+    var displayName: string;
+}
+/** Large numeral — monospace display number. */
+declare function SlideNumber({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare namespace SlideNumber {
+    var displayName: string;
+}
+declare function SlideImage({ src, alt, fill, className, }: {
+    src: string;
+    alt: string;
+    fill?: boolean;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace SlideImage {
+    var displayName: string;
+}
+declare function SlideVideo({ src, alt, fill, className, }: {
+    src: string;
+    alt: string;
+    fill?: boolean;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace SlideVideo {
+    var displayName: string;
+}
+declare function SlideGrid({ children, columns, gap, }: {
+    children: ReactNode;
+    columns?: 2 | 3 | 4;
+    gap?: 'sm' | 'md' | 'lg';
+}): react_jsx_runtime.JSX.Element;
+declare namespace SlideGrid {
+    var displayName: string;
+}
+
+type GapSize = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+type AlignOption = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+type JustifyOption = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+/** Multi-column layout with equal width columns */
+declare function Columns({ children, count, gap, align, }: {
+    children: ReactNode;
+    count?: 2 | 3 | 4;
+    gap?: GapSize;
+    align?: AlignOption;
+}): react_jsx_runtime.JSX.Element;
+type SplitRatio = '1/1' | '2/1' | '1/2' | '3/1' | '1/3';
+type TrioRatio = '1/1/1' | '2/1/1' | '1/2/1' | '1/1/2';
+/**
+ * Two-up layout on the 12-column master grid. Use this for asymmetric
+ * splits (narrative + media, quote + photo, thesis + detail) without
+ * writing `colStart` / `colSpan` by hand. The ratio maps to fixed 12-col
+ * spans so slides using `Split` always align with slides using `<Grid>`.
+ *
+ *   1/1 → 6 + 6
+ *   2/1 → 8 + 4
+ *   1/2 → 4 + 8
+ *   3/1 → 9 + 3
+ *   1/3 → 3 + 9
+ *
+ * Pass two direct children; extra children are ignored.
+ */
+declare function Split({ children, ratio, gap, align, }: {
+    children: ReactNode;
+    ratio?: SplitRatio;
+    gap?: GapSize;
+    align?: AlignOption;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Three-up layout on the 12-column master grid. Same rhythm rules as
+ * `Split` — ratios resolve to 12-col spans so trios align with the rest
+ * of the deck.
+ *
+ *   1/1/1 → 4 + 4 + 4
+ *   2/1/1 → 6 + 3 + 3
+ *   1/2/1 → 3 + 6 + 3
+ *   1/1/2 → 3 + 3 + 6
+ */
+declare function Trio({ children, ratio, gap, align, }: {
+    children: ReactNode;
+    ratio?: TrioRatio;
+    gap?: GapSize;
+    align?: AlignOption;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * CSS Grid foundation — the slide master grid.
+ *
+ * Every slide in the deck uses a shared **12-column** horizontal rhythm.
+ * This is what makes paging through the deck feel like one authored
+ * object instead of loose artboards: titles, media edges, and stat
+ * columns all snap to the same vertical lines slide-to-slide.
+ *
+ * Rows adapt to content (6 for three-up bentos, 8 for stat grids, etc.)
+ * but `cols` should stay at 12 unless you're writing a one-off full-bleed
+ * layout. If you find yourself overriding `cols`, consider whether the
+ * layout belongs behind a template instead.
+ *
+ * A Title rendered by `Grid` sits under a top hairline rule so the
+ * slide header reads as a Swiss editorial masthead.
+ */
+declare function Grid({ children, cols, rows, gap, label, title, ruled, }: {
+    children: ReactNode;
+    cols?: number;
+    rows?: number;
+    gap?: GapSize;
+    label?: string;
+    title?: string;
+    /** Draw the masthead hairline above label/title. Default true. */
+    ruled?: boolean;
+}): react_jsx_runtime.JSX.Element;
+type CellVariant = 'none' | 'muted' | 'outline' | 'accent' | 'rule' | 'frame' | 'solid';
+type CellPadding = 'none' | 'sm' | 'md' | 'lg';
+type CellOverflow = 'hidden' | 'visible';
+/**
+ * A cell inside a `Grid`. Place via colStart/rowStart and span via colSpan/rowSpan.
+ *
+ * Variant vocabulary (Swiss-first):
+ *   none     — no chrome, just layout
+ *   rule     — top hairline only, transparent bg (the default bento treatment)
+ *   frame    — 1px hairline on all four sides, transparent bg
+ *   outline  — legacy alias for `frame`
+ *   muted    — filled plate (use sparingly, for dense data cells)
+ *   accent   — solid signal-color block with inverted text
+ *   solid    — solid foreground block with inverted text
+ *
+ * Corners are square by default — pass `rounded` for the exception.
+ */
+declare function Cell({ children, colSpan, rowSpan, colStart, rowStart, variant, padding, overflow, rounded, }: {
+    children: ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+    colStart?: number;
+    rowStart?: number;
+    variant?: CellVariant;
+    padding?: CellPadding;
+    overflow?: CellOverflow;
+    rounded?: boolean;
+}): react_jsx_runtime.JSX.Element;
+/** Vertical stack with consistent spacing */
+declare function Stack({ children, gap, align, justify, className, }: {
+    children: ReactNode;
+    gap?: GapSize;
+    align?: AlignOption;
+    justify?: JustifyOption;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/** Horizontal row with alignment control */
+declare function Row({ children, gap, align, justify, wrap, }: {
+    children: ReactNode;
+    gap?: GapSize;
+    align?: AlignOption;
+    justify?: JustifyOption;
+    wrap?: boolean;
+}): react_jsx_runtime.JSX.Element;
+/** Center content on both axes */
+declare function Center({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/** Explicit whitespace — use for intentional spacing */
+declare function Spacer({ size }: {
+    size?: GapSize;
+}): react_jsx_runtime.JSX.Element;
+type TextAlign = 'left' | 'center' | 'right';
+type TextColor = 'default' | 'secondary' | 'muted' | 'accent' | 'inherit';
+/**
+ * Hero numeral / single-word text. Light + tight tracking signals
+ * decorative, not authored. Use for big stats or one-word statements.
+ */
+declare function Display({ children, align, color, size, weight, }: {
+    children: ReactNode;
+    align?: TextAlign;
+    color?: TextColor;
+    size?: 'sm' | 'md' | 'lg';
+    weight?: 'extralight' | 'light' | 'regular' | 'medium';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Full-slide statement headline. Use when the whole slide is one
+ * sentence (keynote thesis, section opener). Always 128px.
+ */
+declare function Headline({ children, align, color, weight, }: {
+    children: ReactNode;
+    align?: TextAlign;
+    color?: TextColor;
+    weight?: 'light' | 'regular' | 'medium' | 'semibold';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Slide title. Use when the slide has supporting content below a heading.
+ * Always 72px. Defaults to medium — bump to semibold for covers.
+ */
+declare function Title({ children, align, color, weight, }: {
+    children: ReactNode;
+    align?: TextAlign;
+    color?: TextColor;
+    weight?: 'light' | 'regular' | 'medium' | 'semibold';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Sub-head under a Title, or a section label that still needs to read
+ * as type (not a Label). Always 44px. Color defaults to foreground —
+ * pass `color="muted"` for quieter sub-heads.
+ */
+declare function Subtitle({ children, align, color, weight, }: {
+    children: ReactNode;
+    align?: TextAlign;
+    color?: TextColor;
+    weight?: 'light' | 'regular' | 'medium' | 'semibold';
+}): react_jsx_runtime.JSX.Element;
+/** Paragraph text. `md` is the default — go sm for dense cells, lg for emphasis. */
+declare function Body({ children, align, color, size, weight, reveal, index, }: {
+    children: ReactNode;
+    align?: TextAlign;
+    color?: TextColor;
+    size?: 'sm' | 'md' | 'lg';
+    weight?: 'light' | 'regular' | 'medium' | 'semibold';
+    reveal?: boolean;
+    index?: number;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Renders a body string that may contain `\n` line breaks as separate
+ * `<Body>` paragraphs with a gap between them. Use this instead of
+ * `<Body>{string}</Body>` whenever the text comes from a template prop.
+ */
+declare function BodyLines({ children, size, color, }: {
+    children: string;
+    size?: 'sm' | 'md' | 'lg';
+    color?: 'default' | 'muted' | 'secondary' | 'accent' | 'inherit';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Small uppercase annotation. One size only (18px). Use for eyebrows,
+ * figure captions, section markers, attribution lines.
+ *
+ * `orientation="vertical"` sets the label in the margin, running
+ * bottom-to-top — the Swiss gutter label treatment.
+ */
+declare function Label({ children, align, color, font, orientation, reveal, index, }: {
+    children: ReactNode;
+    align?: TextAlign;
+    color?: TextColor;
+    font?: 'mono' | 'sans';
+    orientation?: 'horizontal' | 'vertical';
+    reveal?: boolean;
+    index?: number;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Inline content highlight. `text-primary` is reserved for content
+ * emphasis — if you want a ghost tint, use `text-foreground/XX` directly.
+ */
+declare function Accent({ children, color, }: {
+    children: ReactNode;
+    color?: 'accent' | 'default';
+}): react_jsx_runtime.JSX.Element;
+/** Inline monospace for numbers, code, technical content. */
+declare function Mono({ children, size, }: {
+    children: ReactNode;
+    size?: 'sm' | 'md' | 'lg';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Inline code token for use inside Body or template body props.
+ * Uses `em`-relative sizing so it scales with whatever Body size it sits in.
+ */
+declare function InlineCode({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Pull quote. `sm` for inline quotes inside a content slide, `lg` for a
+ * full-slide pull quote.
+ *
+ * The decorative open-quote glyph is positioned with a negative offset
+ * so it sits just outside the text block — beautiful inline but liable
+ * to clip when the quote is placed in the left column of a slide.
+ * Pass `decorated={false}` to suppress the glyph (the Swiss editorial
+ * treatment) and rely on rules + attribution to signal "quote".
+ */
+declare function Quote({ children, attribution, size, decorated, }: {
+    children: ReactNode;
+    attribution?: string;
+    size?: 'sm' | 'lg';
+    decorated?: boolean;
+}): react_jsx_runtime.JSX.Element;
+type ObjectFit = 'cover' | 'contain' | 'fill';
+type AspectRatio = '16/9' | '4/3' | '1/1' | 'auto';
+/**
+ * Syntax-highlighted code block sized for the slide canvas.
+ *
+ * Two usage modes:
+ *   - Fenced code blocks in MDX (```tsx) render through this automatically via
+ *     the `pre` override in slideMdxComponents — pass nothing, `children` carries
+ *     the already-highlighted rehype-pretty-code output.
+ *   - Explicit JSX usage: pass a `code` string prop and Shiki highlights it at
+ *     runtime using the github-dark-dimmed theme.
+ *
+ * Font scales with --slide-type-scale like all other slide typography.
+ */
+declare function SlideCodeBlock({ children, language, code, dataTheme, }: {
+    children?: ReactNode;
+    language?: string;
+    /** Plain code string — triggers runtime Shiki highlighting. */
+    code?: string;
+    /** Forwarded from rehype-pretty-code's data-theme on the original <pre>. */
+    dataTheme?: string;
+}): react_jsx_runtime.JSX.Element;
+/** Image with fit modes and optional aspect-ratio container. Square corners by default. */
+declare function Image({ src, alt, fit, rounded, aspectRatio, className, caption, }: {
+    src: string;
+    alt: string;
+    fit?: ObjectFit;
+    rounded?: boolean;
+    aspectRatio?: AspectRatio;
+    className?: string;
+    caption?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Video with autoplay/loop and optional aspect-ratio container.
+ *
+ * Play/pause is driven by IntersectionObserver so the video only runs when
+ * its slide is visible. On exit the video pauses and resets to the start so
+ * revisiting the slide always replays from the beginning — standard
+ * presentation behavior. `autoPlay={false}` on the HTML element prevents
+ * the browser from playing before visibility is confirmed.
+ */
+declare function Video({ src, fit, rounded, aspectRatio, autoPlay, loop, muted, poster, caption, }: {
+    src: string;
+    fit?: ObjectFit;
+    rounded?: boolean;
+    aspectRatio?: AspectRatio;
+    autoPlay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    /** Static frame shown while the video is loading or the slide is off-screen. */
+    poster?: string;
+    caption?: string;
+}): react_jsx_runtime.JSX.Element;
+/** Material icon at slide scale */
+declare function Icon({ name, size, color, }: {
+    name: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    color?: TextColor;
+}): react_jsx_runtime.JSX.Element;
+/** Circular avatar image. Avatars are the one primitive that stays rounded — intentional human marker. */
+declare function Avatar({ src, alt, size, }: {
+    src: string;
+    alt: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+}): react_jsx_runtime.JSX.Element;
+type BoxVariant = 'default' | 'muted' | 'outline' | 'accent' | 'solid';
+/** Container with background/border/padding. Square corners by default. */
+declare function Box({ children, variant, padding, rounded, className, }: {
+    children: ReactNode;
+    variant?: BoxVariant;
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    rounded?: boolean;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/** Horizontal or vertical rule. Accent is a solid 2px signal-color bar. */
+declare function Divider({ direction, color, weight, }: {
+    direction?: 'horizontal' | 'vertical';
+    color?: 'muted' | 'accent' | 'default';
+    weight?: 'thin' | 'thick';
+}): react_jsx_runtime.JSX.Element;
+/** Small square tag. Shares type sizing with `Label` (18px) so a Badge
+ *  beside a Label reads on the same baseline. Hard-edged, hairline-framed —
+ *  the Swiss form-tag treatment. */
+declare function Badge({ children, variant, }: {
+    children: ReactNode;
+    variant?: 'muted' | 'accent' | 'outline' | 'solid';
+}): react_jsx_runtime.JSX.Element;
+/** Framed highlight block — hairline on all sides, no fill tint. Accent swaps to a solid signal-color block. */
+declare function Highlight({ children, variant, }: {
+    children: ReactNode;
+    variant?: 'accent' | 'muted' | 'frame';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Solid color block. Full-bleed primary / foreground rectangle — use
+ * behind a word of Headline or a stat numeral for the Müller-Brockmann
+ * "color plate" move. Accepts children so text sits on the block with
+ * inverted color.
+ */
+declare function ColorBlock({ children, color, padding, className, }: {
+    children?: ReactNode;
+    color?: 'primary' | 'foreground';
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Editorial form-stamp for media and data cells. Renders "FIG. 03 / 14"
+ * or any register/total pair in mono tabular nums. Use absolutely
+ * positioned inside a cell, or inline above a caption.
+ */
+declare function FigureMark({ register, total, prefix, className, }: {
+    register: number | string;
+    total?: number | string;
+    prefix?: string;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Large margin numeral — the Müller-Brockmann section marker. Renders a
+ * giant extralight numeral pushed off to one side with a vertical
+ * orientation. Place inside a 2-column slice on the outer edge of a
+ * slide.
+ *
+ *   <SectionMarker number="03" caption="Foundations" />
+ */
+declare function SectionMarker({ number, caption, side, }: {
+    number: string;
+    caption?: string;
+    side?: 'left' | 'right';
+}): react_jsx_runtime.JSX.Element;
+/** Styled list with custom markers. Numbered lists use tabular mono for Swiss register. */
+declare function List({ children, marker, gap, }: {
+    children: ReactNode;
+    marker?: 'dash' | 'number' | 'bullet' | 'none';
+    gap?: GapSize;
+}): react_jsx_runtime.JSX.Element;
+/** List item — use inside List. Size matches `Body` md so inline body
+ *  text and list items read on the same baseline. */
+declare function Item({ children, reveal, index, }: {
+    children: ReactNode;
+    reveal?: boolean;
+    index?: number;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Entrance animation wrapper. Wraps any content in a div that animates in
+ * when the slide becomes visible. Set `index` for staggered sequences.
+ *
+ * ```mdx
+ * <Reveal index={0}>First item</Reveal>
+ * <Reveal index={1}>Second item</Reveal>
+ * ```
+ */
+declare function Reveal({ children, index }: {
+    children: ReactNode;
+    index?: number;
+}): react_jsx_runtime.JSX.Element;
+/** Full-bleed container that breaks out of padding */
+declare function Bleed({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/** Flex grow to push content */
+declare function Fill(): react_jsx_runtime.JSX.Element;
+/**
+ * Live — renders a React component at natural browser scale inside a slide.
+ *
+ * The slide canvas (1920×1080) is shrunk via `transform: scale(s)` in
+ * SlideStage. `Live` counter-acts that with `zoom: 1/s` (precomputed by
+ * SlideStage as `--slide-stage-zoom`) so components render at their
+ * natural CSS pixel size regardless of the window size.
+ *
+ * Size components with explicit CSS dimensions or Tailwind size utilities
+ * (e.g. `w-96`, `max-w-lg`). The parent `<Demo>` frame clips overflow and
+ * centers the content. Slide typography primitives (Headline, Body, etc.)
+ * are isolated via `--slide-type-scale: 0`.
+ *
+ * ```mdx
+ * <Demo aspectRatio="16/9">
+ *   <Carousel className="max-w-lg">…</Carousel>
+ * </Demo>
+ * ```
+ */
+declare function Live({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare namespace Live {
+    var displayName: string;
+}
+declare function Demo({ children, aspectRatio, padding, label, }: {
+    children: ReactNode;
+    /** CSS aspect-ratio — same ergonomics as the `aspectRatio` prop on `<Image>`. Defaults to `"16/9"`. */
+    aspectRatio?: string;
+    /** Inset padding inside the frame before the component renders. */
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    /** Optional figure caption rendered below the frame. */
+    label?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace Demo {
+    var displayName: string;
+}
+/** Custom positioning wrapper */
+declare function Position({ children, top, right, bottom, left, }: {
+    children: ReactNode;
+    top?: number | string;
+    right?: number | string;
+    bottom?: number | string;
+    left?: number | string;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Syllabus / handout block for a slide deck.
+ *
+ * In presentation mode: renders as a hidden DOM container so the slide stage
+ * extractors (useSlidesDom, useSyllabus) can clone it into the reading layout.
+ *
+ * In web-syllabus mode: renders as a visible, styled document section.
+ * Write standard MDX headings (## Overview, ## Objectives, etc.) as children —
+ * no sub-component wrappers needed. Only <Syllabus.Meta> remains for
+ * structured key-value metadata (duration, format, audience, etc.).
+ */
+declare function Syllabus({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare namespace Syllabus {
+    var displayName: string;
+    var Meta: {
+        ({ duration, audience, format, location, date }: SyllabusMetaProps): react_jsx_runtime.JSX.Element | null;
+        displayName: string;
+    };
+}
+interface SyllabusMetaProps {
+    audience?: string;
+    date?: string;
+    duration?: string;
+    format?: string;
+    location?: string;
+}
+
+/**
+ * Editorial cover slide — massive wrapping title top-left, optional eyebrow
+ * (typically a year or date) top-right, optional credit bottom-left.
+ * No subtitle, no badges, no image. Designed to feel like a magazine cover.
+ *
+ * The title uses the same pixel size as `Display lg` (160px) but semibold
+ * weight — Display is decorative/light, the cover is authored.
+ *
+ * A full-width hairline above the title turns the cover into a masthead.
+ */
+declare function CoverSlide({ title, subtitle, eyebrow, credit, logo, }: {
+    title: string;
+    /** Optional deck hook — one line under the main title (editorial cover). */
+    subtitle?: string;
+    /** Small text anchored to the top-right corner — typically a year or date. */
+    eyebrow?: string;
+    /** Small text anchored to the bottom-left corner — typically an author credit. */
+    credit?: string;
+    /** Optional brand mark rendered inline just above the title. */
+    logo?: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+/** Full-bleed media slide — image/video fills the entire canvas.
+ *  Optional label+title render in a solid bottom-left block.
+ *
+ *  The overlay uses a hard-edged black block with white type — no blur,
+ *  no transparency, no rounded corners. Swiss posters don't wash titles
+ *  over photos; they cut a plate and set them flat. */
+declare function FullBleedSlide({ mediaSrc, mediaAlt, mediaType, label, title, }: {
+    mediaSrc: string;
+    mediaAlt?: string;
+    mediaType?: 'image' | 'video';
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+/**
+ * Full-bleed image or video with **cover-style** typography — top masthead band
+ * + bottom title plate, both solid black with white type (no blur, no tinted
+ * washes). Use for workshop openers, chapter covers, and hero beats where
+ * `CoverSlide` (type-only) is too empty but `FullBleedSlide` (small bottom-left
+ * caption only) is too little structure.
+ *
+ * The photo shows in the middle band; keep contrast on the plates only.
+ */
+declare function FullBleedCoverSlide({ title, subtitle, eyebrow, credit, mediaSrc, mediaAlt, mediaType, mastheadLabel, }: {
+    title: string;
+    /** Hook under the main title — muted, like `CoverSlide` subtitle. */
+    subtitle?: string;
+    /** Small text on the top-right of the masthead band (e.g. year, “Workshop”). */
+    eyebrow?: string;
+    /** Credit line in the bottom plate, above a hairline — like `CoverSlide`. */
+    credit?: string;
+    mediaSrc: string;
+    mediaAlt?: string;
+    mediaType?: 'image' | 'video';
+    /** Left label in the top band; defaults to the deck’s cover glyph. */
+    mastheadLabel?: string;
+}): react_jsx_runtime.JSX.Element | null;
+/**
+ * Editorial quote slide — flush-left pull quote, attribution on its own
+ * line under a hairline. Previously centered; now composed on the 12-col
+ * grid so the quote sits on the same left edge as every other slide.
+ */
+declare function QuoteSlide({ quote, attribution }: {
+    quote: string;
+    attribution?: string;
+}): react_jsx_runtime.JSX.Element | null;
+type SectionAxis = 'editorial' | 'flush-left' | 'centered';
+/**
+ * Section title slide.
+ *
+ *   axis="editorial"  (default when `number` is set) — huge margin numeral
+ *                     on the left, headline flush-left in the content area.
+ *                     The Müller-Brockmann section marker treatment.
+ *   axis="flush-left" — simple flush-left heading, no margin numeral.
+ *   axis="centered"   — legacy axial layout.
+ *
+ * With `imageSrc` the layout always falls into a text-left / media-right
+ * split regardless of axis so the rhythm matches `Split` slides.
+ */
+declare function SectionSlide({ number, title, subtitle, imageSrc, imageAlt, axis, }: {
+    number?: string;
+    title: string;
+    subtitle?: string;
+    imageSrc?: string;
+    imageAlt?: string;
+    axis?: SectionAxis;
+}): react_jsx_runtime.JSX.Element | null;
+/**
+ * Thesis slide — one headline, optional kicker and subcopy.
+ *
+ *   axis="flush-left" (default) — Swiss editorial: kicker + headline
+ *                     flush to the left, subtitle underneath capped at
+ *                     a readable measure. A hairline rule above the
+ *                     kicker ties the slide into the deck's frame.
+ *   axis="centered"   — legacy axial layout (opt-in only).
+ */
+declare function StatementSlide({ kicker, title, subtitle, axis, }: {
+    kicker?: string;
+    title: string;
+    subtitle?: string;
+    axis?: 'flush-left' | 'centered';
+}): react_jsx_runtime.JSX.Element | null;
+declare const splitHalfGaps: {
+    readonly md: "gap-6";
+    readonly lg: "gap-10";
+    readonly xl: "gap-16";
+};
+declare function SplitHalfPanel({ children, justify, }: {
+    children: ReactNode;
+    justify?: 'start' | 'center' | 'end';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Fifty-fifty deck split — vertical (columns) or horizontal (rows).
+ * Use two `SplitHalf.Panel` children: narrative vs media, thesis vs proof, etc.
+ */
+declare function SplitHalf({ children, axis, gap, label, title, }: {
+    children: ReactNode;
+    axis?: 'horizontal' | 'vertical';
+    gap?: keyof typeof splitHalfGaps;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace SplitHalf {
+    var Panel: typeof SplitHalfPanel;
+}
+interface ClosingContact {
+    /** Optional URL. When set, the value renders as an anchor — external
+     *  http(s) links open in a new tab; mailto: and tel: open natively. */
+    href?: string;
+    label: string;
+    value: string;
+}
+/**
+ * Editorial closing slide — a deliberate bookend rather than a reversed
+ * cover. Title vertically centered so it reads as the final statement,
+ * flanked by a giant ▼ glyph acting as a typographic full-stop — part of
+ * the deck's primitive-shape vocabulary (▲ cover / ■ section / ◆ quote /
+ * ▼ closing). The footer is a tabular colophon — Web / Email / Also —
+ * each column labelled and aligned on the 12-col rhythm, so the last
+ * page of the deck reads like the colophon of a book.
+ */
+declare function ClosingSlide({ title, eyebrow, website, email, handles, }: {
+    title: string;
+    /** Small text anchored to the top-right corner (e.g. "2026", "Q&A"). */
+    eyebrow?: string;
+    /** Primary website URL rendered on its own line. */
+    website?: string;
+    /** Contact email rendered below the website. */
+    email?: string;
+    /** Supplementary contacts (handles, sites, tools). Each entry takes
+     *  its own labelled column on the colophon row. Pass an `href` to
+     *  make the value clickable — `website` and `email` are auto-linked. */
+    handles?: ClosingContact[];
+}): react_jsx_runtime.JSX.Element | null;
+declare function HeroBentoHero({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function HeroBentoCard({ title, body }: {
+    title: string;
+    body?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function HeroBento({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace HeroBento {
+    var Hero: typeof HeroBentoHero;
+    var Card: typeof HeroBentoCard;
+}
+declare function MediaTrioHero({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function MediaTrioMedia({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function MediaTrio({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace MediaTrio {
+    var Hero: typeof MediaTrioHero;
+    var Media: typeof MediaTrioMedia;
+}
+declare function StatBentoBody({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function StatBentoStat({ value, label }: {
+    value: string;
+    label: string;
+}): react_jsx_runtime.JSX.Element;
+declare function StatBento({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace StatBento {
+    var Body: typeof StatBentoBody;
+    var Stat: typeof StatBentoStat;
+}
+declare function CollageFeatured({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function CollageImage({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function Collage({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace Collage {
+    var Featured: typeof CollageFeatured;
+    var Image: typeof CollageImage;
+}
+declare function QuoteWithMediaQuote({ text, attribution }: {
+    text: string;
+    attribution?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function QuoteWithMediaMedia({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function QuoteWithMedia({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace QuoteWithMedia {
+    var Quote: typeof QuoteWithMediaQuote;
+    var Media: typeof QuoteWithMediaMedia;
+}
+declare function SplitWithStatText({ title: cellTitle, body, bullets, }: {
+    title: string;
+    body?: ReactNode;
+    bullets?: string[];
+}): react_jsx_runtime.JSX.Element;
+declare function SplitWithStatMedia({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function SplitWithStatStat({ value, label }: {
+    value: string;
+    label: string;
+}): react_jsx_runtime.JSX.Element;
+declare function SplitWithStat({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace SplitWithStat {
+    var Text: typeof SplitWithStatText;
+    var Media: typeof SplitWithStatMedia;
+    var Stat: typeof SplitWithStatStat;
+}
+declare function TextLeadText({ title: cellTitle, body, bullets, }: {
+    title?: string;
+    body?: ReactNode;
+    bullets?: string[];
+}): react_jsx_runtime.JSX.Element;
+declare function TextLeadMedia({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function TextLead({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace TextLead {
+    var Text: typeof TextLeadText;
+    var Media: typeof TextLeadMedia;
+}
+declare function TimelineBentoIntro({ title: cellTitle, body }: {
+    title: string;
+    body?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TimelineBentoStep({ step, title: cellTitle, body, }: {
+    step?: string;
+    title: string;
+    body?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TimelineBento({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace TimelineBento {
+    var Intro: typeof TimelineBentoIntro;
+    var Step: typeof TimelineBentoStep;
+}
+declare function FullBleedGalleryImage({ src, alt }: {
+    src: string;
+    alt?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function FullBleedGallery({ children, label, title, }: {
+    children: ReactNode;
+    label?: string;
+    title?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace FullBleedGallery {
+    var Image: typeof FullBleedGalleryImage;
+}
+/**
+ * Single full-bleed image. Use when the visual is the entire message.
+ * Optional caption renders as a translucent bottom bar.
+ */
+declare function ImageSlide({ src, alt, caption, }: {
+    src: string;
+    alt?: string;
+    /** Short descriptor — renders as a translucent bottom bar. */
+    caption?: string;
+}): react_jsx_runtime.JSX.Element | null;
+/**
+ * Two images side by side, equal width, full bleed.
+ * A hairline gap separates the panels — editorial column rule.
+ */
+declare function ImageDuoSlide({ left, right, caption, }: {
+    left: {
+        src: string;
+        alt?: string;
+    };
+    right: {
+        src: string;
+        alt?: string;
+    };
+    /** Short descriptor — renders as a translucent bottom bar spanning both images. */
+    caption?: string;
+}): react_jsx_runtime.JSX.Element | null;
+/**
+ * Three images in equal columns, full bleed.
+ * Accepts 2–3 images; fewer than 3 leaves remaining columns as a muted placeholder.
+ */
+declare function ImageTrioSlide({ images, caption, }: {
+    images: {
+        src: string;
+        alt?: string;
+    }[];
+    /** Short descriptor — renders as a translucent bottom bar spanning all columns. */
+    caption?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+declare function SlideBreak(): react_jsx_runtime.JSX.Element;
+declare namespace SlideBreak {
+    var displayName: string;
+}
+declare const slideMdxComponents: {
+    h1: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    h2: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    h3: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    p: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    ul: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    ol: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    li: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    strong: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    code: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    blockquote: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    figure: ({ children }: {
+        children?: ReactNode;
+    }) => react_jsx_runtime.JSX.Element;
+    pre: ({ children, ...props }: React.HTMLAttributes<HTMLPreElement> & {
+        "data-language"?: string;
+        "data-theme"?: string;
+    }) => react_jsx_runtime.JSX.Element;
+    hr: typeof SlideBreak;
+    TalkTrack: typeof TalkTrack;
+    Syllabus: typeof Syllabus;
+    Slide: typeof Slide;
+    SlideImage: typeof SlideImage;
+    SlideVideo: typeof SlideVideo;
+    SlideGrid: typeof SlideGrid;
+    Overline: typeof Overline;
+    Caption: typeof Caption;
+    LegacyDivider: typeof Divider$1;
+    SlideNumber: typeof SlideNumber;
+    Section: typeof Section;
+    Columns: typeof Columns;
+    Grid: typeof Grid;
+    Cell: typeof Cell;
+    Split: typeof Split;
+    Trio: typeof Trio;
+    Stack: typeof Stack;
+    Row: typeof Row;
+    Center: typeof Center;
+    Spacer: typeof Spacer;
+    Display: typeof Display;
+    Headline: typeof Headline;
+    Title: typeof Title;
+    Subtitle: typeof Subtitle;
+    Body: typeof Body;
+    Label: typeof Label;
+    Accent: typeof Accent;
+    Mono: typeof Mono;
+    InlineCode: typeof InlineCode;
+    Quote: typeof Quote;
+    SlideCodeBlock: typeof SlideCodeBlock;
+    Image: typeof Image;
+    Video: typeof Video;
+    Icon: typeof Icon;
+    Avatar: typeof Avatar;
+    Box: typeof Box;
+    Divider: typeof Divider;
+    Badge: typeof Badge;
+    Highlight: typeof Highlight;
+    ColorBlock: typeof ColorBlock;
+    FigureMark: typeof FigureMark;
+    SectionMarker: typeof SectionMarker;
+    List: typeof List;
+    Item: typeof Item;
+    Bleed: typeof Bleed;
+    Fill: typeof Fill;
+    Demo: typeof Demo;
+    Live: typeof Live;
+    Position: typeof Position;
+    Reveal: typeof Reveal;
+    CoverSlide: typeof CoverSlide;
+    FullBleedCoverSlide: typeof FullBleedCoverSlide;
+    QuoteSlide: typeof QuoteSlide;
+    SectionSlide: typeof SectionSlide;
+    StatementSlide: typeof StatementSlide;
+    SplitHalf: typeof SplitHalf;
+    ClosingSlide: typeof ClosingSlide;
+    HeroBento: typeof HeroBento;
+    MediaTrio: typeof MediaTrio;
+    StatBento: typeof StatBento;
+    Collage: typeof Collage;
+    FullBleedGallery: typeof FullBleedGallery;
+    QuoteWithMedia: typeof QuoteWithMedia;
+    SplitWithStat: typeof SplitWithStat;
+    TextLead: typeof TextLead;
+    TimelineBento: typeof TimelineBento;
+    h4: ({ className, ...props }: react.ComponentProps<"h4">) => react_jsx_runtime.JSX.Element;
+    h5: ({ className, ...props }: react.ComponentProps<"h5">) => react_jsx_runtime.JSX.Element;
+    h6: ({ className, ...props }: react.ComponentProps<"h6">) => react_jsx_runtime.JSX.Element;
+    a: ({ className, href, target, rel, children, ...props }: react.ComponentProps<"a">) => react_jsx_runtime.JSX.Element;
+    em: ({ className, ...props }: react.ComponentProps<"em">) => react_jsx_runtime.JSX.Element;
+    del: ({ className, ...props }: react.ComponentProps<"del">) => react_jsx_runtime.JSX.Element;
+    ins: ({ className, ...props }: react.ComponentProps<"ins">) => react_jsx_runtime.JSX.Element;
+    kbd: ({ className, ...props }: react.ComponentProps<"kbd">) => react_jsx_runtime.JSX.Element;
+    mark: ({ className, ...props }: react.ComponentProps<"mark">) => react_jsx_runtime.JSX.Element;
+    sub: ({ className, ...props }: react.ComponentProps<"sub">) => react_jsx_runtime.JSX.Element;
+    sup: ({ className, ...props }: react.ComponentProps<"sup">) => react_jsx_runtime.JSX.Element;
+    abbr: ({ className, ...props }: react.ComponentProps<"abbr">) => react_jsx_runtime.JSX.Element;
+    cite: ({ className, ...props }: react.ComponentProps<"cite">) => react_jsx_runtime.JSX.Element;
+    dfn: ({ className, ...props }: react.ComponentProps<"dfn">) => react_jsx_runtime.JSX.Element;
+    time: ({ className, ...props }: react.ComponentProps<"time">) => react_jsx_runtime.JSX.Element;
+    var: ({ className, ...props }: react.ComponentProps<"var">) => react_jsx_runtime.JSX.Element;
+    samp: ({ className, ...props }: react.ComponentProps<"samp">) => react_jsx_runtime.JSX.Element;
+    output: ({ className, ...props }: react.ComponentProps<"output">) => react_jsx_runtime.JSX.Element;
+    details: ({ className, ...props }: react.ComponentProps<"details">) => react_jsx_runtime.JSX.Element;
+    summary: ({ className, ...props }: react.ComponentProps<"summary">) => react_jsx_runtime.JSX.Element;
+    iframe: ({ className, ...props }: react.ComponentProps<"iframe">) => react_jsx_runtime.JSX.Element;
+    video: ({ className, ...props }: react.ComponentProps<"video">) => react_jsx_runtime.JSX.Element;
+    audio: ({ className, ...props }: react.ComponentProps<"audio">) => react_jsx_runtime.JSX.Element;
+    img: ({ className, alt, ...props }: react.ComponentProps<"img">) => react_jsx_runtime.JSX.Element;
+    table: ({ className, ...props }: react.ComponentProps<"table">) => react_jsx_runtime.JSX.Element;
+    thead: ({ className, ...props }: react.ComponentProps<"thead">) => react_jsx_runtime.JSX.Element;
+    tbody: ({ className, ...props }: react.ComponentProps<"tbody">) => react_jsx_runtime.JSX.Element;
+    tr: ({ className, ...props }: react.ComponentProps<"tr">) => react_jsx_runtime.JSX.Element;
+    th: ({ className, ...props }: react.ComponentProps<"th">) => react_jsx_runtime.JSX.Element;
+    td: ({ className, ...props }: react.ComponentProps<"td">) => react_jsx_runtime.JSX.Element;
+    caption: ({ className, ...props }: react.ComponentProps<"caption">) => react_jsx_runtime.JSX.Element;
+};
+
+declare function SyllabusBody({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusHeadline({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusTitle({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusSubtitle({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusDisplay({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusLabel({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusMono({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusAccent({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+interface SyllabusQuoteProps {
+    attribution?: string;
+    children?: ReactNode;
+    decorated?: boolean;
+    size?: 'lg' | 'sm';
+}
+declare function SyllabusQuote({ children, attribution }: SyllabusQuoteProps): react_jsx_runtime.JSX.Element;
+declare const listGap: {
+    readonly sm: "space-y-1";
+    readonly md: "space-y-1.5";
+    readonly lg: "space-y-2";
+};
+declare function SyllabusList({ children, marker, gap, }: {
+    children?: ReactNode;
+    gap?: keyof typeof listGap;
+    marker?: 'bullet' | 'dash' | 'none' | 'number';
+}): react_jsx_runtime.JSX.Element;
+declare function SyllabusItem({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare const syllabusMdxComponents: {
+    h1: (props: HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+    h2: (props: HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+    h3: (props: HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+    h4: (props: HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+    h5: (props: HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+    h6: (props: HTMLAttributes<HTMLHeadingElement>) => react_jsx_runtime.JSX.Element;
+    p: (props: HTMLAttributes<HTMLParagraphElement>) => react_jsx_runtime.JSX.Element;
+    ul: (props: HTMLAttributes<HTMLUListElement>) => react_jsx_runtime.JSX.Element;
+    ol: (props: HTMLAttributes<HTMLOListElement>) => react_jsx_runtime.JSX.Element;
+    li: (props: HTMLAttributes<HTMLLIElement>) => react_jsx_runtime.JSX.Element;
+    blockquote: (props: HTMLAttributes<HTMLElement>) => react_jsx_runtime.JSX.Element;
+    img: ({ alt, className, ...props }: ImgHTMLAttributes<HTMLImageElement>) => react_jsx_runtime.JSX.Element;
+    Body: typeof SyllabusBody;
+    Headline: typeof SyllabusHeadline;
+    Title: typeof SyllabusTitle;
+    Subtitle: typeof SyllabusSubtitle;
+    Display: typeof SyllabusDisplay;
+    Label: typeof SyllabusLabel;
+    Mono: typeof SyllabusMono;
+    Accent: typeof SyllabusAccent;
+    Quote: typeof SyllabusQuote;
+    List: typeof SyllabusList;
+    Item: typeof SyllabusItem;
+    a: ({ className, href, target, rel, children, ...props }: react.ComponentProps<"a">) => react_jsx_runtime.JSX.Element;
+    strong: ({ className, ...props }: react.ComponentProps<"strong">) => react_jsx_runtime.JSX.Element;
+    em: ({ className, ...props }: react.ComponentProps<"em">) => react_jsx_runtime.JSX.Element;
+    del: ({ className, ...props }: react.ComponentProps<"del">) => react_jsx_runtime.JSX.Element;
+    ins: ({ className, ...props }: react.ComponentProps<"ins">) => react_jsx_runtime.JSX.Element;
+    code: ({ className, ...props }: react.ComponentProps<"code">) => react_jsx_runtime.JSX.Element;
+    kbd: ({ className, ...props }: react.ComponentProps<"kbd">) => react_jsx_runtime.JSX.Element;
+    mark: ({ className, ...props }: react.ComponentProps<"mark">) => react_jsx_runtime.JSX.Element;
+    sub: ({ className, ...props }: react.ComponentProps<"sub">) => react_jsx_runtime.JSX.Element;
+    sup: ({ className, ...props }: react.ComponentProps<"sup">) => react_jsx_runtime.JSX.Element;
+    abbr: ({ className, ...props }: react.ComponentProps<"abbr">) => react_jsx_runtime.JSX.Element;
+    cite: ({ className, ...props }: react.ComponentProps<"cite">) => react_jsx_runtime.JSX.Element;
+    dfn: ({ className, ...props }: react.ComponentProps<"dfn">) => react_jsx_runtime.JSX.Element;
+    time: ({ className, ...props }: react.ComponentProps<"time">) => react_jsx_runtime.JSX.Element;
+    var: ({ className, ...props }: react.ComponentProps<"var">) => react_jsx_runtime.JSX.Element;
+    samp: ({ className, ...props }: react.ComponentProps<"samp">) => react_jsx_runtime.JSX.Element;
+    output: ({ className, ...props }: react.ComponentProps<"output">) => react_jsx_runtime.JSX.Element;
+    details: ({ className, ...props }: react.ComponentProps<"details">) => react_jsx_runtime.JSX.Element;
+    summary: ({ className, ...props }: react.ComponentProps<"summary">) => react_jsx_runtime.JSX.Element;
+    iframe: ({ className, ...props }: react.ComponentProps<"iframe">) => react_jsx_runtime.JSX.Element;
+    video: ({ className, ...props }: react.ComponentProps<"video">) => react_jsx_runtime.JSX.Element;
+    audio: ({ className, ...props }: react.ComponentProps<"audio">) => react_jsx_runtime.JSX.Element;
+    pre: ({ className, children, ...props }: react.ComponentProps<"pre">) => react_jsx_runtime.JSX.Element;
+    hr: ({ className, ...props }: react.ComponentProps<"hr">) => react_jsx_runtime.JSX.Element;
+    table: ({ className, ...props }: react.ComponentProps<"table">) => react_jsx_runtime.JSX.Element;
+    thead: ({ className, ...props }: react.ComponentProps<"thead">) => react_jsx_runtime.JSX.Element;
+    tbody: ({ className, ...props }: react.ComponentProps<"tbody">) => react_jsx_runtime.JSX.Element;
+    tr: ({ className, ...props }: react.ComponentProps<"tr">) => react_jsx_runtime.JSX.Element;
+    th: ({ className, ...props }: react.ComponentProps<"th">) => react_jsx_runtime.JSX.Element;
+    td: ({ className, ...props }: react.ComponentProps<"td">) => react_jsx_runtime.JSX.Element;
+    caption: ({ className, ...props }: react.ComponentProps<"caption">) => react_jsx_runtime.JSX.Element;
+};
+
+interface SlidesPlayerProps {
+    deck: SlideDeckItem;
+    initialSlide?: number;
+    onBack: () => void;
+    onSlideChange?: (index: number) => void;
+    /** When provided, the toolbar shows a "</> MDX" toggle that calls this. */
+    onToggleSource?: () => void;
+    isSourceOpen?: boolean;
+    gateProvider?: SlideGateProvider;
+    renderCodeGate?: (props: {
+        backLabel: string;
+        onBack: () => void;
+        onUnlock: () => void;
+        subtitle: string;
+        title: string;
+        verifyCode: (code: string) => Promise<boolean>;
+    }) => React.ReactNode;
+}
+
+/**
+ * Host-agnostic presentation player. Receives a fully-loaded deck and renders
+ * the full presentation UI (stage, sidebar, toolbar, keyboard nav).
+ *
+ * The host is responsible for: page meta, content loading, gate persistence,
+ * and routing. This component only handles presentation orchestration.
+ */
+declare function SlidesPlayer({ deck, initialSlide, onBack, onSlideChange, onToggleSource, isSourceOpen, gateProvider, renderCodeGate, }: SlidesPlayerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Slide Configurator Store
+ *
+ * Global visual density config for the slides app. Phase 1 exposes a
+ * single `padding` setting that drives the default `Cell` padding and
+ * `Grid` gap. Phase 2 will extend this with color/typography fields.
+ *
+ * Persisted to localStorage so the selected padding survives reloads.
+ */
+type SlideConfigPadding = 'sm' | 'md' | 'lg';
+/**
+ * Slide-only type multiplier. Applied as a CSS variable
+ * (`--slide-type-scale`) on the slide content root; every slide
+ * primitive wraps its canvas-px sizes in `calc(Npx * var(--slide-type-scale, 1))`
+ * so nudging this knob scales every piece of slide text in lockstep.
+ *
+ * Deliberately isolated from the site-wide `--typography-scale`: the
+ * slide artboard is sovereign, tuned to exact px ratios, and should
+ * not follow global UI density changes.
+ */
+type SlideConfigTypographyScale = 'sm' | 'md' | 'lg' | 'xl';
+declare const TYPOGRAPHY_SCALE_VALUES: Record<SlideConfigTypographyScale, number>;
+interface SlideConfigState {
+    padding: SlideConfigPadding;
+    reset: () => void;
+    showInlineTalkTrack: boolean;
+    showPagination: boolean;
+    typographyScale: SlideConfigTypographyScale;
+    updateConfig: (patch: Partial<Omit<SlideConfigState, 'updateConfig' | 'reset'>>) => void;
+}
+/**
+ * Content safe-area inset in pixels. Horizontal `px` matches where folio
+ * chrome aligns on the left/right. Vertical `py` is larger than
+ * `SLIDE_FRAME_WATERMARK_PX` so the layout grid sits below/above the thin
+ * watermark band at the slide edges.
+ */
+declare const FRAME_PADDING_PX: Record<SlideConfigPadding, {
+    px: number;
+    py: number;
+}>;
+/**
+ * Folio chrome offset from the slide top/bottom edges. Tighter than
+ * `FRAME_PADDING_PX.py` so labels read as a margin watermark outside the
+ * content grid while sharing the same horizontal gutters as `px`.
+ */
+declare const SLIDE_FRAME_WATERMARK_PX: Record<SlideConfigPadding, {
+    pb: number;
+    pt: number;
+}>;
+/**
+ * Grid gap in pixels for each config padding level. Matches Tailwind's
+ * `gap-4` / `gap-6` / `gap-10` utilities which the `Grid` primitive uses via
+ * its `gapClasses` map, so the grid overlay renders the same gutters as the
+ * real slide layout.
+ */
+declare const CONFIG_GAP_PX: Record<SlideConfigPadding, number>;
+declare const useSlideConfig: zustand.UseBoundStore<Omit<zustand.StoreApi<SlideConfigState>, "setState" | "persist"> & {
+    setState(partial: SlideConfigState | Partial<SlideConfigState> | ((state: SlideConfigState) => SlideConfigState | Partial<SlideConfigState>), replace?: false | undefined): unknown;
+    setState(state: SlideConfigState | ((state: SlideConfigState) => SlideConfigState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<SlideConfigState, {
+            padding: SlideConfigPadding;
+            showPagination: boolean;
+            showInlineTalkTrack: boolean;
+            typographyScale: SlideConfigTypographyScale;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SlideConfigState) => void) => () => void;
+        onFinishHydration: (fn: (state: SlideConfigState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<SlideConfigState, {
+            padding: SlideConfigPadding;
+            showPagination: boolean;
+            showInlineTalkTrack: boolean;
+            typographyScale: SlideConfigTypographyScale;
+        }, unknown>>;
+    };
+}>;
+/**
+ * Replaces per-primitive Zustand subscriptions for `padding` with a single
+ * subscription at the slide content root. Grid and Cell read this context
+ * instead of subscribing independently — N subscriptions become 1.
+ * Default matches the store default so the fallback is always correct.
+ */
+declare const SlidePaddingContext: react.Context<SlideConfigPadding>;
+declare const useSlidePadding: () => SlideConfigPadding;
+
+type SlideRenderMode = 'presentation' | 'web-syllabus';
+/** Controls how slide components render. Default is presentation mode. */
+declare const SlideRenderModeContext: react.Context<SlideRenderMode>;
+declare function useSlideRenderMode(): SlideRenderMode;
+/** Signals to the syllabus page that a <Syllabus> block was actually rendered. */
+declare const SyllabusDetectContext: react.Context<(() => void) | null>;
+
+export { Accent, Avatar, Badge, Bleed, Body, BodyLines, Box, CONFIG_GAP_PX, Cell, Center, ClosingSlide, Collage, ColorBlock, Columns, CoverSlide, Demo, Display, Divider, FRAME_PADDING_PX, FigureMark, Fill, FullBleedCoverSlide, FullBleedGallery, FullBleedSlide, Grid, Headline, HeroBento, Highlight, Icon, Image, ImageDuoSlide, ImageSlide, ImageTrioSlide, InlineCode, Item, Label, List, Live, MediaTrio, Mono, Position, Quote, QuoteSlide, QuoteWithMedia, Reveal, Row, SLIDE_FRAME_WATERMARK_PX, Section, SectionMarker, SectionSlide, SlideCodeBlock, type SlideConfigPadding, type SlideConfigTypographyScale, SlideDeckItem, type SlideGateProvider, SlideLayout, SlidePaddingContext, type SlideRenderMode, SlideRenderModeContext, SlidesPlayer, type SlidesPlayerProps, Spacer, Split, SplitHalf, SplitWithStat, Stack, StatBento, StatementSlide, Subtitle, Syllabus, SyllabusDetectContext, TYPOGRAPHY_SCALE_VALUES, TalkTrack, TextLead, TimelineBento, Title, Trio, Video, slideMdxComponents, syllabusMdxComponents, useSlideConfig, useSlidePadding, useSlideRenderMode };