@wp-typia/block-types 0.2.4 → 0.3.1

package/dist/blocks/shared/diagnostics.js

@@ -0,0 +1,19 @@
+export function getDiagnosticSeverity(strict) {
+    return strict ? "error" : "warning";
+}
+export function handleDiagnostics(diagnostics, onDiagnostic, options) {
+    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    if (errors.length > 0) {
+        throw new Error([
+            options.failureHeading,
+            ...errors.map((diagnostic) => `- ${diagnostic.message}`),
+        ].join("\n"));
+    }
+    for (const diagnostic of diagnostics) {
+        if (onDiagnostic) {
+            onDiagnostic(diagnostic);
+            continue;
+        }
+        options.logger?.warn(`[wp-typia] ${diagnostic.message}`, diagnostic);
+    }
+}

package/dist/blocks/shared/object-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isNonArrayObject(value: unknown): value is object;
+export declare function isObjectRecord(value: unknown): value is Readonly<Record<string, unknown>>;

package/dist/blocks/shared/object-utils.js

@@ -0,0 +1,10 @@
+export function isNonArrayObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isObjectRecord(value) {
+    if (!isNonArrayObject(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/blocks/shared/static-registration.d.ts

@@ -0,0 +1,4 @@
+export interface NormalizeStaticRegistrationValueOptions {
+    readonly description: string;
+}
+export declare function normalizeStaticRegistrationValue(value: unknown, path: string, options: NormalizeStaticRegistrationValueOptions): unknown;

package/dist/blocks/shared/static-registration.js

@@ -0,0 +1,32 @@
+import { isObjectRecord } from "./object-utils.js";
+export function normalizeStaticRegistrationValue(value, path, options) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "function") {
+        throw new Error(`Cannot generate static ${options.description} registration code for function value at ${path}.`);
+    }
+    if (typeof value === "bigint" || typeof value === "symbol") {
+        throw new Error(`Cannot generate static ${options.description} registration code for ${typeof value} value at ${path}.`);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => normalizeStaticRegistrationValue(entry, `${path}[${index}]`, options));
+    }
+    if (isObjectRecord(value)) {
+        const normalized = {};
+        for (const [key, nestedValue] of Object.entries(value)) {
+            const nextValue = normalizeStaticRegistrationValue(nestedValue, `${path}.${key}`, options);
+            if (nextValue !== undefined) {
+                normalized[key] = nextValue;
+            }
+        }
+        return normalized;
+    }
+    throw new Error(`Cannot generate static ${options.description} registration code for unsupported value at ${path}.`);
+}

package/dist/blocks/supports.d.ts

@@ -1,12 +1,15 @@
 import type { BlockAlignment, BlockVerticalAlignment, JustifyContent, TextAlignment } from "../block-editor/alignment.js";
+import type { BlockBorderSupportAttributes, BlockColorSupportAttributes, BlockDimensionsSupportAttributes, BlockSpacingSupportAttributes, BlockStyleAttributes, BlockTypographySupportAttributes } from "../block-editor/style-attributes.js";
 import type { FlexWrap, LayoutType, Orientation } from "../block-editor/layout.js";
 import type { SpacingAxis, SpacingDimension } from "../block-editor/spacing.js";
+import { type WordPressBlockApiCompatibilityDiagnostic, type WordPressBlockApiCompatibilityFeature, type WordPressBlockApiCompatibilityManifest, type WordPressCompatibilitySettings, type WordPressVersion } from "./compatibility.js";
+import { type DiagnosticLogger } from "./shared/diagnostics.js";
 /**
  * Derived from Gutenberg block support keys and commonly used block.json
  * support sections.
  */
