import { ComponentType, ReactNode, AnchorHTMLAttributes, CSSProperties, MouseEvent } from 'react';

type ComponentIdentifier = 'r-text' | 'something-else' | 'cloudinary-advanced-image' | 'r-video' | 'r-icon' | 'r-button' | 'r-divider' | 'r-embed' | 'r-list' | 'r-accordion' | 'r-mount';
declare const ComponentIdentifiers: Record<string, ComponentIdentifier>;

type AttributeListForComponentTypes = {
    [key: string]: string[];
};
type ComponentNameToModifyAttribute = {
    [key: string]: string;
};
type DeviceTypeBasedAttributeValues = {
    phone?: any;
    tablet?: any;
    desktop?: any;
    all?: any;
};
type AttributeEditModeConfig = {
    name: string;
    /** Optional title shown above this attribute's editor in the modify panel. */
    heading?: string;
    /** Optional supporting text under the heading. */
    subHeading?: string;
    defaultValues?: DeviceTypeBasedAttributeValues;
    /**
     * When true, the Modify drawer does not show an editor for this attribute.
     * The attribute still exists: defaults, prefills, and render still use it.
     * RuleCMS also omits these from user-facing documentation.
     */
    hiddenToUser?: boolean;
};
type DefaultAttributeValue = {
    name: string;
    defaultValues: DeviceTypeBasedAttributeValues;
};
type PageViewType = 'Preview' | 'Compose' | 'RenderedPage';
/**
 * Extra props the embedding application supplied for one component instance,
 * addressed by column id through `RuleCMSWidget`'s `componentProps`. widget-react
 * only delivers the bag — it defines no keys — so each component documents which
 * ones it honours (`r-button` reads `onClick`).
 *
 * Absent far more often than present: the composer never sends it, and neither
 * does any host that did not address this particular instance.
 */
type WidgetInstanceProps = {
    [key: string]: any;
};
type RenderedOrFunctionalComponentEntry = JSX.Element | ((props: {
    componentAttributes?: {
        [key: string]: any;
    };
    pageViewType: PageViewType;
    styleProps: {
        [key: string]: any;
    } | undefined;
    /** Host-app classes for this column, when the renderer decided this card carries them. */
    className?: string;
    /** Host-app props for this instance; see WidgetInstanceProps. */
    widgetInstanceProps?: WidgetInstanceProps;
    /**
     * Host-supplied map of mount name → React component. Only `r-mount`
     * reads it. Absent in the composer, and absent whenever the host
     * passed no `mounts` on `RuleCMSWidget`.
     */
    mounts?: {
        [name: string]: ComponentType<any>;
    };
    /**
     * Nested content the render path resolved for this instance, for the
     * components that are containers rather than leaves — `r-accordion`'s
     * disclosure body is the first. Absent on every render path that exists
     * today: the renderer instantiates components as leaves, and authoring a
     * subtree into a component slot is unshipped platform work. A component
     * that reads it must render identically without it.
     */
    children?: ReactNode;
}) => JSX.Element);
/**
 * What a component knows about the render it is being asked about, when
 * widget-react calls `resolveNoContainer` or `resolveRendersOwnElement`. An
 * object so the contract can grow without breaking existing resolvers.
 */
type NoContainerResolverContext = {
    /** The component instance's attribute values (resolved for the active device). */
    componentAttributes?: {
        [key: string]: any;
    };
    /** The column styles widget-react is about to apply, one way or the other. */
    styleProps?: {
        [key: string]: any;
    } | undefined;
};
/**
 * Answers, for one specific render, "can this component carry the column's box
 * styles itself?" — `false` — or "must widget-react put them on a wrapper
 * div?" — `true`. Same meaning as the static `noContainer`, decided per render.
 *
 * Every component in this library exposes one; see
 * `__docs__/PATTERNS_dynamic_no_container.md`.
 */
type ResolveNoContainer = (context: NoContainerResolverContext) => boolean;
/**
 * Does this render produce a root element that can carry a class attribute?
 * Unlike `resolveNoContainer` this is about the existence of an element, not
 * about whether it can hold box styles: an inline `<span>` answers `true`
 * here and `true` to `resolveNoContainer`.
 *
 * A card whose resolver can return `true` MUST apply the `className` it
 * receives to the element it renders. See
 * `__docs__/PATTERNS_dynamic_no_container.md`.
 */
type ResolveRendersOwnElement = (context: NoContainerResolverContext) => boolean;
type DisplayCardEntry = {
    id: string;
    card: RenderedOrFunctionalComponentEntry;
    defaultAttributeValues: DefaultAttributeValue[];
    attributeEditModeConfigs: AttributeEditModeConfig[];
    /**
     * Per-render answer to whether column dimension styles need a wrapper div.
     * widget-react calls this and ignores `noContainer` when it is present.
     */
    resolveNoContainer?: ResolveNoContainer;
    /**
     * Static fallback used only by widget-react versions that predate
     * `resolveNoContainer`. When true, column dimension styles are applied via a
     * wrapper div rather than passed as styleProps to the component.
     */
    noContainer?: boolean;
    /**
     * Per-render answer to whether this card's own root element can carry a
     * `className`. A card whose resolver can return `true` MUST apply the
     * `className` it receives to the element it renders.
     */
    resolveRendersOwnElement?: ResolveRendersOwnElement;
};
type RenderCardEntry = {
    id: string;
    card: RenderedOrFunctionalComponentEntry;
    defaultAttributeValues: DefaultAttributeValue[];
    resolveNoContainer?: ResolveNoContainer;
    noContainer?: boolean;
    resolveRendersOwnElement?: ResolveRendersOwnElement;
};
type ComponentMetadata = {
    defaultAttributeValues: DefaultAttributeValue[];
    attributeEditModeConfigs: AttributeEditModeConfig[];
};
type ComponentMetadataForEditing = {
    attributeListForComponentTypes: AttributeListForComponentTypes;
    componentNameToModifyAttribute: ComponentNameToModifyAttribute;
    componentMetadata: Record<string, ComponentMetadata>;
};
/**
 * Structured palette-card data for the composer (mirrors widget-react's
 * EditorPreviewEntry). Libraries provide data only; the composer owns the
 * card template so palette cards always render consistently.
 */
