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

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,4 +1,4 @@
-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

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,4 +1,4 @@
-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 = {
@@ -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 };

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

@@ -1,4 +1,4 @@
-import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest, ScheduledActionReferenceFilters, BasicCursorPaginationOptions, CollectionProp } from '../common-types';
+import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest, ScheduledActionReferenceFilters, BasicCursorPaginationOptions, CollectionProp } from '../common-types.js';
 /**
  * Represents that state of the scheduled action
  */
@@ -106,5 +106,5 @@ export declare function wrapScheduledAction(makeRequest: MakeRequest, data: Sche
 /**
  * @private
  */
-export declare const wrapScheduledActionCollection: (makeRequest: MakeRequest, data: CollectionProp<ScheduledActionProps>) => import("../common-types").Collection<ScheduledAction, ScheduledActionProps>;
+export declare const wrapScheduledActionCollection: (makeRequest: MakeRequest, data: CollectionProp<ScheduledActionProps>) => import("../common-types.js").Collection<ScheduledAction, ScheduledActionProps>;
 export {};

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

@@ -0,0 +1,146 @@
+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';
+
+/**
+ * Represents that state of the scheduled action
+ */
+var ScheduledActionStatus;
+(function (ScheduledActionStatus) {
+    /** action is pending execution */
+    ScheduledActionStatus["scheduled"] = "scheduled";
+    /** action has been started and pending completion */
+    ScheduledActionStatus["inProgress"] = "inProgress";
+    /** action was completed successfully (terminal state) */
+    ScheduledActionStatus["succeeded"] = "succeeded";
+    /** action failed to complete (terminal state) */
+    ScheduledActionStatus["failed"] = "failed";
+    /** action was canceled by a user (terminal state) */
+    ScheduledActionStatus["canceled"] = "canceled";
+})(ScheduledActionStatus || (ScheduledActionStatus = {}));
+function getInstanceMethods(makeRequest) {
+    const getParams = (self) => {
+        const scheduledAction = self.toPlainObject();
+        return {
+            spaceId: scheduledAction.sys.space.sys.id,
+            environmentId: scheduledAction.environment?.sys.id,
+            scheduledActionId: scheduledAction.sys.id,
+            version: scheduledAction.sys.version,
+        };
+    };
+    return {
+        /**
+         * Cancels the current Scheduled Action schedule.
+         *
+         * @example ```javascript
+         *  const contentful = require('contentful-management');
+         *
+         *  const client = contentful.createClient({
+         *    accessToken: '<content_management_api_key>'
+         *  })
+         *
+         *  client.getSpace('<space_id>')
+         *    .then((space) => {
+         *      return space.createScheduledAction({
+         *        entity: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Entry',
+         *            id: '<entry_id>'
+         *          }
+         *        },
+         *        environment: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Environment',
+         *            id: '<environment_id>'
+         *          }
+         *        },
+         *        action: 'publish',
+         *        scheduledFor: {
+         *          datetime: <ISO_date_string>,
+         *          timezone: 'Europe/Berlin'
+         *        }
+         *      })
+         *    .then((scheduledAction) => scheduledAction.delete())
+         *    .then((deletedScheduledAction) => console.log(deletedScheduledAction))
+         *    .catch(console.error);
+         * ```
+         */
+        async delete() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'delete',
+                params,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+        /**
+         * Update the current scheduled action. Currently, only changes made to the `scheduledFor` property will be saved.
+         *
+         * @example ```javascript
+         *  const contentful = require('contentful-management');
+         *
+         *  const client = contentful.createClient({
+         *    accessToken: '<content_management_api_key>'
+         *  })
+         *
+         *  client.getSpace('<space_id>')
+         *    .then((space) => {
+         *      return space.createScheduledAction({
+         *        entity: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Entry',
+         *            id: '<entry_id>'
+         *          }
+         *        },
+         *        environment: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Environment',
+         *            id: '<environment_id>'
+         *          }
+         *        },
+         *        action: 'publish',
+         *        scheduledFor: {
+         *          datetime: <ISO_date_string>,
+         *          timezone: 'Europe/Berlin'
+         *        }
+         *      })
+         *    .then((scheduledAction) => {
+         *      scheduledAction.scheduledFor.timezone = 'Europe/Paris';
+         *      return scheduledAction.update();
+         *    })
+         *    .then((scheduledAction) => console.log(scheduledAction))
+         *    .catch(console.error);
+         * ```
+         */
+        async update() {
+            const params = getParams(this);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { sys, ...payload } = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'update',
+                params,
+                payload,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapScheduledAction(makeRequest, data) {
+    const scheduledAction = toPlainObject(copy(data));
+    const scheduledActionWithMethods = enhanceWithMethods(scheduledAction, getInstanceMethods(makeRequest));
+    return freezeSys(scheduledActionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapScheduledActionCollection = wrapCollection(wrapScheduledAction);
+
+export { ScheduledActionStatus, getInstanceMethods as default, wrapScheduledAction, wrapScheduledActionCollection };

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

@@ -1,4 +1,4 @@
-import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
 export type SnapshotProps<T> = {
     sys: MetaSysProps<'User'> & {
         snapshotType: string;
@@ -21,4 +21,4 @@ export declare function wrapSnapshot<T>(_makeRequest: MakeRequest, data: Snapsho
  * @param data - Raw snapshot collection data
  * @return Wrapped snapshot collection data
  */
-export declare const wrapSnapshotCollection: <T>(makeRequest: MakeRequest, data: import("../common-types").CollectionProp<SnapshotProps<T>>) => import("../common-types").Collection<Snapshot<T>, SnapshotProps<T>>;
+export declare const wrapSnapshotCollection: <T>(makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<SnapshotProps<T>>) => import("../common-types.js").Collection<Snapshot<T>, SnapshotProps<T>>;

package/dist/types/entities/snapshot.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
+ */
+function createSnapshotApi() {
+    return {
+    /* In case the snapshot object evolve later */
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot data
+ * @return Wrapped snapshot data
+ */
+function wrapSnapshot(_makeRequest, data) {
+    const snapshot = toPlainObject(copy(data));
+    const snapshotWithMethods = enhanceWithMethods(snapshot, createSnapshotApi());
+    return freezeSys(snapshotWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot collection data
+ * @return Wrapped snapshot collection data
+ */
+const wrapSnapshotCollection = wrapCollection(wrapSnapshot);
+
+export { wrapSnapshot, wrapSnapshotCollection };

package/dist/types/entities/space-member.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types';
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types.js';
 export type SpaceMemberProps = {
     sys: MetaSysProps<'User'>;
     /**
@@ -24,6 +24,6 @@ export declare function wrapSpaceMember(_makeRequest: MakeRequest, data: SpaceMe
 /**
  * @private
  */
-export declare const wrapSpaceMemberCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<SpaceMemberProps>) => import("../common-types").Collection<SpaceMemberProps & {
+export declare const wrapSpaceMemberCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<SpaceMemberProps>) => import("../common-types.js").Collection<SpaceMemberProps & {
     toPlainObject(): SpaceMemberProps;
 }, SpaceMemberProps>;

package/dist/types/entities/space-member.js

@@ -0,0 +1,20 @@
+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 space member data
+ * @return Wrapped space member data
+ */
+function wrapSpaceMember(_makeRequest, data) {
+    const spaceMember = toPlainObject(copy(data));
+    return freezeSys(spaceMember);
+}
+/**
+ * @private
+ */
+const wrapSpaceMemberCollection = wrapCollection(wrapSpaceMember);
+
+export { wrapSpaceMember, wrapSpaceMemberCollection };

package/dist/types/entities/space-membership.d.ts

@@ -1,4 +1,4 @@
-import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types';
+import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
 export type SpaceMembershipProps = {
     sys: MetaSysProps<'User'> & {
         space: Link<'Space'>;
@@ -61,4 +61,4 @@ export declare function wrapSpaceMembership(makeRequest: MakeRequest, data: Spac
 /**
  * @private
  */
-export declare const wrapSpaceMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<SpaceMembershipProps>) => import("../common-types").Collection<SpaceMembership, SpaceMembershipProps>;
+export declare const wrapSpaceMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<SpaceMembershipProps>) => import("../common-types.js").Collection<SpaceMembership, SpaceMembershipProps>;

package/dist/types/entities/space-membership.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 createSpaceMembershipApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        spaceMembershipId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'SpaceMembership',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapSpaceMembership(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'SpaceMembership',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space membership data
+ * @return Wrapped space membership data
+ */
+function wrapSpaceMembership(makeRequest, data) {
+    const spaceMembership = toPlainObject(copy(data));
+    const spaceMembershipWithMethods = enhanceWithMethods(spaceMembership, createSpaceMembershipApi(makeRequest));
+    return freezeSys(spaceMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapSpaceMembershipCollection = wrapCollection(wrapSpaceMembership);
+
+export { wrapSpaceMembership, wrapSpaceMembershipCollection };

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

@@ -1,5 +1,5 @@
-import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types';
-import type { ContentfulSpaceAPI } from '../create-space-api';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
+import type { ContentfulSpaceAPI } from '../create-space-api.js';
 export type SpaceProps = {
     sys: BasicMetaSysProps<'Space', 'User'> & {
         organization: {
@@ -28,4 +28,4 @@ export declare function wrapSpace(makeRequest: MakeRequest, data: SpaceProps): S
  * above for more details.
  * @private
  */
-export declare const wrapSpaceCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<SpaceProps>) => import("../common-types").Collection<Space, SpaceProps>;
+export declare const wrapSpaceCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<SpaceProps>) => import("../common-types.js").Collection<Space, SpaceProps>;

package/dist/types/entities/space.js

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