contentful-management 12.0.0-beta.7 → 12.0.0-beta.9

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

@@ -1,6 +1,6 @@
-import type { Link } from '../common-types';
-import type { TaxonomyConceptLink } from './concept';
-import type { LocalizedEntity } from './utils';
+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;

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

@@ -1,5 +1,5 @@
-import type { Link } from '../common-types';
-import type { LocalizedEntity } from './utils';
+import type { Link } from '../common-types.js';
+import type { LocalizedEntity } from './utils.js';
 export type TaxonomyConceptLink = Link<'TaxonomyConcept'>;
 type Concept = {
     uri: string | null;

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

@@ -1,4 +1,4 @@
-import type { KeyValueMap } from '../common-types';
+import type { KeyValueMap } from '../common-types.js';
 import type { INLINES, BLOCKS } from '@contentful/rich-text-types';
 interface NumRange {
     min?: number;

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

@@ -1,8 +1,8 @@
 import type { Except, RequireAtLeastOne, SetOptional } from 'type-fest';
-import type { BasicMetaSysProps, Collection, DefaultElements, Link, MakeRequest } from '../common-types';
-import type { ContentFields } from './content-type-fields';
-import type { EditorInterface } from './editor-interface';
-import type { Snapshot, SnapshotProps } from './snapshot';
+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;
 };
@@ -209,5 +209,5 @@ export declare function wrapContentType(makeRequest: MakeRequest, data: ContentT
 /**
  * @private
  */
-export declare const wrapContentTypeCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<ContentTypeProps>) => Collection<ContentType, ContentTypeProps>;
+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

@@ -1,5 +1,5 @@
-import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types';
-import type { DefinedParameters } from './widget-parameters';
+import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
+import type { DefinedParameters } from './widget-parameters.js';
 interface WidgetConfig {
     /**
      * Type of the widget used
@@ -158,5 +158,5 @@ export declare function wrapEditorInterface(makeRequest: MakeRequest, data: Edit
 /**
  * @private
  */
-export declare const wrapEditorInterfaceCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<EditorInterfaceProps>) => import("../common-types").Collection<EditorInterface, EditorInterfaceProps>;
+export declare const wrapEditorInterfaceCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<EditorInterfaceProps>) => import("../common-types.js").Collection<EditorInterface, EditorInterfaceProps>;
 export {};

package/dist/types/entities/editor-interface.js