type EditorPreviewCardEntry = {
    id: string;
    /** Compact glyph for the palette card: an emoji string or small JSX. */
    icon: ReactNode;
    /** Short name shown under the icon, e.g. "Text", "Image". */
    label: string;
};
type CardEntry = DisplayCardEntry | EditorPreviewCardEntry;
type Card = {
    title: string;
    entries: CardEntry[] | DisplayCardEntry[];
};
type CardGroup = {
    title: string;
    cards: Card[];
    showInitially?: boolean;
};
/**
 * Editor-preview card groups hold ONLY structured palette entries. These
 * mirror widget-react's LibraryCard / LibraryCardGroup so the editor surface
 * stays assignable to the ComponentLibraryModule contract.
 */
type EditorPreviewCard = {
    title: string;
    entries: EditorPreviewCardEntry[];
};
type EditorPreviewCardGroup = {
    title: string;
    cards: EditorPreviewCard[];
    showInitially?: boolean;
};
interface SourceComponentsPlugin {
    components: Record<string, RenderCardEntry>;
}
/** Lucide `__iconNode` geometry: [tagName, attributes][]. Plain JSON. */
type IconNode = [string, Record<string, string>][];
/**
 * What an icon attribute stores. Geometry is stamped when the author picks
 * the icon, not at publish, so the render path never needs the icon registry
 * and every surface — composer, dev, staging, production — draws from the
 * same value. `name` is kept so a later sync can re-resolve stale geometry.
 */
type IconAttributeValue = {
    name: string;
    iconNode: IconNode;
};
type PreviewComponents = Record<string, EditorPreviewCardEntry>;

/**
 * Returns the source components plugin with a lookup map of render components.
 * Results are cached after the first call.
 */
declare const getSourceComponentsPlugin: () => {
    components: Record<string, RenderCardEntry>;
};

declare const getComponentMetadataForEditing: () => ComponentMetadataForEditing;

/**
 * Returns the preview card groups for drag and drop functionality.
 * This replaces the dragDropPreviewCardGroups export.
 */
declare const getPreviewCardGroups: () => EditorPreviewCardGroup[];
/**
 * Returns a lookup map of preview components by entry ID.
 * Results are cached after the first call.
 */
declare const getPreviewComponents: () => PreviewComponents;

/**
 * ComponentLibraryModule conformance (the @rulecms/widget-react contract).
 *
 * This package is the DEFAULT component library. It conforms to the contract
 * STRUCTURALLY — it has no dependency on @rulecms/widget-react (the
 * devDependency-only type-conformance test in
 * __tests__/contract-conformance.test.ts guarantees the shape). Consumers
 * register it, e.g.:
 *
 *   libraries: { default: () => import('@rulecms/source-components-react') }
 *
 * or statically import the module for SSR pages.
 */
declare const manifest: {
    id: string;
    version: string;
    reactPeerRange: string;
};
/** The render surface: component type → renderable entry. */
declare const components: Record<string, RenderCardEntry>;
/**
 * Optional `ComponentLibraryModule.stylesheet`. widget-react injects this
 * once per library as an SSR `<style>` tag. Button hover / focus / active
 * plus accordion open/close motion and the custom chevron.
 */
declare const stylesheet: string;
/** The editor surface: palette + attribute metadata for the RuleCMS composer. */
declare const editor: {
    previewComponents: PreviewComponents;
    previewCardGroups: EditorPreviewCardGroup[];
    componentMetadata: ComponentMetadataForEditing;
};

/**
 * HTML tags the RText component is allowed to enclose its text content in,
 * ordered from most common to least common.
 *
 * Every entry is a standard HTML element that can directly contain text
 * without changing how that text behaves. Deliberately excluded:
 * - Interactive / behavior-changing tags: a, button, label, summary, option,
 *   textarea, select, details, dialog
 * - Void elements that cannot enclose text: br, wbr, hr, img, input
 * - Tags only valid inside a specific parent: li, dt, dd, td, th, caption,
 *   legend, figcaption, rt, rp, optgroup
 * - Raw-text / metadata tags: script, style, title, template
 * - Live-region / form-output tags that alter assistive-technology behavior:
 *   output
 */
declare const ENCLOSING_TAGS: readonly ["p", "div", "span", "h1", "h2", "h3", "h4", "h5", "h6", "strong", "em", "b", "i", "u", "small", "mark", "pre", "code", "blockquote", "q", "sub", "sup", "s", "del", "ins", "cite", "abbr", "dfn", "kbd", "samp", "var", "time", "data", "address", "bdi", "bdo", "figure", "article", "section", "aside", "header", "footer", "main", "nav"];
type EnclosingTag = (typeof ENCLOSING_TAGS)[number];
/**
 * The tags above whose default CSS display is block-level.
 *
 * Box styles — margin, padding, width, border — behave as authored on these
 * elements, so RText can carry the column's styles on the tag itself and
 * needs no wrapper div (see `resolve-no-container.ts`).
 */