-export type BlockSupportFeature = 'align' | 'alignWide' | 'anchor' | 'ariaLabel' | 'background' | 'border' | 'className' | 'color' | 'customClassName' | 'dimensions' | 'filter' | 'html' | 'inserter' | 'interactivity' | 'js' | 'layout' | 'lightbox' | 'lock' | 'locking' | 'multiple' | 'position' | 'renaming' | 'reusable' | 'shadow' | 'spacing' | 'typography';
-export declare const BLOCK_SUPPORT_FEATURES: readonly ["align", "alignWide", "anchor", "ariaLabel", "background", "border", "className", "color", "customClassName", "dimensions", "filter", "html", "inserter", "interactivity", "js", "layout", "lightbox", "lock", "locking", "multiple", "position", "renaming", "reusable", "shadow", "spacing", "typography"];
+export type BlockSupportFeature = 'align' | 'alignWide' | 'allowedBlocks' | 'anchor' | 'ariaLabel' | 'autoRegister' | 'background' | 'border' | 'className' | 'color' | 'contentRole' | 'customClassName' | 'dimensions' | 'filter' | 'html' | 'inserter' | 'interactivity' | 'js' | 'layout' | 'lightbox' | 'listView' | 'lock' | 'locking' | 'multiple' | 'position' | 'renaming' | 'reusable' | 'shadow' | 'spacing' | 'splitting' | 'visibility' | 'typography';
+export declare const BLOCK_SUPPORT_FEATURES: readonly ["align", "alignWide", "allowedBlocks", "anchor", "ariaLabel", "autoRegister", "background", "border", "className", "color", "contentRole", "customClassName", "dimensions", "filter", "html", "inserter", "interactivity", "js", "layout", "lightbox", "listView", "lock", "locking", "multiple", "position", "renaming", "reusable", "shadow", "spacing", "splitting", "typography", "visibility"];
 export type TypographySupportKey = 'fontFamily' | 'fontSize' | 'fontStyle' | 'fontWeight' | 'letterSpacing' | 'lineHeight' | 'dropCap' | 'textAlign' | 'textColumns' | 'textDecoration' | 'textTransform' | 'writingMode';
 export declare const TYPOGRAPHY_SUPPORT_KEYS: readonly ["fontFamily", "fontSize", "fontStyle", "fontWeight", "letterSpacing", "lineHeight", "dropCap", "textAlign", "textColumns", "textDecoration", "textTransform", "writingMode"];
 export type SpacingSupportKey = 'blockGap' | 'margin' | 'padding';
