eddev 0.2.67-beta1 → 0.3.0-beta1

package/blocks/ContentBlocks.js

@@ -1,28 +1,48 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentBlocks = exports.BlocksContext = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
+var jsx_runtime_1 = require("react/jsx-runtime");
 // @ts-ignore
-const blocks_1 = __importDefault(require("@manifest/blocks"));
-const blockAttributes_1 = require("./blockAttributes");
-const react_1 = require("react");
-const ErrorBoundaryFrontend_1 = require("./ErrorBoundaryFrontend");
+var blocks_1 = __importDefault(require("@manifest/blocks"));
+var blockAttributes_1 = require("./blockAttributes");
+var react_1 = require("react");
+var ErrorBoundaryFrontend_1 = require("./ErrorBoundaryFrontend");
 exports.BlocksContext = (0, react_1.createContext)(undefined);
 function wrapPromise(promise) {
-    let status = "pending";
-    let result;
-    let suspender = promise.then((r) => {
+    var status = "pending";
+    var result;
+    var suspender = promise.then(function (r) {
         status = "success";
         result = r;
-    }, (e) => {
+    }, function (e) {
         status = "error";
         result = e;
     });
     return {
-        read() {
+        read: function () {
             //console.log(status);
             if (status === "pending") {
                 throw suspender;
@@ -36,9 +56,9 @@ function wrapPromise(promise) {
         },
     };
 }
-let blockManifestResource = null;
+var blockManifestResource = null;
 function ContentBlocks(props) {
-    let blockTypes = blocks_1.default;
+    var blockTypes = blocks_1.default;
     if (blocks_1.default.then && process.serverless && !blocks_1.default.default) {
         if (!blockManifestResource)
             blockManifestResource = wrapPromise(blocks_1.default);
@@ -49,37 +69,33 @@ function ContentBlocks(props) {
     }
     if (!Array.isArray(props.blocks))
         return null;
-    const parentContext = (0, react_1.useContext)(exports.BlocksContext);
-    const blocks = (0, react_1.useMemo)(() => props.blocks.map((block, index) => {
-        // Create a context object for the current block
-        const ctx = {
-            ...parentContext,
-            ancestors: [...(parentContext?.ancestors || []), parentContext?.current].filter(Boolean),
-            parent: parentContext?.current,
-            current: block,
-            prev: props.blocks[index - 1],
-            next: props.blocks[index + 1],
-        };
-        // Figure out the
-        let blockNode;
-        if (block.blockName in blockTypes) {
-            const Component = blockTypes[block.blockName];
-            if (!Component)
-                return (0, jsx_runtime_1.jsx)(react_1.Fragment, {});
-            blockNode = ((0, jsx_runtime_1.jsx)(blockAttributes_1.InlineEditingContextProvider, { block: [block.blockName, block.props], values: block.inline, innerBlocks: block.innerBlocks, children: (0, jsx_runtime_1.jsx)(Component, { ...block.props, innerHTML: block.innerHTML, 
-                    // innerBlocks={block.innerBlocks}
-                    children: Array.isArray(block.innerBlocks) && block.innerBlocks.length ? ((0, jsx_runtime_1.jsx)(ContentBlocks, { blocks: block.innerBlocks })) : null }) }));
-        }
-        else if (block.innerHTML) {
-            blockNode = (0, jsx_runtime_1.jsx)("div", { dangerouslySetInnerHTML: { __html: block.innerHTML } });
-        }
-        else {
-            blockNode = null;
-        }
-        return [ctx, block, blockNode];
-    }), [props.blocks]);
-    const layout = (0, react_1.useMemo)(() => {
-        return blocks.filter(Boolean).map(([ctx, block, blockNode], index) => {
+    var parentContext = (0, react_1.useContext)(exports.BlocksContext);
+    var blocks = (0, react_1.useMemo)(function () {
+        return props.blocks.map(function (block, index) {
+            // Create a context object for the current block
+            var ctx = __assign(__assign({}, parentContext), { ancestors: __spreadArray(__spreadArray([], ((parentContext === null || parentContext === void 0 ? void 0 : parentContext.ancestors) || []), true), [parentContext === null || parentContext === void 0 ? void 0 : parentContext.current], false).filter(Boolean), parent: parentContext === null || parentContext === void 0 ? void 0 : parentContext.current, current: block, prev: props.blocks[index - 1], next: props.blocks[index + 1] });
+            // Figure out the
+            var blockNode;
+            if (block.blockName in blockTypes) {
+                var Component = blockTypes[block.blockName];
+                if (!Component)
+                    return (0, jsx_runtime_1.jsx)(react_1.Fragment, {}, void 0);
+                blockNode = ((0, jsx_runtime_1.jsx)(blockAttributes_1.InlineEditingContextProvider, __assign({ block: [block.blockName, block.props], values: block.inline, innerBlocks: block.innerBlocks }, { children: (0, jsx_runtime_1.jsx)(Component, __assign({}, block.props, { innerHTML: block.innerHTML, 
+                        // innerBlocks={block.innerBlocks}
+                        children: Array.isArray(block.innerBlocks) && block.innerBlocks.length ? ((0, jsx_runtime_1.jsx)(ContentBlocks, { blocks: block.innerBlocks }, void 0)) : null }), void 0) }), void 0));
+            }
+            else if (block.innerHTML) {
+                blockNode = (0, jsx_runtime_1.jsx)("div", { dangerouslySetInnerHTML: { __html: block.innerHTML } }, void 0);
+            }
+            else {
+                blockNode = null;
+            }
+            return [ctx, block, blockNode];
+        });
+    }, [props.blocks]);
+    var layout = (0, react_1.useMemo)(function () {
+        return blocks.filter(Boolean).map(function (_a, index) {
+            var ctx = _a[0], block = _a[1], blockNode = _a[2];
             // Exit early if the block is null
             if (blockNode === null)
                 return (0, jsx_runtime_1.jsx)(react_1.Fragment, {}, index);
@@ -88,30 +104,22 @@ function ContentBlocks(props) {
                 blockNode = props.wrapBlock(blockNode, ctx);
             }
             // Wrap the block in a context provider
-            blockNode = (0, jsx_runtime_1.jsx)(exports.BlocksContext.Provider, { value: ctx, children: blockNode });
+            blockNode = (0, jsx_runtime_1.jsx)(exports.BlocksContext.Provider, __assign({ value: ctx }, { children: blockNode }), void 0);
             // Custom spacer function?
-            let spaceBefore = null;
-            let spaceAfter = null;
+            var spaceBefore = null;
+            var spaceAfter = null;
             if (props.spacer) {
                 // Before block
-                spaceBefore = props.spacer({
-                    ...ctx,
-                    prev: ctx.prev || null,
-                    next: ctx.current || null,
-                });
+                spaceBefore = props.spacer(__assign(__assign({}, ctx), { prev: ctx.prev || null, next: ctx.current || null }));
                 // After block (last block only)
                 if (index === props.blocks.length - 1) {
-                    spaceAfter = props.spacer({
-                        ...ctx,
-                        prev: block,
-                        next: null,
-                    });
+                    spaceAfter = props.spacer(__assign(__assign({}, ctx), { prev: block, next: null }));
                 }
             }
             // Attempt to wrap the block
-            return ((0, jsx_runtime_1.jsxs)(react_1.Fragment, { children: [spaceBefore, (0, jsx_runtime_1.jsx)(ErrorBoundaryFrontend_1.ErrorBoundaryFrontend, { children: blockNode }), spaceAfter] }, index));
+            return ((0, jsx_runtime_1.jsxs)(react_1.Fragment, { children: [spaceBefore, (0, jsx_runtime_1.jsx)(ErrorBoundaryFrontend_1.ErrorBoundaryFrontend, { children: blockNode }, void 0), spaceAfter] }, index));
         });
     }, [blocks, props.wrapBlock, props.spacer]);
-    return (0, jsx_runtime_1.jsx)(react_1.Fragment, { children: layout });
+    return (0, jsx_runtime_1.jsx)(react_1.Fragment, { children: layout }, void 0);
 }
 exports.ContentBlocks = ContentBlocks;

package/blocks/ErrorBoundaryEditor.d.ts

@@ -10,6 +10,6 @@ export declare class ErrorBoundaryEditor extends Component<Props, State> {
     state: State;
     static getDerivedStateFromError(err: Error): State;
     componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
-    render(): string | number | boolean | import("react/jsx-runtime").JSX.Element | React.ReactFragment | null | undefined;
+    render(): string | number | boolean | JSX.Element | React.ReactFragment | null | undefined;
 }
 export {};

package/blocks/ErrorBoundaryEditor.js

@@ -1,35 +1,64 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorBoundaryEditor = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-class ErrorBoundaryEditor extends react_1.Component {
-    constructor() {
-        super(...arguments);
-        this.state = {
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var ErrorBoundaryEditor = /** @class */ (function (_super) {
+    __extends(ErrorBoundaryEditor, _super);
+    function ErrorBoundaryEditor() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = {
             hasError: false,
         };
+        return _this;
     }
-    static getDerivedStateFromError(err) {
+    ErrorBoundaryEditor.getDerivedStateFromError = function (err) {
         // Update state so the next render will show the fallback UI.
         return { hasError: true, error: err };
-    }
-    componentDidCatch(error, errorInfo) {
+    };
+    ErrorBoundaryEditor.prototype.componentDidCatch = function (error, errorInfo) {
         console.error("Uncaught error:", error, errorInfo);
-    }
-    render() {
+    };
+    ErrorBoundaryEditor.prototype.render = function () {
         if (this.state.hasError) {
-            const err = this.state.error;
-            return ((0, jsx_runtime_1.jsx)("pre", { style: {
+            var err = this.state.error;
+            return ((0, jsx_runtime_1.jsx)("pre", __assign({ style: {
                     fontSize: "12px",
                     color: "red",
                     border: "1px solid red",
                     borderRadius: "4px",
                     padding: "4px",
                     overflowX: "auto",
-                }, children: err.stack }));
+                } }, { children: err.stack }), void 0));
         }
         return this.props.children;
-    }
-}
+    };
+    return ErrorBoundaryEditor;
+}(react_1.Component));
 exports.ErrorBoundaryEditor = ErrorBoundaryEditor;

package/blocks/ErrorBoundaryFrontend.d.ts

@@ -10,6 +10,6 @@ export declare class ErrorBoundaryFrontend extends Component<Props, State> {
     state: State;
     static getDerivedStateFromError(err: Error): State;
     componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
-    render(): string | number | boolean | import("react/jsx-runtime").JSX.Element | React.ReactFragment | null | undefined;
+    render(): string | number | boolean | JSX.Element | React.ReactFragment | null | undefined;
 }
 export {};

package/blocks/ErrorBoundaryFrontend.js

@@ -1,40 +1,69 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorBoundaryFrontend = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-class ErrorBoundaryFrontend extends react_1.Component {
-    constructor() {
-        super(...arguments);
-        this.state = {
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var ErrorBoundaryFrontend = /** @class */ (function (_super) {
+    __extends(ErrorBoundaryFrontend, _super);
+    function ErrorBoundaryFrontend() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = {
             hasError: false,
         };
+        return _this;
     }
-    static getDerivedStateFromError(err) {
+    ErrorBoundaryFrontend.getDerivedStateFromError = function (err) {
         // Update state so the next render will show the fallback UI.
         return { hasError: true, error: err };
-    }
-    componentDidCatch(error, errorInfo) {
+    };
+    ErrorBoundaryFrontend.prototype.componentDidCatch = function (error, errorInfo) {
         console.error("Uncaught error:", error, errorInfo);
-    }
-    render() {
+    };
+    ErrorBoundaryFrontend.prototype.render = function () {
         if (this.state.hasError) {
-            const err = this.state.error;
+            var err = this.state.error;
             if (process.dev) {
-                return ((0, jsx_runtime_1.jsx)("pre", { style: {
+                return ((0, jsx_runtime_1.jsx)("pre", __assign({ style: {
                         fontSize: "12px",
                         color: "red",
                         border: "1px solid red",
                         borderRadius: "4px",
                         padding: "4px",
                         overflowX: "auto",
-                    }, children: err.stack }));
+                    } }, { children: err.stack }), void 0));
             }
             else {
                 return null;
             }
         }
         return this.props.children;
-    }
-}
+    };
+    return ErrorBoundaryFrontend;
+}(react_1.Component));
 exports.ErrorBoundaryFrontend = ErrorBoundaryFrontend;

package/blocks/InspectorControls.d.ts

@@ -1,2 +1,2 @@
 import { PropsWithChildren } from "react";
-export declare function InspectorControls(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element | null;
+export declare function InspectorControls(props: PropsWithChildren<{}>): JSX.Element | null;

package/blocks/InspectorControls.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InspectorControls = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
+var jsx_runtime_1 = require("react/jsx-runtime");
 // @ts-ignore
-const block_editor_1 = require("@wordpress/block-editor");
+var block_editor_1 = require("@wordpress/block-editor");
 function InspectorControls(props) {
     if (process.admin) {
-        return (0, jsx_runtime_1.jsx)(block_editor_1.InspectorControls, { children: props.children });
+        return (0, jsx_runtime_1.jsx)(block_editor_1.InspectorControls, { children: props.children }, void 0);
     }
     return null;
 }

package/blocks/blockAttributes.d.ts

@@ -3,14 +3,14 @@ import { PropsWithChildren } from "react";
 interface Attributes {
     [key: string]: any;
 }
-type ProviderProps = PropsWithChildren<{
+declare type ProviderProps = PropsWithChildren<{
     values: Attributes;
     innerBlocks: ContentBlock[];
     block: [string, Attributes];
     onChange?: (attrs: Attributes) => void;
     insertBlocksAfter?: (block: any) => void;
 }>;
-export declare function InlineEditingContextProvider(props: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function InlineEditingContextProvider(props: ProviderProps): JSX.Element;
 export declare function useInlineEditableValue<T>(key: string, defaultValue?: T): [T, (value: T) => void];
 export declare function useBlockAppender(): ((block: any) => void) | undefined;
 export declare function useInnerBlocks(): ContentBlock[];

package/blocks/blockAttributes.js

@@ -1,52 +1,72 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useBlockParents = exports.useInnerBlocks = exports.useBlockAppender = exports.useInlineEditableValue = exports.InlineEditingContextProvider = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-const InlineEditingContext = (0, react_1.createContext)(undefined);
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+var InlineEditingContext = (0, react_1.createContext)(undefined);
 function InlineEditingContextProvider(props) {
-    const parentContext = (0, react_1.useContext)(InlineEditingContext);
-    return ((0, jsx_runtime_1.jsx)(InlineEditingContext.Provider, { value: {
+    var parentContext = (0, react_1.useContext)(InlineEditingContext);
+    return ((0, jsx_runtime_1.jsx)(InlineEditingContext.Provider, __assign({ value: {
             values: props.values,
             innerBlocks: props.innerBlocks,
-            parents: [...(parentContext?.parents || []), props.block].filter(Boolean),
-            getValue(key) {
-                return props.values?.[key];
+            parents: __spreadArray(__spreadArray([], ((parentContext === null || parentContext === void 0 ? void 0 : parentContext.parents) || []), true), [props.block], false).filter(Boolean),
+            getValue: function (key) {
+                var _a;
+                return (_a = props.values) === null || _a === void 0 ? void 0 : _a[key];
             },
-            setValue(key, value) {
+            setValue: function (key, value) {
+                var _a;
                 if (props.onChange) {
-                    props.onChange({
-                        ...(props.values || {}),
-                        [key]: value,
-                    });
+                    props.onChange(__assign(__assign({}, (props.values || {})), (_a = {}, _a[key] = value, _a)));
                 }
             },
             insertBlocksAfter: props.insertBlocksAfter,
-        }, children: props.children }));
+        } }, { children: props.children }), void 0));
 }
 exports.InlineEditingContextProvider = InlineEditingContextProvider;
 function useInlineEditableValue(key, defaultValue) {
-    const attrs = (0, react_1.useContext)(InlineEditingContext);
+    var _a;
+    var attrs = (0, react_1.useContext)(InlineEditingContext);
     return [
-        attrs?.getValue(key) ?? defaultValue,
-        (value) => {
-            attrs?.setValue(key, value);
+        (_a = attrs === null || attrs === void 0 ? void 0 : attrs.getValue(key)) !== null && _a !== void 0 ? _a : defaultValue,
+        function (value) {
+            attrs === null || attrs === void 0 ? void 0 : attrs.setValue(key, value);
         },
     ];
 }
 exports.useInlineEditableValue = useInlineEditableValue;
 function useBlockAppender() {
-    const ctx = (0, react_1.useContext)(InlineEditingContext);
-    return ctx?.insertBlocksAfter;
+    var ctx = (0, react_1.useContext)(InlineEditingContext);
+    return ctx === null || ctx === void 0 ? void 0 : ctx.insertBlocksAfter;
 }
 exports.useBlockAppender = useBlockAppender;
 function useInnerBlocks() {
-    const ctx = (0, react_1.useContext)(InlineEditingContext);
-    return ctx?.innerBlocks || [];
+    var ctx = (0, react_1.useContext)(InlineEditingContext);
+    return (ctx === null || ctx === void 0 ? void 0 : ctx.innerBlocks) || [];
 }
 exports.useInnerBlocks = useInnerBlocks;
 function useBlockParents() {
-    const ctx = (0, react_1.useContext)(InlineEditingContext);
-    return ctx?.parents || [];
+    var ctx = (0, react_1.useContext)(InlineEditingContext);
+    return (ctx === null || ctx === void 0 ? void 0 : ctx.parents) || [];
 }
 exports.useBlockParents = useBlockParents;

package/blocks/index.js

@@ -1,11 +1,7 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/blocks/inlineEditing.d.ts

@@ -1,6 +1,6 @@
-import { ComponentPropsWithoutRef, ElementType, FunctionComponent } from "react";
+import { ElementType, FunctionComponent, ComponentPropsWithoutRef } from "react";
 import { ContentBlocksSettings } from ".";
-type PropTypes<T extends ElementType> = {
+declare type PropTypes<T extends ElementType> = {
     /** The 'key' of this editable text value */
     id: string;
     /** Specify a tag name or React component */
@@ -14,17 +14,17 @@ type PropTypes<T extends ElementType> = {
     /** Append a new block when the user hits 'Enter' */
     appendOnEnter?: boolean;
 } & ComponentPropsWithoutRef<T>;
-export declare function EditableText<T extends ElementType>({ id, as, appendOnEnter, ...props }: PropTypes<T>): import("react/jsx-runtime").JSX.Element | null;
-type AppenderConfig = {
+export declare function EditableText<T extends ElementType>({ id, as, appendOnEnter, ...props }: PropTypes<T>): JSX.Element | null;
+declare type AppenderConfig = {
     type: "default" | "button" | FunctionComponent<any>;
     block?: boolean;
 };
-type InnerBlocksProps = {
+declare type InnerBlocksProps = {
     allowedBlocks?: string[];
     orientation?: "horizontal" | "vertical";
     templateLock?: any;
     template?: any;
     appender?: AppenderConfig;
 } & ContentBlocksSettings;
-export declare function InnerBlocks(props: InnerBlocksProps): import("react/jsx-runtime").JSX.Element;
+export declare function InnerBlocks(props: InnerBlocksProps): JSX.Element;
 export {};