declare const BLOCK_ENCLOSING_TAGS: readonly EnclosingTag[];
/**
 * The tags above that default to `display: inline`, where vertical
 * margin/padding and width/height are ignored by the layout engine. Column
 * box styles must go on a wrapper element instead of on the tag.
 *
 * Kept as an explicit list rather than derived from BLOCK_ENCLOSING_TAGS so
 * adding a tag to ENCLOSING_TAGS forces a deliberate block-or-inline call;
 * the coverage test in `__tests__/enclosing-tags.test.ts` fails otherwise.
 */
declare const INLINE_ENCLOSING_TAGS: readonly EnclosingTag[];
/**
 * Runtime guard for values arriving through componentAttributes (untyped
 * editor-authored data). Unknown values are rejected so a bad persisted value
 * can never render an unexpected element.
 */
declare function isEnclosingTag(value: unknown): value is EnclosingTag;
/**
 * True when the tag renders as a block-level box. Unknown values count as
 * non-block: the safe answer, because it routes box styles to a wrapper
 * element where they are guaranteed to apply.
 */
declare function isBlockEnclosingTag(value: unknown): boolean;

/**
 * One link entry as the composer stores it. Shared by every component that
 * links (text markers today, icons next), so nothing here knows about text.
 */
type LinkItem = {
    href?: string;
    /** Author-facing name for identifying the entry in the composer. Never rendered. */
    label?: string;
    target?: string;
    rel?: string;
    title?: string;
    ariaLabel?: string;
    /** `true` = bare download attribute; string = suggested filename. */
    download?: string | boolean;
    hreflang?: string;
    referrerPolicy?: string;
};

/**
 * Schemes that can execute or smuggle a payload. Mirrors the denylist in
 * RuleCMS `text-safety/validate-text-content.ts`; the two must stay in step,
 * because that one warns at save and this one is the guarantee at render.
 */
declare const REJECTED_HREF_SCHEMES: readonly string[];
/**
 * Whether a value is safe to put in an `href`.
 *
 * A denylist, not an allowlist. Customers link with git and ssh URLs, mobile
 * deep links, `mailto:`, `tel:`, `sms:`, custom app schemes, protocol-relative
 * `//host/path`, and bare `/path`, `#anchor`, `?q=1`, `./rel` — all of which
 * are accepted. A host is not required and neither is http/https. Only the
 * schemes that turn a link into code or an opaque payload are turned away.
 *
 * Rejection happens at render, never at save: the composer may use this for a
 * non-blocking warning, but stored content is not trusted content.
 */
declare function isSafeHref(value: unknown): boolean;

/**
 * The props an `<a>` receives, picked from React's own anchor attributes so
 * the object can be spread onto an element without a cast at the call site.
 * `href` is required: an anchor without one has no link role, is not
 * focusable, and is invisible to assistive technology while still looking
 * like a link.
 */
type AnchorAttributes = Pick<AnchorHTMLAttributes<HTMLAnchorElement>, 'target' | 'rel' | 'title' | 'aria-label' | 'download' | 'hrefLang' | 'referrerPolicy'> & {
    href: string;
};
/**
 * Turns a stored link entry into anchor props, or `undefined` when the entry
 * cannot produce a usable anchor — missing, cleared, blank `href`, or an
 * `href` the safety check rejects. Callers render the plain text in that case.
 *
 * Knows nothing about text, markers, or any one component: this is the piece
 * every linking component shares.
 */
declare function resolveLinkAttributes(item: LinkItem | undefined): AnchorAttributes | undefined;

type InlineTextRun = {
    kind: 'text';
    text: string;
};
type InlineLinkRun = {
    kind: 'link';
    index: number;
    text: string;
};
type InlineRun = InlineTextRun | InlineLinkRun;
/**
 * @deprecated Use `parseInlineMarkers` from `shared/inline-markup`.
 *
 * The link-only view of the grammar, kept because it is public API. Markers now
 * also carry marks (`{b|word}`) and line breaks (`{br|}`), which this shape
 * cannot express, so anything that is not a linked span is flattened into text:
 * marked spans contribute their words without the marks, and a break
 * contributes a newline. That is exactly what a caller stripping markers out of
 * a string wants — `resolveAccordionSummary` is the one in this package — and
 * it is wrong for anything that means to render them.
 *
 * Adjacent text is merged, so text with no linked spans is still one run.
 */
declare function parseInlineLinkMarkers(value: string): InlineRun[];

/**
 * One styling entry as the composer stores it. Shared by every component that
 * renders inline markup, so nothing here knows about text.
 *
 * Two fields rather than one because they fail differently. Class names are
 * names of rules the customer's own CSS owns, and this library can neither see
 * them nor be sure they exist. Declarations are CSS this library has to
 * understand well enough to hand to a platform that wants an object rather
 * than a string.
 */
type SpanStyleItem = {
    /** Author-facing name for identifying the entry in the composer. Never rendered. */
    label?: string;
    /** Whitespace-separated class names, exactly as the author typed them. */
    classNames?: string;
    /** A CSS declaration list — `color: #c00; font-weight: 600` — without braces. */
    declarations?: string;
};
/**
 * Runtime guard for entries arriving through componentAttributes (untyped,
 * editor-authored data).
 *
 * Only object shape is checked, for the same reason as `isLinkItem`: one bad
 * field must cost that field rather than the whole entry, so per-field
 * validation belongs to `resolveSpanStyleAttributes` where each value is turned
 * into something a platform can apply.
 */
