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

package/dist/types/entities/app-definition.d.ts

@@ -1,10 +1,10 @@
-import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types';
-import type { ContentfulAppDefinitionAPI } from '../create-app-definition-api';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
+import type { ContentfulAppDefinitionAPI } from '../create-app-definition-api.js';
 import type { SetOptional, Except } from 'type-fest';
-import type { FieldType } from './field-type';
-import type { InstallationParameterType, ParameterDefinition } from './widget-parameters';
-import type { AppInstallationProps } from './app-installation';
-import type { EnvironmentProps } from './environment';
+import type { FieldType } from './field-type.js';
+import type { InstallationParameterType, ParameterDefinition } from './widget-parameters.js';
+import type { AppInstallationProps } from './app-installation.js';
+import type { EnvironmentProps } from './environment.js';
 export interface NavigationItem {
     name: string;
     path: string;
@@ -78,5 +78,5 @@ export declare function wrapAppDefinition(makeRequest: MakeRequest, data: AppDef
  * @param data - Raw App Definition collection data
  * @return Wrapped App Definition collection data
  */
-export declare const wrapAppDefinitionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppDefinitionProps>) => import("../common-types").Collection<AppDefinition, AppDefinitionProps>;
+export declare const wrapAppDefinitionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppDefinitionProps>) => import("../common-types.js").Collection<AppDefinition, AppDefinitionProps>;
 export {};

package/dist/types/entities/app-definition.js

