contentful-management 12.0.0-beta.1 → 12.0.0-beta.11

package/dist/types/entities/personal-access-token.js

@@ -0,0 +1,33 @@
+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
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  personal access token data
+ * @return Wrapped personal access token
+ */
+function wrapPersonalAccessToken(makeRequest, data) {
+    const personalAccessToken = toPlainObject(copy(data));
+    const personalAccessTokenWithMethods = enhanceWithMethods(personalAccessToken, {
+        revoke: function () {
+            return makeRequest({
+                entityType: 'PersonalAccessToken',
+                action: 'revoke',
+                params: { tokenId: data.sys.id },
+            }).then((data) => wrapPersonalAccessToken(makeRequest, data));
+        },
+    });
+    return freezeSys(personalAccessTokenWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw personal access collection data
+ * @return Wrapped personal access token collection data
+ */
+const wrapPersonalAccessTokenCollection = wrapCollection(wrapPersonalAccessToken);
+
+export { wrapPersonalAccessToken, wrapPersonalAccessTokenCollection };

package/dist/types/entities/preview-api-key.d.ts

@@ -1,6 +1,6 @@
-import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types';
+import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types.js';
 export type PreviewApiKeyProps = {
-    sys: MetaSysProps<'User'>;
+    sys: MetaSysProps;
     name: string;
     description: string;
     accessToken: string;
@@ -17,4 +17,4 @@ export declare function wrapPreviewApiKey(_makeRequest: MakeRequest, data: Previ
 /**
  * @private
  */
-export declare const wrapPreviewApiKeyCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<PreviewApiKeyProps>) => import("../common-types").Collection<PreviewApiKey, PreviewApiKeyProps>;
+export declare const wrapPreviewApiKeyCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<PreviewApiKeyProps>) => import("../common-types.js").Collection<PreviewApiKey, PreviewApiKeyProps>;

package/dist/types/entities/preview-api-key.js

@@ -0,0 +1,28 @@
+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';
+
+/**
+ * @private
+ */
+function createPreviewApiKeyApi() {
+    return {};
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key data
+ * @return Wrapped preview api key data
+ */
+function wrapPreviewApiKey(_makeRequest, data) {
+    const previewApiKey = toPlainObject(copy(data));
+    const previewApiKeyWithMethods = enhanceWithMethods(previewApiKey, createPreviewApiKeyApi());
+    return freezeSys(previewApiKeyWithMethods);
+}
+/**
+ * @private
+ */
+const wrapPreviewApiKeyCollection = wrapCollection(wrapPreviewApiKey);
+
+export { wrapPreviewApiKey, wrapPreviewApiKeyCollection };

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

@@ -1,5 +1,5 @@
-import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest } from '../common-types';
-import type { AsyncActionProcessingOptions } from '../methods/action';
+import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest } from '../common-types.js';
+import type { AsyncActionProcessingOptions } from '../methods/action.js';
 type ReleaseActionStatuses = 'created' | 'inProgress' | 'failed' | 'succeeded';
 export type ReleaseActionTypes = 'publish' | 'unpublish' | 'validate';
 export type ReleaseActionSysProps = {
@@ -54,5 +54,5 @@ export declare function wrapReleaseAction(makeRequest: MakeRequest, data: Releas
 /**
  * @private
  */
-export declare const wrapReleaseActionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<ReleaseActionProps<any>>) => import("../common-types").Collection<ReleaseAction<any>, ReleaseActionProps<any>>;
+export declare const wrapReleaseActionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<ReleaseActionProps<any>>) => import("../common-types.js").Collection<ReleaseAction<any>, ReleaseActionProps<any>>;
 export {};

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

@@ -0,0 +1,52 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import { pollAsyncActionStatus } from '../methods/action.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * @private
+ */
+function createReleaseActionApi(makeRequest) {
+    const getParams = (self) => {
+        const action = self.toPlainObject();
+        return {
+            spaceId: action.sys.space.sys.id,
+            environmentId: action.sys.environment.sys.id,
+            releaseId: action.sys.release.sys.id,
+            actionId: action.sys.id,
+        };
+    };
+    return {
+        async get() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'ReleaseAction',
+                action: 'get',
+                params,
+            }).then((releaseAction) => wrapReleaseAction(makeRequest, releaseAction));
+        },
+        /** Waits for a Release Action to complete */
+        async waitProcessing(options) {
+            return pollAsyncActionStatus(async () => this.get(), options);
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Release data
+ * @return Wrapped Release data
+ */
+function wrapReleaseAction(makeRequest, data) {
+    const releaseAction = toPlainObject(copy(data));
+    const releaseActionWithApiMethods = enhanceWithMethods(releaseAction, createReleaseActionApi(makeRequest));
+    return freezeSys(releaseActionWithApiMethods);
+}
+/**
+ * @private
+ */
+const wrapReleaseActionCollection = wrapCollection(wrapReleaseAction);
+
+export { wrapReleaseAction, wrapReleaseActionCollection };

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

@@ -1,7 +1,7 @@
-import type { BaseCollection, CursorPaginatedCollection, CursorPaginatedCollectionProp, DefaultElements, ISO8601Timestamp, Link, MakeRequest, MakeRequestPayload } from '../common-types';
-import { ScheduledActionReferenceFilters } from '../common-types';
-import type { AsyncActionProcessingOptions } from '../methods/action';
-import type { ReleaseAction } from './release-action';
+import type { BaseCollection, CursorPaginatedCollection, CursorPaginatedCollectionProp, DefaultElements, ISO8601Timestamp, Link, MakeRequest, MakeRequestPayload } from '../common-types.js';
+import { ScheduledActionReferenceFilters } from '../common-types.js';
+import type { AsyncActionProcessingOptions } from '../methods/action.js';
+import type { ReleaseAction } from './release-action.js';
 /** Entity types supported by the Release API */
 type Entity = 'Entry' | 'Asset';
 type ReleaseStatus = 'active' | 'archived';
@@ -18,6 +18,8 @@ export interface ReleaseQueryOptions {
     'sys.createdBy.sys.id[in]'?: string;
     /** Comma-separated filter (inclusion) by Release status (active, archived) */
     'sys.status[in]'?: ReleaseStatus;
+    /** Determines the Release API version to use. 'Release.v1' refers to Launch, 'Release.v2' refers to Releases. */
+    'sys.schemaVersion'?: 'Release.v1' | 'Release.v2';
     /** Comma-separated filter (exclusion) by Release status (active, archived) */
     'sys.status[nin]'?: ReleaseStatus;
     /** Find releases using full text phrase and term matching */
@@ -55,6 +57,7 @@ export type ReleaseSysProps = {
     createdAt: ISO8601Timestamp;
     updatedAt: ISO8601Timestamp;
     lastAction?: Link<'ReleaseAction'>;
+    schemaVersion?: 'Release.v2';
 };
 export type ReleaseReferenceFilters = ScheduledActionReferenceFilters;
 export declare const ReleaseReferenceFilters: typeof ScheduledActionReferenceFilters;
@@ -72,11 +75,25 @@ export interface ReleaseProps {
     metadata?: ReleaseMetadata;
 }
 export interface ReleasePayload extends MakeRequestPayload {
+    sys?: {
+        type: 'Release';
+        schemaVersion?: 'Release.v1' | undefined;
+    };
     title: string;
     entities: BaseCollection<Link<Entity>>;
 }
+export interface ReleasePayloadV2 extends MakeRequestPayload {
+    sys?: {
+        type: 'Release';
+        schemaVersion: 'Release.v2';
+    };
+    title: string;
+    entities: BaseCollection<{
+        entity: Link<Entity>;
+    } & ReleaseValidatePayload>;
+}
 export interface ReleaseValidatePayload {
-    action?: 'publish';
+    action?: 'publish' | 'unpublish';
 }
 export interface ReleaseValidateOptions {
     payload?: ReleaseValidatePayload;

package/dist/types/entities/release.js

@@ -0,0 +1,106 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import '../common-types.js';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapReleaseAction } from './release-action.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * @private
+ */
+function createReleaseApi(makeRequest) {
+    const getParams = (self) => {
+        const release = self.toPlainObject();
+        return {
+            spaceId: release.sys.space.sys.id,
+            environmentId: release.sys.environment.sys.id,
+            releaseId: release.sys.id,
+            version: release.sys.version,
+        };
+    };
+    return {
+        async archive() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'archive',
+                params,
+            }).then((release) => wrapRelease(makeRequest, release));
+        },
+        async unarchive() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'unarchive',
+                params,
+            }).then((release) => wrapRelease(makeRequest, release));
+        },
+        async update(payload) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'update',
+                params,
+                payload,
+            }).then((release) => wrapRelease(makeRequest, release));
+        },
+        async delete() {
+            const params = getParams(this);
+            await makeRequest({
+                entityType: 'Release',
+                action: 'delete',
+                params,
+            });
+        },
+        async publish(options) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'publish',
+                params,
+            })
+                .then((data) => wrapReleaseAction(makeRequest, data))
+                .then((action) => action.waitProcessing(options));
+        },
+        async unpublish(options) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'unpublish',
+                params,
+            })
+                .then((data) => wrapReleaseAction(makeRequest, data))
+                .then((action) => action.waitProcessing(options));
+        },
+        async validate(options) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'validate',
+                params,
+                payload: options?.payload,
+            })
+                .then((data) => wrapReleaseAction(makeRequest, data))
+                .then((action) => action.waitProcessing(options?.processingOptions));
+        },
+    };
+}
+/**
+ * Return a Release object enhanced with its own API helper functions.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Release data
+ * @return Wrapped Release data
+ */
+function wrapRelease(makeRequest, data) {
+    const release = toPlainObject(copy(data));
+    const releaseWithApiMethods = enhanceWithMethods(release, createReleaseApi(makeRequest));
+    return freezeSys(releaseWithApiMethods);
+}
+/**
+ * @private
+ */
+const wrapReleaseCollection = wrapCursorPaginatedCollection(wrapRelease);
+
+export { wrapRelease, wrapReleaseCollection };

