contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/entities/comment.js

@@ -0,0 +1,60 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+// Remove and replace with BLOCKS as soon as rich-text-types supports mentions
+var CommentNode;
+(function (CommentNode) {
+    CommentNode["Document"] = "document";
+    CommentNode["Paragraph"] = "paragraph";
+    CommentNode["Mention"] = "mention";
+})(CommentNode || (CommentNode = {}));
+/**
+ * @private
+ */
+function createCommentApi(makeRequest) {
+    const getParams = (comment) => ({
+        spaceId: comment.sys.space.sys.id,
+        environmentId: comment.sys.environment.sys.id,
+        entryId: comment.sys.parentEntity.sys.id,
+        commentId: comment.sys.id,
+    });
+    return {
+        update: async function () {
+            const raw = this.toPlainObject();
+            const data = await makeRequest({
+                entityType: 'Comment',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            });
+            return wrapComment(makeRequest, data);
+        },
+        delete: async function () {
+            const raw = this.toPlainObject();
+            await makeRequest({
+                entityType: 'Comment',
+                action: 'delete',
+                params: {
+                    ...getParams(raw),
+                    version: raw.sys.version,
+                },
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapComment(makeRequest, data) {
+    const comment = toPlainObject(copy(data));
+    const commentWithMethods = enhanceWithMethods(comment, createCommentApi(makeRequest));
+    return freezeSys(commentWithMethods);
+}
+/**
+ * @private
+ */
+const wrapCommentCollection = wrapCollection(wrapComment);
+
+export { CommentNode, createCommentApi as default, wrapComment, wrapCommentCollection };

package/dist/types/entities/concept-scheme.d.ts

@@ -0,0 +1,22 @@
+import type { Link } from '../common-types.js';
+import type { TaxonomyConceptLink } from './concept.js';
+import type { LocalizedEntity } from './utils.js';
+export type ConceptScheme = {
+    uri: string | null;
+    prefLabel: string;
+    definition: string | null;
+    topConcepts: TaxonomyConceptLink[];
+    concepts: TaxonomyConceptLink[];
+    totalConcepts: number;
+    sys: {
+        type: 'TaxonomyConceptScheme';
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        version: number;
+        createdBy: Link<'User'>;
+        updatedBy: Link<'User'>;
+    };
+};
+export type ConceptSchemeProps<Locales extends string = string> = LocalizedEntity<ConceptScheme, 'prefLabel' | 'definition', Locales>;
+export type CreateConceptSchemeProps = Partial<Omit<ConceptSchemeProps, 'sys'>> & Pick<ConceptSchemeProps, 'prefLabel'>;

package/dist/types/entities/concept.d.ts

@@ -0,0 +1,30 @@
+import type { Link } from '../common-types.js';
+import type { LocalizedEntity } from './utils.js';
+export type TaxonomyConceptLink = Link<'TaxonomyConcept'>;
+type Concept = {
+    uri: string | null;
+    prefLabel: string;
+    altLabels: string[];
+    hiddenLabels: string[];
+    definition: string | null;
+    editorialNote: string | null;
+    historyNote: string | null;
+    example: string | null;
+    note: string | null;
+    scopeNote: string | null;
+    notations: string[];
+    broader: TaxonomyConceptLink[];
+    related: TaxonomyConceptLink[];
+    sys: {
+        type: 'TaxonomyConcept';
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        version: number;
+        createdBy: Link<'User'>;
+        updatedBy: Link<'User'>;
+    };
+};
+export type ConceptProps<Locales extends string = string> = LocalizedEntity<Omit<Concept, 'conceptSchemes'>, 'prefLabel' | 'altLabels' | 'hiddenLabels' | 'definition' | 'historyNote' | 'editorialNote' | 'example' | 'note' | 'scopeNote', Locales>;
+export type CreateConceptProps = Partial<Omit<ConceptProps, 'sys'>> & Pick<ConceptProps, 'prefLabel'>;
+export {};

package/dist/types/entities/content-type-fields.d.ts

@@ -0,0 +1,81 @@
+import type { KeyValueMap } from '../common-types.js';
+import type { INLINES, BLOCKS } from '@contentful/rich-text-types';
+interface NumRange {
+    min?: number;
+    max?: number;
+}
+interface DateRange {
+    min?: string;
+    max?: string;
+}
+interface RegExp {
+    pattern: string;
+    flags: string;
+}
+interface NodesValidation {
+    [BLOCKS.EMBEDDED_ENTRY]?: Pick<ContentTypeFieldValidation, 'size' | 'linkContentType' | 'message'>[];
+    [INLINES.EMBEDDED_ENTRY]?: Pick<ContentTypeFieldValidation, 'size' | 'linkContentType' | 'message'>[];
+    [INLINES.ENTRY_HYPERLINK]?: Pick<ContentTypeFieldValidation, 'size' | 'linkContentType' | 'message'>[];
+    [BLOCKS.EMBEDDED_ASSET]?: Pick<ContentTypeFieldValidation, 'size' | 'message'>[];
+    [INLINES.ASSET_HYPERLINK]?: Pick<ContentTypeFieldValidation, 'size' | 'message'>[];
+    [BLOCKS.EMBEDDED_RESOURCE]?: {
+        validations: Pick<ContentTypeFieldValidation, 'size' | 'message'>[];
+        allowedResources: ContentTypeAllowedResources[];
+    };
+    [INLINES.EMBEDDED_RESOURCE]?: {
+        validations: Pick<ContentTypeFieldValidation, 'size' | 'message'>[];
+        allowedResources: ContentTypeAllowedResources[];
+    };
+    [INLINES.RESOURCE_HYPERLINK]?: {
+        validations: Pick<ContentTypeFieldValidation, 'size' | 'message'>[];
+        allowedResources: ContentTypeAllowedResources[];
+    };
+}
+export interface ContentTypeFieldValidation {
+    linkContentType?: string[];
+    in?: (string | number)[];
+    linkMimetypeGroup?: string[];
+    enabledNodeTypes?: (`${BLOCKS}` | `${INLINES}`)[];
+    enabledMarks?: string[];
+    unique?: boolean;
+    size?: NumRange;
+    range?: NumRange;
+    dateRange?: DateRange;
+    regexp?: RegExp;
+    message?: string | null;
+    prohibitRegexp?: RegExp;
+    assetImageDimensions?: {
+        width?: NumRange;
+        height?: NumRange;
+    };
+    assetFileSize?: NumRange;
+    nodes?: NodesValidation;
+}
+interface Item {
+    type: string;
+    linkType?: string;
+    validations?: ContentTypeFieldValidation[];
+}
+type ContentTypeAllowedResources = ContentfulEntryResource | ExternalResource;
+export interface ContentfulEntryResource {
+    type: 'Contentful:Entry';
+    source: string;
+    contentTypes: string[];
+}
+export interface ExternalResource {
+    type: string;
+}
+export interface ContentFields<T = KeyValueMap> extends Item {
+    id: string;
+    name: string;
+    required: boolean;
+    localized: boolean;
+    disabled?: boolean;
+    omitted?: boolean;
+    deleted?: boolean;
+    items?: Item;
+    apiName?: string;
+    defaultValue?: T;
+    allowedResources?: ContentTypeAllowedResources[];
+}
+export {};

package/dist/types/entities/content-type.d.ts

@@ -0,0 +1,213 @@
+import type { Except, RequireAtLeastOne, SetOptional } from 'type-fest';
+import type { BasicMetaSysProps, Collection, DefaultElements, Link, MakeRequest } from '../common-types.js';
+import type { ContentFields } from './content-type-fields.js';
+import type { EditorInterface } from './editor-interface.js';
+import type { Snapshot, SnapshotProps } from './snapshot.js';
+type TaxonomyConceptValidationLink = Link<'TaxonomyConcept'> & {
+    required?: boolean;
+};
+type TaxonomyConceptSchemeValidationLink = Link<'TaxonomyConceptScheme'> & {
+    required?: boolean;
+};
+export type ContentTypeMetadata = {
+    annotations?: RequireAtLeastOne<{
+        ContentType?: AnnotationAssignment[];
+        ContentTypeField?: Record<string, AnnotationAssignment[]>;
+    }, 'ContentType' | 'ContentTypeField'>;
+    taxonomy?: Array<TaxonomyConceptValidationLink | TaxonomyConceptSchemeValidationLink>;
+};
+export type AnnotationAssignment = Link<'Annotation'> & {
+    parameters?: Record<string, string | number | boolean>;
+};
+export type ContentTypeProps = {
+    sys: BasicMetaSysProps & {
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+        firstPublishedAt?: string;
+        publishedCounter?: number;
+        publishedVersion?: number;
+    };
+    name: string;
+    description: string;
+    /** Field used as the main display field for Entries */
+    displayField: string;
+    /** All the fields contained in this Content Type */
+    fields: ContentFields[];
+    metadata?: ContentTypeMetadata;
+};
+export type CreateContentTypeProps = SetOptional<Except<ContentTypeProps, 'sys'>, 'description' | 'displayField'>;
+type ContentTypeApi = {
+    /**
+     * Sends an update to the server with any changes made to the object's properties. <br />
+     * <strong>Important note about deleting fields</strong>: The standard way to delete a field is with two updates: first omit the property from your responses (set the field attribute "omitted" to true), and then
+     * delete it by setting the attribute "deleted" to true. See the "Deleting fields" section in the
+     * <a href="https://www.contentful.com/developers/docs/references/content-management-api/#/reference/content-types/content-type">API reference</a> for more reasoning. Alternatively,
+     * you may use the convenience method omitAndDeleteField to do both steps at once.
+     * @return Object returned from the server with updated changes.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => {
+     *  contentType.name = 'New name'
+     *  return contentType.update()
+     * })
+     * .then(contentType => console.log(contentType))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<ContentType>;
+    /**
+     * Deletes this object on the server.
+     * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.delete())
+     * .then(() => console.log('contentType deleted'))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * Publishes the object
+     * @return Object returned from the server with updated metadata.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.publish())
+     * .then((contentType) => console.log(`${contentType.sys.id} is published`))
+     * .catch(console.error)
+     * ```
+     */
+    publish(): Promise<ContentType>;
+    /**
+     * Unpublishes the object
+     * @return Object returned from the server with updated metadata.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.unpublish())
+     * .then((contentType) => console.log(`${contentType.sys.id} is unpublished`))
+     * .catch(console.error)
+     * ```
+     */
+    unpublish(): Promise<ContentType>;
+    /**
+     * Gets the editor interface for the object <br />
+     * <strong>Important note</strong>: The editor interface only represent a published contentType.<br />
+     * To get the most recent representation of the contentType make sure to publish it first
+     * @return Object returned from the server with the current editor interface.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.getEditorInterface())
+     * .then((editorInterface) => console.log(editorInterface.contorls))
+     * .catch(console.error)
+     * ```
+     */
+    getEditorInterface(): Promise<EditorInterface>;
+    /**
+     * Checks if the contentType is in draft mode. This means it is not published.
+     */
+    isDraft(): boolean;
+    /**
+     * Checks if the contentType is published. A published contentType might have unpublished changes (@see {ContentType.isUpdated})
+     */
+    isPublished(): boolean;
+    /**
+     * Checks if the contentType is updated. This means the contentType was previously published but has unpublished changes.
+     */
+    isUpdated(): boolean;
+    /**
+     * Omits and deletes a field if it exists on the contentType. This is a convenience method which does both operations at once and potentially less
+     * safe than the standard way. See note about deleting fields on the Update method.
+     * @return Object returned from the server with updated metadata.
+     */
+    omitAndDeleteField(id: string): Promise<ContentType>;
+    /**
+     * Gets a snapshot of a contentType
+     * @param snapshotId - Id of the snapshot
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((entry) => entry.getSnapshot('<snapshot-id>'))
+     * .then((snapshot) => console.log(snapshot))
+     * .catch(console.error)
+     * ```
+     */
+    getSnapshot(snapshotId: string): Promise<SnapshotProps<ContentTypeProps>>;
+    /**
+     * Gets all snapshots of a contentType
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((entry) => entry.getSnapshots())
+     * .then((snapshots) => console.log(snapshots.items))
+     * .catch(console.error)
+     * ```
+     */
+    getSnapshots(): Promise<Collection<Snapshot<ContentTypeProps>, SnapshotProps<ContentTypeProps>>>;
+};
+export interface ContentType extends ContentTypeProps, DefaultElements<ContentTypeProps>, ContentTypeApi {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw content type data
+ * @return Wrapped content type data
+ */
+export declare function wrapContentType(makeRequest: MakeRequest, data: ContentTypeProps): ContentType;
+/**
+ * @private
+ */
+export declare const wrapContentTypeCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<ContentTypeProps>) => Collection<ContentType, ContentTypeProps>;
+export {};

package/dist/types/entities/content-type.js

@@ -0,0 +1,117 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { isPublished, isUpdated, isDraft } from '../plain/checks.js';
+import { wrapEditorInterface } from './editor-interface.js';
+import { wrapSnapshotCollection, wrapSnapshot } from './snapshot.js';
+import { omitAndDeleteField } from '../methods/content-type.js';
+
+/**
+ * @private
+ */
+function createContentTypeApi(makeRequest) {
+    const getParams = (self) => {
+        const contentType = self.toPlainObject();
+        return {
+            raw: contentType,
+            params: {
+                spaceId: contentType.sys.space.sys.id,
+                environmentId: contentType.sys.environment.sys.id,
+                contentTypeId: contentType.sys.id,
+            },
+        };
+    };
+    return {
+        update: function () {
+            const { raw, params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'update',
+                params,
+                payload: raw,
+            }).then((data) => wrapContentType(makeRequest, data));
+        },
+        delete: function () {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'delete',
+                params,
+            }).then(() => {
+                // noop
+            });
+        },
+        publish: function () {
+            const { raw, params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'publish',
+                params,
+                payload: raw,
+            }).then((data) => wrapContentType(makeRequest, data));
+        },
+        unpublish: function () {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'unpublish',
+                params,
+            }).then((data) => wrapContentType(makeRequest, data));
+        },
+        getEditorInterface: function () {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'EditorInterface',
+                action: 'get',
+                params,
+            }).then((data) => wrapEditorInterface(makeRequest, data));
+        },
+        getSnapshots: function (query = {}) {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'Snapshot',
+                action: 'getManyForContentType',
+                params: { ...params, query },
+            }).then((data) => wrapSnapshotCollection(makeRequest, data));
+        },
+        getSnapshot: function (snapshotId) {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'Snapshot',
+                action: 'getForContentType',
+                params: { ...params, snapshotId },
+            }).then((data) => wrapSnapshot(makeRequest, data));
+        },
+        isPublished: function () {
+            return isPublished(this);
+        },
+        isUpdated: function () {
+            return isUpdated(this);
+        },
+        isDraft: function () {
+            return isDraft(this);
+        },
+        omitAndDeleteField: function (fieldId) {
+            const { raw, params } = getParams(this);
+            return omitAndDeleteField(makeRequest, { ...params, fieldId }, raw).then((data) => wrapContentType(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw content type data
+ * @return Wrapped content type data
+ */
+function wrapContentType(makeRequest, data) {
+    const contentType = toPlainObject(copy(data));
+    const contentTypeWithMethods = enhanceWithMethods(contentType, createContentTypeApi(makeRequest));
+    return freezeSys(contentTypeWithMethods);
+}
+/**
+ * @private
+ */
+const wrapContentTypeCollection = wrapCollection(wrapContentType);
+
+export { wrapContentType, wrapContentTypeCollection };

package/dist/types/entities/editor-interface.d.ts

@@ -0,0 +1,162 @@
+import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
+import type { DefinedParameters } from './widget-parameters.js';
+interface WidgetConfig {
+    /**
+     * Type of the widget used
+     */
+    widgetNamespace?: string;
+    /**
+     * ID of the widget used
+     */
+    widgetId?: string;
+    /**
+     * Instance parameter values
+     */
+    settings?: DefinedParameters;
+}
+export interface Control extends WidgetConfig {
+    /**
+     * ID of the customized field
+     */
+    fieldId: string;
+}
+export interface GroupControl extends WidgetConfig {
+    /**
+     * ID of the customized field group
+     */
+    groupId: string;
+}
+export interface FieldGroupItem {
+    groupId: string;
+    name: string;
+    items: EditorLayoutItem[];
+}
+export interface FieldItem {
+    fieldId: string;
+}
+export type EditorLayoutItem = FieldItem | FieldGroupItem;
+export interface Editor {
+    /**
+     * Type of the widget used
+     */
+    widgetNamespace: string;
+    /**
+     * ID of the widget used
+     */
+    widgetId: string;
+    /**
+     * Widget will be enabled if disabled property is missing
+     */
+    disabled?: boolean;
+    /**
+     * Instance parameter values
+     */
+    settings?: DefinedParameters;
+}
+export interface SidebarItem {
+    /**
+     * Type of the widget used
+     */
+    widgetNamespace: string;
+    /**
+     * ID of the widget used
+     */
+    widgetId: string;
+    /**
+     * Widget will be enabled if disabled property is missing
+     */
+    disabled?: boolean;
+    /**
+     * Instance parameter values
+     */
+    settings?: DefinedParameters;
+}
+export type EditorInterfaceProps = {
+    sys: MetaSysProps & {
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+        contentType: Link<'ContentType'>;
+    };
+    /**
+     * Array of fields and their associated widgetId
+     */
+    controls?: Control[];
+    /**
+     * Array of field groups and their associated widgetId
+     */
+    groupControls?: GroupControl[];
+    /**
+     * Array of editors. Defaults will be used if property is missing.
+     */
+    editors?: Editor[];
+    /**
+     * Legacy singular editor override
+     */
+    editor?: Editor;
+    /**
+     * Array of editor layout field groups
+     */
+    editorLayout?: FieldGroupItem[];
+    /**
+     * Array of sidebar widgets. Defaults will be used if property is missing.
+     */
+    sidebar?: SidebarItem[];
+};
+export interface EditorInterface extends EditorInterfaceProps, DefaultElements<EditorInterfaceProps> {
+    /**
+     * Gets a control for a specific field
+     * @return control object for specific field
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.getEditorInterface())
+     * .then((editorInterface) => {
+     *  control = editorInterface.getControlForField('<field-id>')
+     *  console.log(control)
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    getControlForField(id: string): null | Control;
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.getEditorInterface())
+     * .then((editorInterface) => {
+     *  editorInterface.controls[0] = { "fieldId": "title", "widgetId": "singleLine"}
+     *  editorInterface.editors = [
+     *    { "widgetId": "custom-widget", "widgetNamespace": "app" }
+     *  ]
+     *  return editorInterface.update()
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<EditorInterface>;
+}
+/**
+ * @private
+ */
+export declare function wrapEditorInterface(makeRequest: MakeRequest, data: EditorInterfaceProps): EditorInterface;
+/**
+ * @private
+ */
+export declare const wrapEditorInterfaceCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<EditorInterfaceProps>) => import("../common-types.js").Collection<EditorInterface, EditorInterfaceProps>;
+export {};