declare function isSpanStyleItem(value: unknown): value is SpanStyleItem;
/**
 * True for a cleared slot. Clearing an entry stores `{}` rather than removing
 * the array element, because marker indexes are 1-based positions: dropping an
 * element would silently repoint every later marker.
 *
 * A `label` alone is a cleared slot. It is the author's note to themselves
 * about which entry this is, and an entry that only has a name applies nothing.
 */
declare function isEmptySpanStyleItem(item: unknown): boolean;
/**
 * The entry a `{.n|…}` marker points at, by 1-based position. Tolerant of bad
 * data on every axis — a non-array list, a fractional or out-of-range index, a
 * hole in the array — because none of it may throw during a render.
 */
declare function getSpanStyleItemAt(spanStyles: unknown, oneBasedIndex: number): SpanStyleItem | undefined;

/**
 * A class name is a *selector* into CSS the customer already ships. This
 * library cannot see those rules, so it cannot validate a name against
 * anything — the only useful question is whether the token could damage the
 * document it lands in, and the answer is almost always no: every renderer sets
 * `class` through a DOM property or a framework binding, never by pasting into
 * markup.
 *
 * So the filter is deliberately permissive. Utility frameworks make class names
 * that look like code — `md:hover:text-lg`, `w-1/2`, `text-[#c00]`,
 * `[&>svg]:size-4` — and a tidier-looking allowlist would reject those and be
 * read as a bug.
 */
/**
 * The `class` value for a styling entry, or `undefined` when it has none worth
 * setting.
 *
 * Duplicates collapse and order is the author's. One bad token costs that
 * token: the rest of a mostly-fine list still applies, which is the same
 * per-field tolerance `resolveLinkAttributes` gives a link entry.
 */
declare function resolveClassNames(value: unknown): string | undefined;

/**
 * One CSS declaration, normalized: a property name this module accepted and the
 * value it accepted for it, both trimmed and with nothing dropped in between.
 */
type StyleDeclaration = {
    property: string;
    value: string;
};
/**
 * An authored CSS declaration list to the declarations that will be applied.
 *
 * The list is a denylist over values and an allowlist over property names,
 * which is the same shape as `text-safety/validate-text-content.ts` in the
 * composer and for the same reason: a person writing `color: #c00` should never
 * have to think about this function, while the handful of constructs that turn
 * a declaration into a request or a script are named and refused.
 *
 * A rejected declaration costs only itself. `color: red; behavior: url(x)`
 * still sets the colour, because dropping the whole entry over one bad
 * declaration would lose work the author can see is fine.
 */
declare function parseStyleDeclarations(value: unknown): StyleDeclaration[];
/**
 * Declarations back to a CSS string, for the places that want a `style`
 * attribute rather than an object — the composer's editing surface, and the
 * ports whose templates bind a string.
 */
declare function formatStyleDeclarations(declarations: readonly StyleDeclaration[]): string;

/** The props a styled run's element receives, ready to spread. */
type SpanStyleAttributes = {
    className?: string;
    style?: CSSProperties;
};
/**
 * Turns a stored styling entry into element props, or `undefined` when the
 * entry cannot produce any — missing, cleared, or holding nothing that survived
 * the checks in `resolveClassNames` and `parseStyleDeclarations`. Callers render
 * the plain text in that case, exactly as they do for a link that resolves to
 * nothing.
 *
 * Knows nothing about text, markers, or any one component: this is the piece
 * every component rendering inline markup shares.
 */
declare function resolveSpanStyleAttributes(item: SpanStyleItem | undefined): SpanStyleAttributes | undefined;

/**
 * The formatting one marker can carry. Independent flags rather than a union,
 * because a span can be bold and italic and struck at once.
 */
type InlineMarks = {
    bold: boolean;
    italic: boolean;
    strike: boolean;
};
type MarkupTextRun = {
    kind: 'text';
    text: string;
};
type MarkupSpanRun = {
    kind: 'span';
    text: string;
    /**
     * 1-based position in the link list, when the marker carried an index. A
     * span can be marked without linking (`{b|word}`) and linked without marks
     * (`{1|word}`), so this is optional and the marks are always present.
     */
    index?: number;
    /**
     * 1-based position in the styling list, when the marker carried a `.index`.
     * Independent of everything else on the span: `{.1|word}` is styled only,
     * `{b2.1|word}` is bold, linked, and styled.
     */
    styleIndex?: number;
    marks: InlineMarks;
};
type MarkupBreakRun = {
    kind: 'break';
};
type MarkupRun = MarkupTextRun | MarkupSpanRun | MarkupBreakRun;
/**
 * Splits authored text into plain runs, marked/linked spans, and line breaks.
 *
 * The grammar, and everything it deliberately leaves as literal text, is
 * specified in `rulecms/__docs__/__ARCHITECTURE__/INLINE_MARKUP_ARCHITECTURE.md`.
 * In short: a marker is `{`, then lowercase mark letters, then a link index,
 * then `.` and a styling index, then `|`, then its text, then `}`. At least one
 * of those three must be present, and everything that does not match that shape
 * stays verbatim — `{name}`, `{99}`, a lone `{`, JSON fragments, an unterminated
 * marker, an unknown mark letter, and empty span text.
 *
 * Indexes are 1-based and normalize through a base-10 parse, so `{01|x}` and
 * `{1|x}` point at the same entry. Resolving an index to an entry is the
 * caller's job; this stays pure and free of React.
 */
declare function parseInlineMarkers(value: string): MarkupRun[];