@@ -0,0 +1,26 @@
+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';
+import createAppDefinitionApi from '../create-app-definition-api.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition data
+ * @return Wrapped App Definition data
+ */
+function wrapAppDefinition(makeRequest, data) {
+    const appDefinition = toPlainObject(copy(data));
+    const appDefinitionWithMethods = enhanceWithMethods(appDefinition, createAppDefinitionApi(makeRequest));
+    return freezeSys(appDefinitionWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition collection data
+ * @return Wrapped App Definition collection data
+ */
+const wrapAppDefinitionCollection = wrapCollection(wrapAppDefinition);
+
+export { wrapAppDefinition, wrapAppDefinitionCollection };

package/dist/types/entities/app-details.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
 type AppDetailsSys = Except<BasicMetaSysProps<'AppDetails', 'User'>, 'version' | 'id'> & {
     appDefinition: Link<'AppDefinition'>;
     organization: Link<'Organization'>;

package/dist/types/entities/app-details.js

@@ -0,0 +1,37 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @return Wrapped App Details data
+ */
+function createAppDetailsApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+    });
+    return {
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AppDetails',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppDetails data
+ * @return Wrapped AppDetails data
+ */
+function wrapAppDetails(makeRequest, data) {
+    const appDetails = toPlainObject(copy(data));
+    return enhanceWithMethods(appDetails, createAppDetailsApi(makeRequest));
+}
+
+export { wrapAppDetails };

package/dist/types/entities/app-event-subscription.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
 type AppEventSubscriptionSys = Except<BasicMetaSysProps<'AppEventSubscription', 'User'>, 'version' | 'id'> & {
     appDefinition: Link<'AppDefinition'>;
     organization: Link<'Organization'>;

package/dist/types/entities/app-event-subscription.js

@@ -0,0 +1,32 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+function createEventSubscriptionApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+    });
+    return {
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AppEventSubscription',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppEventSubscription data
+ * @return Wrapped AppEventSubscription data
+ */
+function wrapAppEventSubscription(makeRequest, data) {
+    const eventSubscription = toPlainObject(copy(data));
+    return enhanceWithMethods(eventSubscription, createEventSubscriptionApi(makeRequest));
+}
+
+export { wrapAppEventSubscription };

package/dist/types/entities/app-installation.d.ts

@@ -1,6 +1,6 @@
-import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
 import type { Except } from 'type-fest';
-import type { FreeFormParameters } from './widget-parameters';
+import type { FreeFormParameters } from './widget-parameters.js';
 export type AppInstallationProps = {
     sys: Omit<BasicMetaSysProps<'AppInstallation', 'User'>, 'id'> & {
         appDefinition: Link<'AppDefinition'>;
@@ -67,4 +67,4 @@ export declare function wrapAppInstallation(makeRequest: MakeRequest, data: AppI
 /**
  * @private
  */
-export declare const wrapAppInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppInstallationProps>) => import("../common-types").Collection<AppInstallation, AppInstallationProps>;
+export declare const wrapAppInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppInstallationProps>) => import("../common-types.js").Collection<AppInstallation, AppInstallationProps>;

package/dist/types/entities/app-installation.js

@@ -0,0 +1,52 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createAppInstallationApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        environmentId: data.sys.environment.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppInstallation',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: data,
+            }).then((data) => wrapAppInstallation(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppInstallation',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Installation data
+ * @return Wrapped App installation data
+ */
+function wrapAppInstallation(makeRequest, data) {
+    const appInstallation = toPlainObject(copy(data));
+    const appInstallationWithMethods = enhanceWithMethods(appInstallation, createAppInstallationApi(makeRequest));
+    return freezeSys(appInstallationWithMethods);
+}
+/**
+ * @private
+ */
+const wrapAppInstallationCollection = wrapCollection(wrapAppInstallation);
+
+export { wrapAppInstallation, wrapAppInstallationCollection };

package/dist/types/entities/app-key.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
 type AppKeySys = Except<BasicMetaSysProps<'AppKey', 'User'>, 'version'> & {
     appDefinition: Link<'AppDefinition'>;
     organization: Link<'Organization'>;
@@ -73,5 +73,5 @@ export declare function wrapAppKey(makeRequest: MakeRequest, data: AppKeyProps):
  * @param data - Raw App Key collection data
  * @return Wrapped App Key collection data
  */
-export declare const wrapAppKeyCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppKeyProps>) => import("../common-types").Collection<AppKey, AppKeyProps>;
+export declare const wrapAppKeyCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppKeyProps>) => import("../common-types.js").Collection<AppKey, AppKeyProps>;
 export {};

package/dist/types/entities/app-key.js

@@ -0,0 +1,41 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+function createKeyApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+        fingerprint: data.sys.id,
+    });
+    return {
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AppKey',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppKey data
+ * @return Wrapped AppKey data
+ */
+function wrapAppKey(makeRequest, data) {
+    const key = toPlainObject(copy(data));
+    return enhanceWithMethods(key, createKeyApi(makeRequest));
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Key collection data
+ * @return Wrapped App Key collection data
+ */
+const wrapAppKeyCollection = wrapCollection(wrapAppKey);
+
+export { wrapAppKey, wrapAppKeyCollection };

package/dist/types/entities/app-signed-request.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
 type AppSignedRequestSys = Except<BasicMetaSysProps<'AppSignedRequest', 'User'>, 'version' | 'id'> & {
     appDefinition: Link<'AppDefinition'>;
     space: Link<'Space'>;

package/dist/types/entities/app-signed-request.js

@@ -0,0 +1,15 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppSignedRequest data
+ * @return Wrapped AppSignedRequest data
+ */
+function wrapAppSignedRequest(_makeRequest, data) {
+    const signedRequest = toPlainObject(copy(data));
+    return signedRequest;
+}
+
+export { wrapAppSignedRequest };

package/dist/types/entities/app-signing-secret.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
 type AppSigningSecretSys = Except<BasicMetaSysProps<'AppSigningSecret', 'User'>, 'version' | 'id'> & {
     appDefinition: Link<'AppDefinition'>;
     organization: Link<'Organization'>;

package/dist/types/entities/app-signing-secret.js

@@ -0,0 +1,32 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+function createSigningSecretApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+    });
+    return {
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AppSigningSecret',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppSigningSecret data
+ * @return Wrapped AppSigningSecret data
+ */
+function wrapAppSigningSecret(makeRequest, data) {
+    const signingSecret = toPlainObject(copy(data));
+    return enhanceWithMethods(signingSecret, createSigningSecretApi(makeRequest));
+}
+
+export { wrapAppSigningSecret };

package/dist/types/entities/app-upload.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
 type AppUploadSys = Except<BasicMetaSysProps<'AppUpload', 'User'>, 'version'>;
 export type AppUploadProps = {
     sys: AppUploadSys & {
@@ -40,5 +40,5 @@ export declare function wrapAppUpload(makeRequest: MakeRequest, data: AppUploadP
  * @param data - Raw App Upload collection data
  * @return Wrapped App Upload collection data
  */
-export declare const wrapAppUploadCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppUploadProps>) => import("../common-types").Collection<AppUpload, AppUploadProps>;
+export declare const wrapAppUploadCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppUploadProps>) => import("../common-types.js").Collection<AppUpload, AppUploadProps>;
 export {};

package/dist/types/entities/app-upload.js

@@ -0,0 +1,36 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createAppUploadApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appUploadId: data.sys.id,
+    });
+    return {
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppUpload',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Upload data
+ * @return Wrapped App Upload data
+ */
+function wrapAppUpload(makeRequest, data) {
+    const appUpload = toPlainObject(copy(data));
+    const appUploadWithMethods = enhanceWithMethods(appUpload, createAppUploadApi(makeRequest));
+    return freezeSys(appUploadWithMethods);
+}
+
+export { wrapAppUpload };

package/dist/types/entities/asset-key.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultElements, MakeRequest } from '../common-types';
+import type { DefaultElements, MakeRequest } from '../common-types.js';
 export type AssetKeyProps = {
     /** A JWT describing a policy; needs to be attached to signed URLs */
     policy: string;

package/dist/types/entities/asset-key.js

@@ -0,0 +1,15 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw asset key data
+ * @return Wrapped asset key data
+ */
+function wrapAssetKey(_makeRequest, data) {
+    const assetKey = toPlainObject(copy(data));
+    return assetKey;
+}
+
+export { wrapAssetKey };

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

@@ -1,5 +1,5 @@
 import type { Stream } from 'stream';
-import type { DefaultElements, EntityMetaSysProps, MetadataProps, MakeRequest } from '../common-types';
+import type { DefaultElements, EntityMetaSysProps, MetadataProps, MakeRequest } from '../common-types.js';
 export type AssetProps = {
     sys: EntityMetaSysProps;
     fields: {
@@ -273,5 +273,5 @@ export declare function wrapAsset(makeRequest: MakeRequest, data: AssetProps): A
 /**
  * @private
  */
-export declare const wrapAssetCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AssetProps>) => import("../common-types").Collection<Asset, AssetProps>;
+export declare const wrapAssetCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AssetProps>) => import("../common-types.js").Collection<Asset, AssetProps>;
 export {};

package/dist/types/entities/asset.js

@@ -0,0 +1,129 @@
+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';
+import { isPublished, isUpdated, isDraft, isArchived } from '../plain/checks.js';
+
+/**
+ * @private
+ */
+function createAssetApi(makeRequest) {
+    const getParams = (raw) => {
+        return {
+            spaceId: raw.sys.space.sys.id,
+            environmentId: raw.sys.environment.sys.id,
+            assetId: raw.sys.id,
+        };
+    };
+    return {
+        processForLocale: function processForLocale(locale, options) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'processForLocale',
+                params: {
+                    ...getParams(raw),
+                    locale,
+                    options,
+                    asset: raw,
+                },
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        processForAllLocales: function processForAllLocales(options) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'processForAllLocales',
+                params: {
+                    ...getParams(raw),
+                    asset: raw,
+                    options,
+                },
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        update: function update() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+                headers: {},
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+        publish: function publish() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'publish',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        unpublish: function unpublish() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'unpublish',
+                params: getParams(raw),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        archive: function archive() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'archive',
+                params: getParams(raw),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        unarchive: function unarchive() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'unarchive',
+                params: getParams(raw),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        isPublished: function isPublished$1() {
+            const raw = this.toPlainObject();
+            return isPublished(raw);
+        },
+        isUpdated: function isUpdated$1() {
+            const raw = this.toPlainObject();
+            return isUpdated(raw);
+        },
+        isDraft: function isDraft$1() {
+            const raw = this.toPlainObject();
+            return isDraft(raw);
+        },
+        isArchived: function isArchived$1() {
+            const raw = this.toPlainObject();
+            return isArchived(raw);
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw asset data
+ * @return Wrapped asset data
+ */
+function wrapAsset(makeRequest, data) {
+    const asset = toPlainObject(copy(data));
+    const assetWithMethods = enhanceWithMethods(asset, createAssetApi(makeRequest));
+    return freezeSys(assetWithMethods);
+}
+/**
+ * @private
+ */
+const wrapAssetCollection = wrapCollection(wrapAsset);
+
+export { wrapAsset, wrapAssetCollection };

package/dist/types/entities/bulk-action.d.ts

@@ -1,5 +1,5 @@
-import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest, MakeRequestPayload, VersionedLink } from '../common-types';
-import type { AsyncActionProcessingOptions } from '../methods/action';
+import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest, MakeRequestPayload, VersionedLink } from '../common-types.js';
+import type { AsyncActionProcessingOptions } from '../methods/action.js';
 /** Entity types supported by the BulkAction API */
 type Entity = 'Entry' | 'Asset';
 type Collection<T> = Array<T>;

package/dist/types/entities/bulk-action.js

@@ -0,0 +1,58 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { pollAsyncActionStatus } from '../methods/action.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Represents the state of the BulkAction */
+var BulkActionStatus;
+(function (BulkActionStatus) {
+    /** BulkAction is pending execution */
+    BulkActionStatus["created"] = "created";
+    /** BulkAction has been started and pending completion */
+    BulkActionStatus["inProgress"] = "inProgress";
+    /** BulkAction was completed successfully (terminal state) */
+    BulkActionStatus["succeeded"] = "succeeded";
+    /** BulkAction failed to complete (terminal state) */
+    BulkActionStatus["failed"] = "failed";
+})(BulkActionStatus || (BulkActionStatus = {}));
+Object.values(BulkActionStatus);
+/**
+ * @private
+ */
+function createBulkActionApi(makeRequest) {
+    const getParams = (self) => {
+        const bulkAction = self.toPlainObject();
+        return {
+            spaceId: bulkAction.sys.space.sys.id,
+            environmentId: bulkAction.sys.environment.sys.id,
+            bulkActionId: bulkAction.sys.id,
+        };
+    };
+    return {
+        async get() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'BulkAction',
+                action: 'get',
+                params,
+            }).then((bulkAction) => wrapBulkAction(makeRequest, bulkAction));
+        },
+        async waitProcessing(options) {
+            return pollAsyncActionStatus(async () => this.get(), options);
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw BulkAction data
+ * @return Wrapped BulkAction data
+ */
+function wrapBulkAction(makeRequest, data) {
+    const bulkAction = toPlainObject(copy(data));
+    const bulkActionWithApiMethods = enhanceWithMethods(bulkAction, createBulkActionApi(makeRequest));
+    return freezeSys(bulkActionWithApiMethods);
+}
+
+export { BulkActionStatus, wrapBulkAction };

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

@@ -1,5 +1,5 @@
 import type { Node, Text } from '@contentful/rich-text-types';
-import type { BasicMetaSysProps, DefaultElements, GetCommentParams, GetEntryParams, GetSpaceEnvironmentParams, Link, MakeRequest, VersionedLink } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, GetCommentParams, GetEntryParams, GetSpaceEnvironmentParams, Link, MakeRequest, VersionedLink } from '../common-types.js';
 interface LinkWithReference<T extends string> extends Link<T> {
     sys: Link<T>['sys'] & {
         ref: string;
@@ -98,5 +98,5 @@ export declare function wrapComment(makeRequest: MakeRequest, data: CommentProps
 /**
  * @private
  */
-export declare const wrapCommentCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<CommentProps | RichTextCommentProps>) => import("../common-types").Collection<Comment | RichTextComment, CommentProps | RichTextCommentProps>;
+export declare const wrapCommentCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<CommentProps | RichTextCommentProps>) => import("../common-types.js").Collection<Comment | RichTextComment, CommentProps | RichTextCommentProps>;
 export {};