@@ -0,0 +1,47 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createEditorInterfaceApi(makeRequest) {
+    return {
+        update: function () {
+            const self = this;
+            const raw = self.toPlainObject();
+            return makeRequest({
+                entityType: 'EditorInterface',
+                action: 'update',
+                params: {
+                    spaceId: self.sys.space.sys.id,
+                    environmentId: self.sys.environment.sys.id,
+                    contentTypeId: self.sys.contentType.sys.id,
+                },
+                payload: raw,
+            }).then((response) => wrapEditorInterface(makeRequest, response));
+        },
+        getControlForField: function (fieldId) {
+            const self = this;
+            const result = (self.controls || []).filter((control) => {
+                return control.fieldId === fieldId;
+            });
+            return result && result.length > 0 ? result[0] : null;
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapEditorInterface(makeRequest, data) {
+    const editorInterface = toPlainObject(copy(data));
+    const editorInterfaceWithMethods = enhanceWithMethods(editorInterface, createEditorInterfaceApi(makeRequest));
+    return freezeSys(editorInterfaceWithMethods);
+}
+/**
+ * @private
+ */
+const wrapEditorInterfaceCollection = wrapCollection(wrapEditorInterface);
+
+export { wrapEditorInterface, wrapEditorInterfaceCollection };

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

@@ -1,6 +1,6 @@
-import type { CollectionProp, DefaultElements, EntityMetaSysProps, KeyValueMap, Link, MakeRequest, MetadataProps } from '../common-types';
-import type { ContentfulEntryApi } from '../create-entry-api';
-import type { AssetProps } from './asset';
+import type { CollectionProp, DefaultElements, EntityMetaSysProps, KeyValueMap, Link, MakeRequest, MetadataProps } from '../common-types.js';
+import type { ContentfulEntryApi } from '../create-entry-api.js';
+import type { AssetProps } from './asset.js';
 export interface EntryMetaSysProps extends EntityMetaSysProps {
     contentType: Link<'ContentType'>;
     automationTags: Link<'Tag'>[];
@@ -54,4 +54,4 @@ export declare function wrapEntry(makeRequest: MakeRequest, data: EntryProps): E
  * Data is also mixed in with link getters if links exist and includes were requested
  * @private
  */
-export declare const wrapEntryCollection: (makeRequest: MakeRequest, data: CollectionProp<EntryProps<KeyValueMap>>) => import("../common-types").Collection<Entry, EntryProps<KeyValueMap>>;
+export declare const wrapEntryCollection: (makeRequest: MakeRequest, data: CollectionProp<EntryProps<KeyValueMap>>) => import("../common-types.js").Collection<Entry, EntryProps<KeyValueMap>>;

package/dist/types/entities/entry.js

@@ -0,0 +1,24 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import createEntryApi from '../create-entry-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw entry data
+ * @return Wrapped entry data
+ */
+function wrapEntry(makeRequest, data) {
+    const entry = toPlainObject(copy(data));
+    const entryWithMethods = enhanceWithMethods(entry, createEntryApi(makeRequest));
+    return freezeSys(entryWithMethods);
+}
+/**
+ * Data is also mixed in with link getters if links exist and includes were requested
+ * @private
+ */
+const wrapEntryCollection = wrapCollection(wrapEntry);
+
+export { wrapEntry, wrapEntryCollection };

package/dist/types/entities/environment-alias.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
 export type EnvironmentAliasProps = {
     /**
      * System meta data
@@ -69,4 +69,4 @@ export declare function wrapEnvironmentAlias(makeRequest: MakeRequest, data: Env
  * @param data - Raw environment alias collection data
  * @return Wrapped environment alias collection data
  */
-export declare const wrapEnvironmentAliasCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<EnvironmentAliasProps>) => import("../common-types").Collection<EnvironmentAlias, EnvironmentAliasProps>;
+export declare const wrapEnvironmentAliasCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<EnvironmentAliasProps>) => import("../common-types.js").Collection<EnvironmentAlias, EnvironmentAliasProps>;

package/dist/types/entities/environment-alias.js

@@ -0,0 +1,55 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createEnvironmentAliasApi(makeRequest) {
+    const getParams = (alias) => ({
+        spaceId: alias.sys.space.sys.id,
+        environmentAliasId: alias.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentAlias',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapEnvironmentAlias(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentAlias',
+                action: 'delete',
+                params: getParams(raw),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias data
+ * @return Wrapped environment alias data
+ */
+function wrapEnvironmentAlias(makeRequest, data) {
+    const alias = toPlainObject(copy(data));
+    const enhancedAlias = enhanceWithMethods(alias, createEnvironmentAliasApi(makeRequest));
+    return freezeSys(enhancedAlias);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias collection data
+ * @return Wrapped environment alias collection data
+ */
+const wrapEnvironmentAliasCollection = wrapCollection(wrapEnvironmentAlias);
+
+export { wrapEnvironmentAlias, wrapEnvironmentAliasCollection };

package/dist/types/entities/environment-template-installation.d.ts

@@ -1,4 +1,4 @@
-import type { BasicMetaSysProps, DefaultElements, ISO8601Timestamp, Link, MakeRequest, VersionedLink } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, ISO8601Timestamp, Link, MakeRequest, VersionedLink } from '../common-types.js';
 type JsonObject = {
     [Key in string]?: JsonValue;
 };
@@ -52,5 +52,5 @@ export type EnvironmentTemplateValidationProps<T = ValidationFinding> = {
 };
 export type EnvironmentTemplateInstallation = EnvironmentTemplateInstallationProps & DefaultElements<EnvironmentTemplateInstallationProps>;
 export declare function wrapEnvironmentTemplateInstallation(makeRequest: MakeRequest, data: EnvironmentTemplateInstallationProps): EnvironmentTemplateInstallation;
-export declare const wrapEnvironmentTemplateInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types").CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>) => import("../common-types").CursorPaginatedCollection<EnvironmentTemplateInstallation, EnvironmentTemplateInstallationProps>;
+export declare const wrapEnvironmentTemplateInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>) => import("../common-types.js").CursorPaginatedCollection<EnvironmentTemplateInstallation, EnvironmentTemplateInstallationProps>;
 export {};

package/dist/types/entities/environment-template-installation.js

@@ -0,0 +1,20 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+
+var EnvironmentTemplateInstallationStatuses;
+(function (EnvironmentTemplateInstallationStatuses) {
+    EnvironmentTemplateInstallationStatuses["created"] = "created";
+    EnvironmentTemplateInstallationStatuses["inProgress"] = "inProgress";
+    EnvironmentTemplateInstallationStatuses["failed"] = "failed";
+    EnvironmentTemplateInstallationStatuses["succeeded"] = "succeeded";
+    EnvironmentTemplateInstallationStatuses["disconnected"] = "disconnected";
+    EnvironmentTemplateInstallationStatuses["inRetry"] = "inRetry";
+})(EnvironmentTemplateInstallationStatuses || (EnvironmentTemplateInstallationStatuses = {}));
+function wrapEnvironmentTemplateInstallation(makeRequest, data) {
+    const environmentTemplate = toPlainObject(copy(data));
+    return freezeSys(environmentTemplate);
+}
+const wrapEnvironmentTemplateInstallationCollection = wrapCursorPaginatedCollection(wrapEnvironmentTemplateInstallation);
+
+export { wrapEnvironmentTemplateInstallation, wrapEnvironmentTemplateInstallationCollection };

package/dist/types/entities/environment-template.d.ts

@@ -1,7 +1,7 @@
-import type { BasicMetaSysProps, Link, MakeRequest, DefaultElements } from '../common-types';
-import type { ContentfulEnvironmentTemplateApi } from '../create-environment-template-api';
-import type { ContentTypeProps } from './content-type';
-import type { EditorInterfaceProps } from './editor-interface';
+import type { BasicMetaSysProps, Link, MakeRequest, DefaultElements } from '../common-types.js';
+import type { ContentfulEnvironmentTemplateApi } from '../create-environment-template-api.js';
+import type { ContentTypeProps } from './content-type.js';
+import type { EditorInterfaceProps } from './editor-interface.js';
 export type Hint = {
     operation: 'renameFieldId';
     fieldId: string;
@@ -32,8 +32,9 @@ export type EnvironmentTemplateProps = {
         contentTypeTemplates: Array<ContentTypeTemplateProps>;
         editorInterfaceTemplates: Array<EditorInterfaceTemplateProps>;
     };
+    forTemplatedSpaces?: boolean;
 };
 export type CreateEnvironmentTemplateProps = Omit<EnvironmentTemplateProps, 'sys'>;
 export type EnvironmentTemplate = EnvironmentTemplateProps & DefaultElements<EnvironmentTemplateProps> & ContentfulEnvironmentTemplateApi;
 export declare function wrapEnvironmentTemplate(makeRequest: MakeRequest, data: EnvironmentTemplateProps, organizationId: string): EnvironmentTemplate;
-export declare const wrapEnvironmentTemplateCollection: (makeRequest: MakeRequest, data: import("../common-types").CursorPaginatedCollectionProp<EnvironmentTemplateProps>, organizationId: string) => import("../common-types").CursorPaginatedCollection<EnvironmentTemplate, EnvironmentTemplateProps>;
+export declare const wrapEnvironmentTemplateCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CursorPaginatedCollectionProp<EnvironmentTemplateProps>, organizationId: string) => import("../common-types.js").CursorPaginatedCollection<EnvironmentTemplate, EnvironmentTemplateProps>;

package/dist/types/entities/environment-template.js

@@ -0,0 +1,15 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+import { createEnvironmentTemplateApi } from '../create-environment-template-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+function wrapEnvironmentTemplate(makeRequest, data, organizationId) {
+    const environmentTemplate = toPlainObject(copy(data));
+    const environmentTemplateApi = createEnvironmentTemplateApi(makeRequest, organizationId);
+    const enhancedEnvironmentTemplate = enhanceWithMethods(environmentTemplate, environmentTemplateApi);
+    return freezeSys(enhancedEnvironmentTemplate);
+}
+const wrapEnvironmentTemplateCollection = wrapCursorPaginatedCollection(wrapEnvironmentTemplate);
+
+export { wrapEnvironmentTemplate, wrapEnvironmentTemplateCollection };

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

@@ -1,5 +1,5 @@
-import type { ContentfulEnvironmentAPI } from '../create-environment-api';
-import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types';
+import type { ContentfulEnvironmentAPI } from '../create-environment-api.js';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
 type EnvironmentMetaSys = BasicMetaSysProps<'EnvironmentMeta', 'User'> & {
     status: Link<'Status'>;
     space: Link<'Space'>;
@@ -34,5 +34,5 @@ export declare function wrapEnvironment(makeRequest: MakeRequest, data: Environm
  * above for more details.
  * @private
  */
-export declare const wrapEnvironmentCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<EnvironmentProps>) => import("../common-types").Collection<Environment, EnvironmentProps>;
+export declare const wrapEnvironmentCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<EnvironmentProps>) => import("../common-types.js").Collection<Environment, EnvironmentProps>;
 export {};

package/dist/types/entities/environment.js

@@ -0,0 +1,31 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import createEnvironmentApi from '../create-environment-api.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * This method creates the API for the given environment with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a environment id, so the base path for requests now has the
+ * environment id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Environment
+ * @return
+ */
+function wrapEnvironment(makeRequest, data) {
+    // do not pollute generated typings
+    const environment = toPlainObject(copy(data));
+    const environmentApi = createEnvironmentApi(makeRequest);
+    const enhancedEnvironment = enhanceWithMethods(environment, environmentApi);
+    return freezeSys(enhancedEnvironment);
+}
+/**
+ * This method wraps each environment in a collection with the environment API. See wrapEnvironment
+ * above for more details.
+ * @private
+ */
+const wrapEnvironmentCollection = wrapCollection(wrapEnvironment);
+
+export { wrapEnvironment, wrapEnvironmentCollection };

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

@@ -1,6 +1,6 @@
-import type { FieldType } from './field-type';
-import type { DefinedParameters, InstallationParameterType, ParameterDefinition } from './widget-parameters';
-import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types';
+import type { FieldType } from './field-type.js';
+import type { DefinedParameters, InstallationParameterType, ParameterDefinition } from './widget-parameters.js';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
 import type { SetRequired, RequireExactlyOne } from 'type-fest';
 type ExtensionSysProps = BasicMetaSysProps<'Extension', 'User'> & {
     space: Link<'Space'>;
@@ -99,5 +99,5 @@ export declare function wrapExtension(makeRequest: MakeRequest, data: ExtensionP
 /**
  * @private
  */
-export declare const wrapExtensionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<ExtensionProps>) => import("../common-types").Collection<Extension, ExtensionProps>;
+export declare const wrapExtensionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<ExtensionProps>) => import("../common-types.js").Collection<Extension, ExtensionProps>;
 export {};

package/dist/types/entities/extension.js

@@ -0,0 +1,51 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createExtensionApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        environmentId: data.sys.environment.sys.id,
+        extensionId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Extension',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((response) => wrapExtension(makeRequest, response));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Extension',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw UI Extension data
+ * @return Wrapped UI Extension data
+ */
+function wrapExtension(makeRequest, data) {
+    const extension = toPlainObject(copy(data));
+    const extensionWithMethods = enhanceWithMethods(extension, createExtensionApi(makeRequest));
+    return freezeSys(extensionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapExtensionCollection = wrapCollection(wrapExtension);
+
+export { wrapExtension, wrapExtensionCollection };

package/dist/types/entities/function-log.d.ts

@@ -1,5 +1,5 @@
-import type { Link, DefaultElements } from '../common-types';
-import type { MakeRequest } from '../common-types';
+import type { Link, DefaultElements } from '../common-types.js';
+import type { MakeRequest } from '../common-types.js';
 export type FunctionLogProps = {
     sys: {
         id: string;
@@ -43,4 +43,4 @@ export declare function wrapFunctionLog(makeRequest: MakeRequest, data: Function
  * @param data - raw contentful-function data
  * @return Wrapped App Function collection data
  */
-export declare const wrapFunctionLogCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<FunctionLogProps>) => import("../common-types").Collection<FunctionLogProps, FunctionLogProps>;
+export declare const wrapFunctionLogCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<FunctionLogProps>) => import("../common-types.js").Collection<FunctionLogProps, FunctionLogProps>;

package/dist/types/entities/function-log.js

@@ -0,0 +1,23 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+function wrapFunctionLog(makeRequest, data) {
+    const functionLog = toPlainObject(copy(data));
+    return freezeSys(functionLog);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-function data
+ * @return Wrapped App Function collection data
+ */
+const wrapFunctionLogCollection = wrapCollection(wrapFunctionLog);
+
+export { wrapFunctionLog, wrapFunctionLogCollection };

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

@@ -1,5 +1,5 @@
-import type { Link, DefaultElements } from '../common-types';
-import type { MakeRequest } from '../common-types';
+import type { Link, DefaultElements } from '../common-types.js';
+import type { MakeRequest } from '../common-types.js';
 export type FunctionProps = {
     sys: {
         id: string;
@@ -29,4 +29,4 @@ export declare function wrapFunction(makeRequest: MakeRequest, data: FunctionPro
 /**
  * @private
  */
-export declare const wrapFunctionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<FunctionProps>) => import("../common-types").Collection<FunctionProps, FunctionProps>;
+export declare const wrapFunctionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<FunctionProps>) => import("../common-types.js").Collection<FunctionProps, FunctionProps>;