/** One run as authored text. */
declare function formatInlineMarker(run: MarkupRun): string;
/**
 * Runs back to the string they were parsed from.
 *
 * This is the writer half of the grammar, and it lives beside the parser so
 * that an editor never hand-assembles marker syntax. `parseInlineMarkers` and
 * this function are inverses for anything the parser produces, which is what
 * lets a rich editor round-trip through source mode without rewriting content
 * the author did not touch.
 */
declare function serializeInlineMarkers(runs: readonly MarkupRun[]): string;

/**
 * Renders authored text with its `{…|…}` markers resolved — marks as elements,
 * indexes against a link list, `.n` against a styling list, `{br|}` as a line
 * break.
 *
 * Every element is phrasing content and sits inside whatever tag the caller
 * wraps this in; nothing here ever becomes the caller's root element, so the
 * wrapper decisions in `MINIMAL_MARKUP_ARCHITECTURE.md` are unaffected.
 *
 * When no run needs an element the return value is a plain string: the same
 * React output as text with no markup support at all. A span whose link or
 * styling entry is missing, cleared, or rejected contributes its text, so a
 * broken reference degrades to prose rather than leaving a `{1|…}` shell,
 * emitting an `<a>` without an `href`, or wrapping words in a `<span>` that
 * carries nothing.
 */
declare function renderInlineMarkup(text: string, links: unknown, spanStyles?: unknown): ReactNode;

/**
 * The preset vocabulary for `r-button`.
 *
 * Three independent axes rather than one flat list of named buttons: five
 * variants times four tones times five sizes is a hundred looks from three
 * short tables, and an author picks each axis without us having to have
 * anticipated the combination.
 *
 * Every preset name here is persisted customer data, exactly like an icon
 * name. A name that has shipped is never deleted or repurposed — add a new
 * one and alias the old one, or published pages change appearance on upgrade.
 */
/** How the button is filled and bordered. */
declare const BUTTON_VARIANTS: readonly ["solid", "soft", "outline", "ghost", "link"];
/** Which colour family the variant draws from. */
declare const BUTTON_TONES: readonly ["brand", "neutral", "danger", "success"];
/** Type scale, padding and control height, smallest to largest. */
declare const BUTTON_SIZES: readonly ["xs", "sm", "md", "lg", "xl"];
type ButtonVariant = (typeof BUTTON_VARIANTS)[number];
type ButtonTone = (typeof BUTTON_TONES)[number];
type ButtonSize = (typeof BUTTON_SIZES)[number];
type ButtonPreset = {
    variant: ButtonVariant;
    tone: ButtonTone;
    size: ButtonSize;
};
/**
 * What an unconfigured button looks like. Dropping the component on a canvas
 * and touching nothing must already produce something shippable.
 */
declare const DEFAULT_BUTTON_PRESET: ButtonPreset;
declare const isButtonVariant: (value: unknown) => value is ButtonVariant;
declare const isButtonTone: (value: unknown) => value is ButtonTone;
declare const isButtonSize: (value: unknown) => value is ButtonSize;
/**
 * The colour slots a tone fills.
 *
 * `hover` / `active` / `softHover` are consumed by the library stylesheet
 * (`button-library-stylesheet.ts`) via the per-instance fill slots. Changing
 * a tone here is still a palette change, not a delivery change.
 */
type TonePalette = {
    /** Solid fill, and the text colour for outline / ghost / link. */
    base: string;
    hover: string;
    active: string;
    /** Text placed on top of `base`. */
    contrast: string;
    /** Outline border, kept separate so neutral can be lighter than its text. */
    border: string;
    /** Tinted fill for the soft variant. */
    soft: string;
    softHover: string;
    /** Text placed on top of `soft`. */
    softContrast: string;
};
/**
 * Defaults only. Every one of these reaches the page as the fallback half of a
 * `var(--rulecms-button-…, default)`, so a customer rebrands every button on
 * their site by defining the custom property once, with no per-button edits
 * and no composer access. See `button-css-variables.ts`.
 */
declare const TONE_PALETTES: Record<ButtonTone, TonePalette>;
type SizeScale = {
    fontSize: string;
    /** Floor for the control height. WCAG 2.2 AA wants at least 24px. */
    minHeight: string;
    paddingInline: string;
    paddingBlock: string;
    borderRadius: string;
    /** Space between an icon and the label. */
    gap: string;
};
declare const SIZE_SCALES: Record<ButtonSize, SizeScale>;

/**
 * Turns whatever the composer stored into a complete preset.
 *
 * Tolerant on every axis independently: a value saved by a newer composer, a
 * half-written object, or an outright wrong type costs that one axis and
 * nothing else. A published page must never fail to render a button because
 * one field went stale.
 */
declare function resolveButtonPreset(value: unknown): ButtonPreset;

/**
 * The preset's contribution to the button's inline style, including resting
 * colours as real CSS properties. The composer picker uses this so a swatch
 * looks right without the library stylesheet.
 *
 * Callers spread column `styleProps` *after* this, which is what makes the
 * preset a set of defaults rather than a set of rules: anything the author
 * touched in Column Styles lands later in the object and wins.
 */
declare function buildButtonPresetStyles(preset: ButtonPreset): CSSProperties;
/**
 * What `RButton` puts on the element. Same as the picker styles, minus the
 * colour properties the library stylesheet owns — those stay on the element
 * only as custom properties so `:hover` can change them.
 */
declare function buildButtonRenderStyles(preset: ButtonPreset): CSSProperties;
/**
 * Column styles still win on everything except `backgroundColor`, which is
 * remapped onto the fill slots so hover/active follow the authored colour
 * instead of the preset's blue-family hover.
 */