package/dist/types/entities/resource-provider.d.ts

@@ -1,10 +1,10 @@
-import type { BasicMetaSysProps, CollectionProp, DefaultElements, Link, MakeRequest } from '../common-types';
-import type { ResourceType, UpsertResourceTypeProps } from './resource-type';
+import type { BasicMetaSysProps, CollectionProp, DefaultElements, Link, MakeRequest } from '../common-types.js';
+import { type ResourceType, type UpsertResourceTypeProps } from './resource-type.js';
 export type ResourceProviderProps = {
     /**
      * System metadata
      */
-    sys: Omit<BasicMetaSysProps<'ResourceProvider', 'User'>, 'version'> & {
+    sys: Omit<BasicMetaSysProps, 'version'> & {
         organization: Link<'Organization'>;
         appDefinition: Link<'AppDefinition'>;
     };

package/dist/types/entities/resource-provider.js

@@ -0,0 +1,136 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapResourceType } from './resource-type.js';
+
+/**
+ * @private
+ */
+function createResourceProviderApi(makeRequest) {
+    return {
+        /**
+         * Sends an update to the server with any changes made to the object's properties
+         * @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.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceProvider())
+         * .then((resourceProvider) => {
+         *    resourceProvider.function.sys.id = '<new_contentful_function_id>'
+         *    return resourceProvider.upsert()
+         * })
+         * .catch(console.error)
+         * ```
+         */
+        upsert: function upsert() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceProvider',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: getUpsertParams(data),
+            }).then((data) => wrapResourceProvider(makeRequest, data));
+        },
+        /**
+         * 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.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceProvider())
+         * .then((resourceProvider) => resourceProvider.delete())
+         * .catch(console.error)
+         * ```
+         */
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceProvider',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+        getResourceType: function getResourceType(id) {
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'get',
+                params: {
+                    organizationId: this.sys.organization.sys.id,
+                    appDefinitionId: this.sys.appDefinition.sys.id,
+                    resourceTypeId: id,
+                },
+            }).then((data) => wrapResourceType(makeRequest, data));
+        },
+        upsertResourceType: function upsertResourceType(id, data) {
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'upsert',
+                params: {
+                    organizationId: this.sys.organization.sys.id,
+                    appDefinitionId: this.sys.appDefinition.sys.id,
+                    resourceTypeId: id,
+                },
+                headers: {},
+                payload: data,
+            }).then((data) => wrapResourceType(makeRequest, data));
+        },
+        getResourceTypes: function getResourceTypes() {
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'getMany',
+                params: {
+                    organizationId: this.sys.organization.sys.id,
+                    appDefinitionId: this.sys.appDefinition.sys.id,
+                },
+            }).then((data) => {
+                data.items = data.items.map((item) => wrapResourceType(makeRequest, item));
+                return data;
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param data - raw ResourceProvider Object
+ * @return Object containing the http params for the ResourceProvider request: organizationId and appDefinitionId
+ */
+const getParams = (data) => ({
+    organizationId: data.sys.organization.sys.id,
+    appDefinitionId: data.sys.appDefinition.sys.id,
+});
+/**
+ * @private
+ * @param data - raw ResourceProvider Object
+ * @return UpsertResourceProviderProps
+ */
+const getUpsertParams = (data) => ({
+    sys: { id: data.sys.id },
+    type: data.type,
+    function: data.function,
+});
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Provider data
+ * @return Wrapped Resource Provider data
+ */
+function wrapResourceProvider(makeRequest, data) {
+    const resourceProvider = toPlainObject(copy(data));
+    const ResourceProviderWithMethods = enhanceWithMethods(resourceProvider, createResourceProviderApi(makeRequest));
+    return freezeSys(ResourceProviderWithMethods);
+}
+
+export { wrapResourceProvider };

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

@@ -1,9 +1,9 @@
-import type { BasicMetaSysProps, CursorPaginatedCollectionProp, DefaultElements, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, CursorPaginatedCollectionProp, DefaultElements, Link, MakeRequest } from '../common-types.js';
 export type ResourceTypeProps = {
     /**
      * System metadata
      */
-    sys: Omit<BasicMetaSysProps<'ResourceType', 'User'>, 'version'> & {
+    sys: Omit<BasicMetaSysProps, 'version'> & {
         appDefinition: Link<'AppDefinition'>;
         resourceProvider: Link<'ResourceProvider'>;
         organization: Link<'Organization'>;

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

@@ -0,0 +1,94 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createResourceTypeApi(makeRequest) {
+    return {
+        /**
+         * Sends an update to the server with any changes made to the object's properties
+         * @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.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceType())
+         * .then((resourceType) => {
+         *    resourceType.name = '<new_name>'
+         *    return resourceType.upsert()
+         * })
+         * .catch(console.error)
+         * ```
+         */
+        upsert: function upsert() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: getUpsertParams(data),
+            }).then((data) => wrapResourceType(makeRequest, data));
+        },
+        /**
+         * 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.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceType())
+         * .then((resourceType) => resourceType.delete())
+         * .catch(console.error)
+         * ```
+         */
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+const getParams = (data) => ({
+    organizationId: data.sys.organization.sys.id,
+    appDefinitionId: data.sys.appDefinition.sys.id,
+    resourceTypeId: data.sys.id,
+});
+const getUpsertParams = (data) => ({
+    name: data.name,
+    defaultFieldMapping: data.defaultFieldMapping,
+});
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Type data
+ * @return Wrapped Resource Type data
+ */
+function wrapResourceType(makeRequest, data) {
+    const resourceType = toPlainObject(copy(data));
+    const ResourceTypeWithMethods = enhanceWithMethods(resourceType, createResourceTypeApi(makeRequest));
+    return freezeSys(ResourceTypeWithMethods);
+}
+function wrapResourceTypeforEnvironment(makeRequest, data) {
+    const resourceType = toPlainObject(data);
+    return freezeSys(resourceType);
+}
+const wrapResourceTypesForEnvironmentCollection = wrapCursorPaginatedCollection(wrapResourceTypeforEnvironment);
+
+export { wrapResourceType, wrapResourceTypeforEnvironment, wrapResourceTypesForEnvironmentCollection };

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

@@ -1,4 +1,4 @@
-import type { BasicCursorPaginationOptions, CursorPaginatedCollectionProp, Link, MakeRequest } from '../common-types';
+import type { BasicCursorPaginationOptions, CursorPaginatedCollectionProp, Link, MakeRequest } from '../common-types.js';
 export type ResourceQueryOptions = LookupQueryOptions | SearchQueryOptions;
 type LookupQueryOptions = {
     'sys.urn[in]': string;

package/dist/types/entities/resource.js

@@ -0,0 +1,10 @@
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+
+function wrapResource(makeRequest, data) {
+    const resource = toPlainObject(data);
+    return freezeSys(resource);
+}
+const wrapResourceCollection = wrapCursorPaginatedCollection(wrapResource);
+
+export { wrapResource, wrapResourceCollection };

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

@@ -1,11 +1,11 @@
-import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
 export type ActionType = 'read' | 'create' | 'update' | 'delete' | 'publish' | 'unpublish' | 'archive' | 'unarchive';
 type ConditionType = 'and' | 'or' | 'not' | 'equals';
 export type ConstraintType = {
     [key in ConditionType]?: ConstraintType[] | any;
 };
 export type RoleProps = {
-    sys: BasicMetaSysProps<'Role', 'User'> & {
+    sys: BasicMetaSysProps & {
         space: Link<'Space'>;
     };
     name: string;
@@ -81,5 +81,5 @@ export declare function wrapRole(makeRequest: MakeRequest, data: RoleProps): Rol
 /**
  * @private
  */
-export declare const wrapRoleCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<RoleProps>) => import("../common-types").Collection<Role, RoleProps>;
+export declare const wrapRoleCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<RoleProps>) => import("../common-types.js").Collection<Role, RoleProps>;
 export {};

package/dist/types/entities/role.js

@@ -0,0 +1,50 @@
+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 createRoleApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        roleId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Role',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapRole(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Role',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw role data
+ * @return Wrapped role data
+ */
+function wrapRole(makeRequest, data) {
+    const role = toPlainObject(copy(data));
+    const roleWithMethods = enhanceWithMethods(role, createRoleApi(makeRequest));
+    return freezeSys(roleWithMethods);
+}
+/**
+ * @private
+ */
+const wrapRoleCollection = wrapCollection(wrapRole);
+
+export { wrapRole, wrapRoleCollection };