@@ -139,12 +142,15 @@ export interface BlockTypographySupport {
 export interface BlockSupports {
     readonly align?: boolean | readonly BlockAlignment[];
     readonly alignWide?: boolean;
+    readonly allowedBlocks?: boolean;
     readonly anchor?: boolean;
     readonly ariaLabel?: boolean;
+    readonly autoRegister?: boolean;
     readonly background?: boolean | BlockBackgroundSupport;
     readonly border?: boolean | BlockBorderSupport;
     readonly className?: boolean;
     readonly color?: boolean | BlockColorSupport;
+    readonly contentRole?: boolean;
     readonly customClassName?: boolean;
     readonly dimensions?: boolean | BlockDimensionsSupport;
     readonly filter?: boolean | BlockFilterSupport;
@@ -154,6 +160,7 @@ export interface BlockSupports {
     readonly js?: boolean;
     readonly layout?: boolean | BlockLayoutSupport;
     readonly lightbox?: boolean | BlockLightboxSupport;
+    readonly listView?: boolean;
     readonly lock?: boolean;
     readonly locking?: boolean;
     readonly multiple?: boolean;
@@ -162,6 +169,54 @@ export interface BlockSupports {
     readonly reusable?: boolean;
     readonly shadow?: boolean | BlockShadowSupport;
     readonly spacing?: boolean | BlockSpacingSupport;
+    readonly splitting?: boolean;
     readonly typography?: boolean | BlockTypographySupport;
+    readonly visibility?: boolean;
 }
+export type BlockSupportsInput = BlockSupports & Readonly<Record<string, unknown>>;
+export interface BlockAlignSupportAttributes {
+    readonly align?: BlockAlignment;
+}
+export interface BlockAllowedBlocksSupportAttributes {
+    readonly allowedBlocks?: readonly string[];
+}
+export interface BlockLayoutSupportAttributes {
+    readonly layout?: BlockLayoutDefault;
+}
+export interface BlockStyleAttributeSupportAttributes {
+    readonly style?: BlockStyleAttributes;
+}
+type SupportTruthy<TValue> = [TValue] extends [false | null | undefined] ? false : true;
+type HasSupport<TSupports, TKey extends PropertyKey> = TKey extends keyof TSupports ? SupportTruthy<TSupports[TKey]> : false;
+type HasNestedSupport<TSupports, TSection extends keyof BlockSupports, TKey extends PropertyKey> = TSection extends keyof TSupports ? TSupports[TSection] extends true ? true : TSupports[TSection] extends Readonly<Record<TKey, infer TValue>> ? SupportTruthy<TValue> : false : false;
+type IfSupport<TCondition, TAttributes> = TCondition extends true ? TAttributes : {};
+export interface DefineSupportsInlineOptions {
+    readonly allowUnknownFutureKeys?: boolean;
+    readonly logger?: DiagnosticLogger<WordPressBlockApiCompatibilityDiagnostic>;
+    readonly minVersion?: WordPressVersion;
+    readonly minWordPress?: WordPressVersion;
+    readonly onDiagnostic?: (diagnostic: WordPressBlockApiCompatibilityDiagnostic) => void;
+    readonly strict?: boolean;
+}
+export interface DefineSupportsOptions extends WordPressCompatibilitySettings {
+    readonly logger?: DiagnosticLogger<WordPressBlockApiCompatibilityDiagnostic>;
+    readonly minWordPress?: WordPressVersion;
+    readonly onDiagnostic?: (diagnostic: WordPressBlockApiCompatibilityDiagnostic) => void;
+}
+export type StripDefineSupportsOptions<TSupports> = Omit<TSupports, keyof DefineSupportsInlineOptions>;
+export declare const DEFINED_BLOCK_SUPPORTS_METADATA: unique symbol;
+export type DefinedBlockSupportsMetadataKey = typeof DEFINED_BLOCK_SUPPORTS_METADATA;
+export interface DefinedBlockSupportsMetadata {
+    readonly diagnostics: readonly WordPressBlockApiCompatibilityDiagnostic[];
+    readonly manifest: WordPressBlockApiCompatibilityManifest;
+}
+export type DefinedBlockSupports<TSupports extends BlockSupportsInput = BlockSupportsInput> = Readonly<StripDefineSupportsOptions<TSupports>> & {
+    readonly [DEFINED_BLOCK_SUPPORTS_METADATA]?: DefinedBlockSupportsMetadata;
+};
+export type SupportAttributes<TSupports> = TSupports extends DefinedBlockSupports<infer TDefinedSupports> ? SupportAttributesFromBlockSupports<StripDefineSupportsOptions<TDefinedSupports>> : TSupports extends BlockSupportsInput ? SupportAttributesFromBlockSupports<StripDefineSupportsOptions<TSupports>> : {};
+export type SupportAttributesFromBlockSupports<TSupports> = IfSupport<HasSupport<TSupports, "align">, BlockAlignSupportAttributes> & IfSupport<HasSupport<TSupports, "allowedBlocks">, BlockAllowedBlocksSupportAttributes> & IfSupport<HasSupport<TSupports, "layout">, BlockLayoutSupportAttributes> & IfSupport<HasSupport<TSupports, "color">, BlockColorSupportAttributes> & IfSupport<HasSupport<TSupports, "typography">, BlockTypographySupportAttributes> & IfSupport<HasSupport<TSupports, "spacing">, BlockSpacingSupportAttributes> & IfSupport<HasSupport<TSupports, "dimensions">, BlockDimensionsSupportAttributes> & IfSupport<HasSupport<TSupports, "border">, BlockBorderSupportAttributes> & IfSupport<HasSupport<TSupports, "background">, BlockStyleAttributeSupportAttributes> & IfSupport<HasNestedSupport<TSupports, "filter", "duotone">, BlockStyleAttributeSupportAttributes> & IfSupport<HasSupport<TSupports, "position">, BlockStyleAttributeSupportAttributes> & IfSupport<HasSupport<TSupports, "shadow">, BlockStyleAttributeSupportAttributes>;
+export declare function collectBlockSupportsCompatibilityFeatures(supports: BlockSupportsInput): readonly WordPressBlockApiCompatibilityFeature[];
+export declare function createBlockSupportsCompatibilityManifest(supports: BlockSupportsInput, settings?: DefineSupportsOptions): WordPressBlockApiCompatibilityManifest;
+export declare function getDefinedSupportsCompatibilityManifest(supports: unknown): WordPressBlockApiCompatibilityManifest | undefined;
+export declare function defineSupports<const TSupports extends BlockSupportsInput & DefineSupportsInlineOptions>(supports: TSupports, options?: DefineSupportsOptions): DefinedBlockSupports<TSupports>;
 export {};

package/dist/blocks/supports.js

@@ -1,12 +1,18 @@
+import { createWordPressBlockApiCompatibilityManifest, } from "./compatibility.js";
+import { handleDiagnostics, } from "./shared/diagnostics.js";
+import { isNonArrayObject, isObjectRecord, } from "./shared/object-utils.js";
 export const BLOCK_SUPPORT_FEATURES = [
     'align',
     'alignWide',
+    'allowedBlocks',
     'anchor',
     'ariaLabel',
+    'autoRegister',
     'background',
     'border',
     'className',
     'color',
+    'contentRole',
     'customClassName',
     'dimensions',
     'filter',
@@ -16,6 +22,7 @@ export const BLOCK_SUPPORT_FEATURES = [
     'js',
     'layout',
     'lightbox',
+    'listView',
     'lock',
     'locking',
     'multiple',
@@ -24,7 +31,9 @@ export const BLOCK_SUPPORT_FEATURES = [
     'reusable',
     'shadow',
     'spacing',
+    'splitting',
     'typography',
+    'visibility',
 ];
 export const TYPOGRAPHY_SUPPORT_KEYS = [
     'fontFamily',
@@ -45,3 +54,166 @@ export const SPACING_SUPPORT_KEYS = [
     'margin',
     'padding',
 ];
+export const DEFINED_BLOCK_SUPPORTS_METADATA = Symbol.for("@wp-typia/block-types/defined-supports");
+const KNOWN_BLOCK_SUPPORT_FEATURES = new Set(BLOCK_SUPPORT_FEATURES);
+const DEFINE_SUPPORTS_INLINE_OPTION_KEYS = new Set([
+    "allowUnknownFutureKeys",
+    "logger",
+    "minVersion",
+    "minWordPress",
+    "onDiagnostic",
+    "strict",
+]);
+const COLOR_COMPATIBILITY_SUPPORT_KEYS = [
+    "button",
+    "enableContrastChecker",
+    "heading",
+];
+const TYPOGRAPHY_COMPATIBILITY_SUPPORT_KEYS = [
+    "fontSize",
+    "letterSpacing",
+    "lineHeight",
+    "textAlign",
+    "textDecoration",
+    "textTransform",
+];
+const TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS = [
+    "allowedBlocks",
+    "background",
+    "contentRole",
+    "dimensions",
+    "listView",
+    "position",
+    "renaming",
+    "shadow",
+    "visibility",
+];
+function isEnabledSupportValue(value) {
+    return value !== false && value !== null && value !== undefined;
+}
+function isEnabledTopLevelSupportValue(value) {
+    if (!isObjectRecord(value)) {
+        return isNonArrayObject(value) ? false : isEnabledSupportValue(value);
+    }
+    return Object.entries(value).some(([key, nestedValue]) => !key.startsWith("__experimental") &&
+        isEnabledSupportValue(nestedValue));
+}
+function hasEnabledNestedSupport(section, key) {
+    return isObjectRecord(section) && isEnabledSupportValue(section[key]);
+}
+function addCompatibilityFeature(features, seen, feature) {
+    const id = `blockSupports.${feature}`;
+    if (seen.has(id)) {
+        return;
+    }
+    seen.add(id);
+    features.push({
+        area: "blockSupports",
+        feature,
+    });
+}
+export function collectBlockSupportsCompatibilityFeatures(supports) {
+    const features = [];
+    const seen = new Set();
+    for (const key of TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS) {
+        if (isEnabledTopLevelSupportValue(supports[key])) {
+            addCompatibilityFeature(features, seen, key);
+        }
+    }
+    const spacing = supports.spacing;
+    for (const key of SPACING_SUPPORT_KEYS) {
+        if (hasEnabledNestedSupport(spacing, key)) {
+            addCompatibilityFeature(features, seen, `spacing.${key}`);
+        }
+    }
+    const typography = supports.typography;
+    for (const key of TYPOGRAPHY_COMPATIBILITY_SUPPORT_KEYS) {
+        if (hasEnabledNestedSupport(typography, key)) {
+            addCompatibilityFeature(features, seen, `typography.${key}`);
+        }
+    }
+    const color = supports.color;
+    if (isObjectRecord(color)) {
+        for (const key of COLOR_COMPATIBILITY_SUPPORT_KEYS) {
+            if (isEnabledSupportValue(color[key])) {
+                addCompatibilityFeature(features, seen, `color.${key}`);
+            }
+        }
+    }
+    if (hasEnabledNestedSupport(supports.filter, "duotone")) {
+        addCompatibilityFeature(features, seen, "filter.duotone");
+    }
+    for (const key of Object.keys(supports)) {
+        if (!KNOWN_BLOCK_SUPPORT_FEATURES.has(key) &&
+            !DEFINE_SUPPORTS_INLINE_OPTION_KEYS.has(key) &&
+            isEnabledTopLevelSupportValue(supports[key])) {
+            addCompatibilityFeature(features, seen, key);
+        }
+    }
+    return features;
+}
+function splitDefineSupportsInput(supports) {
+    const normalizedSupports = {};
+    const inlineOptions = {};
+    for (const [key, value] of Object.entries(supports)) {
+        if (DEFINE_SUPPORTS_INLINE_OPTION_KEYS.has(key)) {
+            Object.assign(inlineOptions, { [key]: value });
+            continue;
+        }
+        normalizedSupports[key] = value;
+    }
+    return {
+        inlineOptions,
+        supports: normalizedSupports,
+    };
+}
+function resolveDefineSupportsSettings(inlineOptions, options) {
+    const settings = {};
+    const allowUnknownFutureKeys = options.allowUnknownFutureKeys ?? inlineOptions.allowUnknownFutureKeys;
+    const minVersion = options.minVersion ??
+        options.minWordPress ??
+        inlineOptions.minVersion ??
+        inlineOptions.minWordPress;
+    const strict = options.strict ?? inlineOptions.strict;
+    if (allowUnknownFutureKeys !== undefined) {
+        Object.assign(settings, { allowUnknownFutureKeys });
+    }
+    if (minVersion !== undefined) {
+        Object.assign(settings, { minVersion });
+    }
+    if (strict !== undefined) {
+        Object.assign(settings, { strict });
+    }
+    return settings;
+}
+export function createBlockSupportsCompatibilityManifest(supports, settings = {}) {
+    const compatibilitySettings = resolveDefineSupportsSettings({}, settings);
+    return createWordPressBlockApiCompatibilityManifest(collectBlockSupportsCompatibilityFeatures(supports), compatibilitySettings);
+}
+function handleDefineSupportsDiagnostics(diagnostics, onDiagnostic, logger) {
+    handleDiagnostics(diagnostics, onDiagnostic, {
+        failureHeading: "WordPress block supports compatibility check failed:",
+        logger,
+    });
+}
+export function getDefinedSupportsCompatibilityManifest(supports) {
+    return isObjectRecord(supports)
+        ? supports[DEFINED_BLOCK_SUPPORTS_METADATA]?.manifest
+        : undefined;
+}
+export function defineSupports(supports, options = {}) {
+    const { inlineOptions, supports: normalizedSupports } = splitDefineSupportsInput(supports);
+    const settings = resolveDefineSupportsSettings(inlineOptions, options);
+    const manifest = createBlockSupportsCompatibilityManifest(normalizedSupports, settings);
+    handleDefineSupportsDiagnostics(manifest.diagnostics, options.onDiagnostic ?? inlineOptions.onDiagnostic, options.logger ?? inlineOptions.logger);
+    Object.defineProperty(normalizedSupports, DEFINED_BLOCK_SUPPORTS_METADATA, {
+        configurable: false,
+        enumerable: false,
+        value: {
+            diagnostics: manifest.diagnostics,
+            manifest,
+        },
+        writable: false,
+    });
+    return normalizedSupports;
+}

package/dist/blocks/variations.d.ts

@@ -0,0 +1,87 @@
+import type { BlockAttributes, BlockVariation, BlockVariationScope } from "./registration.js";
+import { type WordPressBlockApiCompatibilityDiagnostic, type WordPressBlockApiCompatibilityFeature, type WordPressBlockApiCompatibilityManifest, type WordPressCompatibilitySettings, type WordPressVersion } from "./compatibility.js";
+import { type DiagnosticLogger } from "./shared/diagnostics.js";
+export type BlockVariationAttributeMap<TAttributes extends BlockAttributes = BlockAttributes> = Partial<TAttributes> & BlockAttributes;
+export type BlockVariationInnerBlockTemplate = readonly [
+    name: string,
+    attributes?: Readonly<BlockAttributes>,
+    innerBlocks?: readonly BlockVariationInnerBlockTemplate[]
+];
+export type BlockVariationInnerBlocks = readonly BlockVariationInnerBlockTemplate[];
+export type BlockVariationIsActive<TAttributes extends BlockAttributes = BlockAttributes> = readonly Extract<keyof TAttributes, string>[] | ((blockAttributes: Readonly<BlockVariationAttributeMap<TAttributes>>, variationAttributes: Readonly<BlockVariationAttributeMap<TAttributes>>) => boolean);
+export interface BlockVariationDefinition<TAttributes extends BlockAttributes = BlockAttributes> extends Omit<BlockVariation<BlockVariationAttributeMap<TAttributes>>, "attributes" | "example" | "innerBlocks" | "isActive" | "scope"> {
+    readonly attributes?: BlockVariationAttributeMap<TAttributes>;
+    readonly example?: BlockVariation<BlockVariationAttributeMap<TAttributes>>["example"] | {
+        readonly attributes: BlockVariationAttributeMap<TAttributes>;
+        readonly innerBlocks?: BlockVariationInnerBlocks;
+    };
+    readonly innerBlocks?: BlockVariationInnerBlocks;
+    readonly isActive?: BlockVariationIsActive<TAttributes>;
+    readonly scope?: readonly BlockVariationScope[];
+}
+export interface DefineVariationInlineOptions {
+    readonly allowMissingIsActive?: boolean;
+    readonly logger?: DiagnosticLogger<BlockVariationDiagnostic>;
+    readonly minVersion?: WordPressVersion;
+    readonly minWordPress?: WordPressVersion;
+    readonly onDiagnostic?: (diagnostic: BlockVariationDiagnostic) => void;
+    readonly requireIsActive?: boolean;
+    readonly strict?: boolean;
+}
+export interface DefineVariationOptions extends WordPressCompatibilitySettings {
+    readonly allowMissingIsActive?: boolean;
+    readonly logger?: DiagnosticLogger<BlockVariationDiagnostic>;
+    readonly minWordPress?: WordPressVersion;
+    readonly onDiagnostic?: (diagnostic: BlockVariationDiagnostic) => void;
+    readonly requireIsActive?: boolean;
+}
+export type StripDefineVariationOptions<TVariation> = Omit<TVariation, keyof DefineVariationInlineOptions>;
+export declare const DEFINED_BLOCK_VARIATION_METADATA: unique symbol;
+export declare const DEFINED_BLOCK_VARIATIONS_METADATA: unique symbol;
+export type DefinedBlockVariationMetadataKey = typeof DEFINED_BLOCK_VARIATION_METADATA;
+export type DefinedBlockVariationsMetadataKey = typeof DEFINED_BLOCK_VARIATIONS_METADATA;
+export interface DefinedBlockVariationMetadata {
+    readonly blockName: string;
+    readonly diagnostics: readonly BlockVariationDiagnostic[];
+    readonly manifest: WordPressBlockApiCompatibilityManifest;
+}
+export interface DefinedBlockVariationsMetadata {
+    readonly diagnostics: readonly BlockVariationDiagnostic[];
+    readonly entries: readonly BlockVariationRegistrationEntry[];
+}
+export type DefinedBlockVariation<TBlockName extends string = string, TAttributes extends BlockAttributes = BlockAttributes, TVariation extends BlockVariationDefinition<TAttributes> = BlockVariationDefinition<TAttributes>> = Readonly<StripDefineVariationOptions<TVariation>> & {
+    readonly [DEFINED_BLOCK_VARIATION_METADATA]?: DefinedBlockVariationMetadata;
+    readonly __wpTypiaVariationAttributes?: TAttributes;
+    readonly __wpTypiaVariationTarget?: TBlockName;
+};
+export type DefinedBlockVariations<TVariations extends readonly DefinedBlockVariation[] = readonly DefinedBlockVariation[]> = Readonly<TVariations> & {
+    readonly [DEFINED_BLOCK_VARIATIONS_METADATA]?: DefinedBlockVariationsMetadata;
+};
+export type BlockVariationDiagnosticCode = "duplicate-active-marker" | "duplicate-variation-name" | "missing-is-active" | "missing-stable-marker" | "unknown-is-active-attribute";
+export interface BlockVariationAuthoringDiagnostic {
+    readonly attribute?: string | undefined;
+    readonly blockName: string;
+    readonly code: BlockVariationDiagnosticCode;
+    readonly message: string;
+    readonly severity: "error" | "warning";
+    readonly variationName: string;
+}
+export type BlockVariationDiagnostic = BlockVariationAuthoringDiagnostic | WordPressBlockApiCompatibilityDiagnostic;
+export interface BlockVariationRegistrationEntry {
+    readonly blockName: string;
+    readonly variation: Readonly<BlockVariationDefinition>;
+}
+export interface CreateBlockVariationRegistrationSourceOptions {
+    readonly functionName?: string;
+    readonly importSource?: string;
+}
+export declare function collectBlockVariationCompatibilityFeatures(): readonly WordPressBlockApiCompatibilityFeature[];
+export declare function createBlockVariationCompatibilityManifest(settings?: DefineVariationOptions): WordPressBlockApiCompatibilityManifest;
+export declare function getDefinedVariationMetadata(variation: unknown): DefinedBlockVariationMetadata | undefined;
+export declare function getDefinedVariationBlockName(variation: unknown): string | undefined;
+export declare function getDefinedVariationCompatibilityManifest(variation: unknown): WordPressBlockApiCompatibilityManifest | undefined;
+export declare function getDefinedVariationsMetadata(variations: unknown): DefinedBlockVariationsMetadata | undefined;
+export declare function defineVariation<TAttributes extends BlockAttributes = BlockAttributes, const TBlockName extends string = string, const TVariation extends BlockVariationDefinition<TAttributes> & DefineVariationInlineOptions = BlockVariationDefinition<TAttributes> & DefineVariationInlineOptions>(blockName: TBlockName, variation: TVariation, options?: DefineVariationOptions): DefinedBlockVariation<TBlockName, TAttributes, TVariation>;
+export declare function createBlockVariationRegistrationPlan(variations: readonly DefinedBlockVariation[]): readonly BlockVariationRegistrationEntry[];
+export declare function defineVariations<const TVariations extends readonly DefinedBlockVariation[]>(variations: TVariations, options?: DefineVariationOptions): DefinedBlockVariations<TVariations>;
+export declare function createStaticBlockVariationRegistrationSource(variations: readonly DefinedBlockVariation[], options?: CreateBlockVariationRegistrationSourceOptions): string;