declare function applyButtonColumnStyles(styleProps?: CSSProperties | {
    [key: string]: unknown;
}): CSSProperties;
/** Applied on top when the button is disabled, before column styles. */
declare const disabledStyles: CSSProperties;

/**
 * SSR-safe rules for `r-button` pseudo-classes.
 *
 * widget-react injects this once per library via `ComponentLibraryModule.stylesheet`.
 * The sheet owns `background-color`, `color`, and `border-color` so `:hover`
 * can win — those properties on an inline style beat any stylesheet rule.
 * Resting values arrive as `--rulecms-button-fill` / `-ink` / `-border` on
 * the element. A column background override rewrites the fill slots and
 * derives hover/active with `color-mix`, so an arbitrary red does not keep
 * the brand-blue hover.
 *
 * Outline is never cleared: the designed ring is a `box-shadow` on
 * `:focus-visible`, on top of the browser's native focus outline.
 */
declare const BUTTON_LIBRARY_STYLESHEET: string;

/**
 * SSR-safe rules for `r-accordion` motion and the custom chevron.
 *
 * widget-react injects this once per library via `ComponentLibraryModule.stylesheet`.
 * Open/close height and opacity cannot be inline styles: they key off `[open]`
 * and `::details-content`. The chevron rotate is the same. Hiding the UA
 * triangle belongs here too — `summary::marker` is a pseudo-element.
 *
 * Browsers that do not support `::details-content` / `interpolate-size` still
 * open and close; they just snap. The chevron and the disclosure keep working.
 */
declare const ACCORDION_LIBRARY_STYLESHEET: string;

/**
 * Every colour a preset emits goes out as `var(--rulecms-button-…, default)`.
 *
 * This is the whole white-label story for buttons. A customer who sets
 *
 *   :root { --rulecms-button-brand: #c8102e; }
 *
 * once in their own stylesheet rebrands every RuleCMS button on the site,
 * without touching a widget, without composer access, and without us shipping
 * a theme provider or a design system to their page. Authors who want one
 * button to differ still override it per column, as before.
 */
declare const BUTTON_CSS_VARIABLE_PREFIX = "--rulecms-button";
/**
 * Per-instance slots the library stylesheet reads. The preset writes these on
 * the element; a column `backgroundColor` rewrite and a future widget-level
 * token both land on the same names.
 */
declare const BUTTON_FILL_VARIABLE = "--rulecms-button-fill";
declare const BUTTON_FILL_HOVER_VARIABLE = "--rulecms-button-fill-hover";
declare const BUTTON_FILL_ACTIVE_VARIABLE = "--rulecms-button-fill-active";
declare const BUTTON_INK_VARIABLE = "--rulecms-button-ink";
declare const BUTTON_INK_HOVER_VARIABLE = "--rulecms-button-ink-hover";
declare const BUTTON_BORDER_VARIABLE = "--rulecms-button-border";
declare const BUTTON_RING_VARIABLE = "--rulecms-button-ring";
/**
 * The suffixes on a tone's custom properties. `''` is the tone's main colour,
 * e.g. `--rulecms-button-brand`.
 */
type ToneVariableSlot = '' | 'hover' | 'active' | 'contrast' | 'border' | 'soft' | 'soft-hover' | 'soft-contrast';
declare const toneCssVariable: (tone: ButtonTone, slot?: ToneVariableSlot) => string;

/** What a freshly dropped button says before the author types anything. */
declare const DEFAULT_BUTTON_LABEL = "Button";
declare const ICON_POSITIONS: readonly ["leading", "trailing"];
type IconPosition = (typeof ICON_POSITIONS)[number];
declare const DEFAULT_ICON_POSITION: IconPosition;

/** The only key `r-button` reads out of the host's per-instance props. */
declare const BUTTON_CLICK_HANDLER_PROP = "onClick";
type ButtonClickHandler = (event: MouseEvent<HTMLButtonElement | HTMLAnchorElement>) => void;

declare const LIST_KINDS: readonly ["unordered", "ordered"];
type ListKind = (typeof LIST_KINDS)[number];
declare const DEFAULT_LIST_KIND: ListKind;
/**
 * `list-style-type` values worth offering. Every entry is valid CSS on both
 * `<ul>` and `<ol>`, so the marker survives the author switching kind rather
 * than resetting. Unset means the browser default — disc for unordered,
 * decimal for ordered — which is why there is no default constant here: not
 * setting the property at all is the default.
 */
declare const LIST_MARKERS: readonly ["disc", "circle", "square", "decimal", "lower-alpha", "upper-alpha", "lower-roman", "upper-roman", "none"];
type ListMarker = (typeof LIST_MARKERS)[number];

/**
 * Heading levels the summary can be given, plus `none` for the common case.
 *
 * `h1` is deliberately absent: the page already has one, and ten disclosures
 * down the page would otherwise offer ten ways to compete with it. Levels
 * start at `h2` because a summary sits under whatever heading introduces the
 * section it is in.
 *
 * `none` is a real option rather than an unset value so the picker always has
 * a definite selection — there is no way to clear a select back to nothing —
 * and it is the default because a disclosure is not automatically part of the
 * document outline.
 */
declare const ACCORDION_HEADING_LEVELS: readonly ["none", "h2", "h3", "h4", "h5", "h6"];
type AccordionHeadingLevel = (typeof ACCORDION_HEADING_LEVELS)[number];
declare const DEFAULT_ACCORDION_HEADING_LEVEL: AccordionHeadingLevel;

/**
 * The attribute names `r-mount` reads.
 *
 * Two, and that is the whole of it: which host component to render, and the
 * props the author filled in for it. The host application supplies the actual
 * React component through `RuleCMSWidget`'s `mounts` map. This library never
 * imports customer code.
 *
 * There is no hide attribute. Hide lives on the column, like every other
 * component. There is no children slot — authoring a subtree into a card is
 * unshipped platform work, and a mount is a leaf that *is* the component.
 */
declare const MOUNT_NAME_ATTRIBUTE = "mount-name-3-resolutions";
declare const MOUNT_PROPS_ATTRIBUTE = "mount-props-3-resolutions";
declare const MOUNT_PROP_TYPES: readonly ["string", "number", "boolean", "json"];
type MountPropType = (typeof MOUNT_PROP_TYPES)[number];
type MountPropRow = {
    key: string;
    type: MountPropType;
    value: string;
};
type MountsMap = {
    [name: string]: ComponentType<any>;
};
/**
 * A name the host can register. Starts with a letter so it cannot collide
 * with a number-looking key or a CSS custom property, then letters, digits,
 * hyphens and underscores only. The same grammar the composer field accepts.
 */
declare const MOUNT_NAME_PATTERN: RegExp;
declare const isMountPropType: (value: unknown) => value is MountPropType;
declare const isAllowedMountName: (value: unknown) => value is string;
/**
 * Keys a marketer-authored row must never become. `on*` would turn a typed
 * string into an event handler; `dangerouslySetInnerHTML` would inject HTML;
 * the rest are reserved by React or by the prototype chain.
 */
declare const isForbiddenMountPropKey: (key: string) => boolean;
declare const resolveMountName: (componentAttributes?: {
    [key: string]: unknown;
}) => string;
/**
 * Turns the authored rows into a props object for the host component.
 * Unknown shapes, forbidden keys, and values that fail their declared type
 * are dropped rather than guessed.
 */
declare const resolveMountProps: (componentAttributes?: {
    [key: string]: unknown;
}) => {
    [key: string]: unknown;
};

/**
 * Shapes rather than dimensions. An iframe has no intrinsic size to preserve,
 * so something has to state the proportion or the box collapses to the
 * browser's 300×150 default — and a ratio does it without the author having to
 * work out a height for every screen width.
 *
 * `none` is the escape hatch for content that has no natural shape, a booking
 * form being the obvious one. It is the only value that hands sizing back to
 * the column's Height setting.
 */
declare const EMBED_ASPECT_RATIOS: readonly ["16:9", "4:3", "1:1", "9:16", "21:9", "none"];
type EmbedAspectRatio = (typeof EMBED_ASPECT_RATIOS)[number];
/**
 * What an unshaped embed is tall by default. Applied by the component rather
 * than seeded onto the column, so the column's Height still overrides it and
 * clearing that returns the embed to a height that works — the same
 * "unset means the component's default" arrangement `r-button` uses for its
 * preset. Sized for a Calendly month view, which is the content that needs it.
 */
declare const EMBED_UNSHAPED_HEIGHT = "700px";
declare const EMBED_LOADING_VALUES: readonly ["lazy", "eager"];
type EmbedLoading = (typeof EMBED_LOADING_VALUES)[number];
/**
 * Lazy by default. An embed is a whole third-party document — for YouTube,
 * comfortably more than the rest of the page around it — and most of them sit
 * below the fold. `eager` exists for the ones that do not.
 */
declare const DEFAULT_EMBED_LOADING: EmbedLoading;

/**
 * The providers `r-embed` will frame, and the only thing standing between an
 * author's paste box and an iframe on a customer's page.
 *
 * This is an allowlist, not a denylist — the opposite of `is-safe-href`, and
 * deliberately so. A link navigates away; an iframe runs a third party's
 * document inside the page the widget was dropped on, with whatever
 * permissions the embedding page grants it. There is no set of dangerous
 * schemes to enumerate here, because everything that is not a provider we have
 * looked at is dangerous.
 *
 * Two consequences worth stating outright:
 *
 * **The `src` is rebuilt, never passed through.** A provider takes the URL the
 * author pasted, extracts the one or two identifiers it recognises, and
 * composes a fresh URL from a hardcoded origin. Nothing an author types
 * reaches the `src` except an id that matched a narrow pattern. A watch page,
 * a share link and an already-embeddable URL all converge on the same output.
 *
 * **The frame's privileges are the provider's, not the author's.** `sandbox`
 * and `allow` are properties of the entry below, not attributes an author can
 * set, which is also why this component has no pass-through convention. A
 * `pass-through-embed-attributes-sandbox` key would hand away every guarantee
 * on this page for the sake of consistency with `r-video`.
 */

type EmbedProviderId = 'youtube' | 'vimeo' | 'google-maps' | 'calendly';
type EmbedProvider = {
    id: EmbedProviderId;
    /** Provider name for the composer and for the docs. */
    label: string;
    /**
     * Hosts an author may paste, already normalised (lowercase, no `www.`).
     * Matching one of these only earns the URL a look at `toEmbedUrl`.
     */
    inputHosts: readonly string[];
    /**
     * Builds the URL that actually goes in the `src`, or returns `null` when the
     * URL is on the right host but is not something this provider can frame.
     * The origin it returns is hardcoded here, never taken from the input.
     */
    toEmbedUrl: (url: URL) => string | null;
    /** Tokens for the iframe's `sandbox`. Fixed per provider; never author-set. */
    sandbox: readonly string[];
    /** Permissions-policy tokens for the iframe's `allow`. */
    allow: readonly string[];
    allowFullScreen: boolean;
    /** The shape this provider's content wants before an author says otherwise. */
    defaultAspectRatio: EmbedAspectRatio;
    /** The iframe's accessible name when the author has not written one. */
    defaultTitle: string;
};
/** Lowercase and drop a leading `www.`, so host matching is not a trick question. */
declare const normaliseHost: (hostname: string) => string;
declare const EMBED_PROVIDERS: readonly EmbedProvider[];
type ResolvedEmbedUrl = {
    provider: EmbedProvider;
    /** The rebuilt URL. Never the author's string. */
    src: string;
};
/**
 * The single place an embed URL is checked against the allowlist.
 *
 * Every caller — the component, both container resolvers, and the composer's
 * URL editor through the package's public exports — comes through here rather
 * than reading `EMBED_PROVIDERS` and matching for itself. That is what keeps
 * a per-app allowlist a change to one function's argument later on, instead of
 * a hunt for call sites: see
 * `rulecms/__docs__/__TODO__/__COMPONENTS__/TODO_PLATFORM_EMBED_ALLOWLIST_PER_APP.md`.
 *
 * Returns `null` for anything it cannot vouch for, which is the fail-closed
 * behaviour the component depends on. It never throws: a malformed URL in a
 * stored widget must not take down the page it was published to.
 */
declare function resolveEmbedUrl(value: unknown, providers?: readonly EmbedProvider[]): ResolvedEmbedUrl | null;
/** Whether a URL would render. The composer's editor uses this for its hint. */
declare const isAllowedEmbedUrl: (value: unknown, providers?: readonly EmbedProvider[]) => boolean;

declare const cardGroups: CardGroup[];

export { ACCORDION_HEADING_LEVELS, ACCORDION_LIBRARY_STYLESHEET, BLOCK_ENCLOSING_TAGS, BUTTON_BORDER_VARIABLE, BUTTON_CLICK_HANDLER_PROP, BUTTON_CSS_VARIABLE_PREFIX, BUTTON_FILL_ACTIVE_VARIABLE, BUTTON_FILL_HOVER_VARIABLE, BUTTON_FILL_VARIABLE, BUTTON_INK_HOVER_VARIABLE, BUTTON_INK_VARIABLE, BUTTON_LIBRARY_STYLESHEET, BUTTON_RING_VARIABLE, BUTTON_SIZES, BUTTON_TONES, BUTTON_VARIANTS, ComponentIdentifiers, DEFAULT_ACCORDION_HEADING_LEVEL, DEFAULT_BUTTON_LABEL, DEFAULT_BUTTON_PRESET, DEFAULT_EMBED_LOADING, DEFAULT_ICON_POSITION, DEFAULT_LIST_KIND, EMBED_ASPECT_RATIOS, EMBED_LOADING_VALUES, EMBED_PROVIDERS, EMBED_UNSHAPED_HEIGHT, ENCLOSING_TAGS, ICON_POSITIONS, INLINE_ENCLOSING_TAGS, LIST_KINDS, LIST_MARKERS, MOUNT_NAME_ATTRIBUTE, MOUNT_NAME_PATTERN, MOUNT_PROPS_ATTRIBUTE, MOUNT_PROP_TYPES, REJECTED_HREF_SCHEMES, SIZE_SCALES, TONE_PALETTES, applyButtonColumnStyles, buildButtonPresetStyles, buildButtonRenderStyles, disabledStyles as buttonDisabledStyles, cardGroups, components, editor, formatInlineMarker, formatStyleDeclarations, getComponentMetadataForEditing, getPreviewCardGroups, getPreviewComponents, getSourceComponentsPlugin, getSpanStyleItemAt, isAllowedEmbedUrl, isAllowedMountName, isBlockEnclosingTag, isButtonSize, isButtonTone, isButtonVariant, isEmptySpanStyleItem, isEnclosingTag, isForbiddenMountPropKey, isMountPropType, isSafeHref, isSpanStyleItem, manifest, normaliseHost, parseInlineLinkMarkers, parseInlineMarkers, parseStyleDeclarations, renderInlineMarkup, resolveButtonPreset, resolveClassNames, resolveEmbedUrl, resolveLinkAttributes, resolveMountName, resolveMountProps, resolveSpanStyleAttributes, serializeInlineMarkers, stylesheet, toneCssVariable };
export type { AccordionHeadingLevel, AnchorAttributes, AttributeEditModeConfig, AttributeListForComponentTypes, ButtonClickHandler, ButtonPreset, ButtonSize, ButtonTone, ButtonVariant, Card, CardEntry, CardGroup, ComponentMetadata, ComponentMetadataForEditing, ComponentNameToModifyAttribute, DefaultAttributeValue, DeviceTypeBasedAttributeValues, DisplayCardEntry, EditorPreviewCard, EditorPreviewCardEntry, EditorPreviewCardGroup, EmbedAspectRatio, EmbedLoading, EmbedProvider, EmbedProviderId, EnclosingTag, IconAttributeValue, IconNode, IconPosition, InlineLinkRun, InlineMarks, InlineRun, InlineTextRun, LinkItem, ListKind, ListMarker, MarkupBreakRun, MarkupRun, MarkupSpanRun, MarkupTextRun, MountPropRow, MountPropType, MountsMap, NoContainerResolverContext, PageViewType, PreviewComponents, RenderCardEntry, RenderedOrFunctionalComponentEntry, ResolveNoContainer, ResolveRendersOwnElement, ResolvedEmbedUrl, SizeScale, SourceComponentsPlugin, SpanStyleAttributes, SpanStyleItem, StyleDeclaration, TonePalette, WidgetInstanceProps };