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

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,6 +1,6 @@
-import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
 export type SnapshotProps<T> = {
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         snapshotType: string;
         snapshotEntityType: 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,6 +1,6 @@
-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'>;
+    sys: MetaSysProps;
     /**
      * User is an admin
      */
@@ -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,6 +1,6 @@
-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'> & {
+    sys: MetaSysProps & {
         space: Link<'Space'>;
         user: Link<'User'>;
     };
@@ -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,7 +1,7 @@
-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'> & {
+    sys: BasicMetaSysProps & {
         organization: {
             sys: {
                 id: string;
@@ -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 };

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

@@ -1,6 +1,6 @@
-import type { DefaultElements, GetTagParams, Link, MakeRequest, MetaSysProps } from '../common-types';
+import type { DefaultElements, GetTagParams, Link, MakeRequest, MetaSysProps } from '../common-types.js';
 export type TagVisibility = 'private' | 'public';
-export type TagSysProps = Pick<MetaSysProps<'User'>, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
+export type TagSysProps = Pick<MetaSysProps, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
     type: 'Tag';
     visibility: TagVisibility;
     space: Link<'Space'>;
@@ -47,5 +47,5 @@ export declare function wrapTag(makeRequest: MakeRequest, data: TagProps): Tag;
 /**
  * @private
  */
-export declare const wrapTagCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<TagProps>) => import("../common-types").Collection<Tag, TagProps>;
+export declare const wrapTagCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<TagProps>) => import("../common-types.js").Collection<Tag, TagProps>;
 export {};

package/dist/types/entities/tag.js

@@ -0,0 +1,53 @@
+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 createTagApi(makeRequest) {
+    const getParams = (tag) => ({
+        spaceId: tag.sys.space.sys.id,
+        environmentId: tag.sys.environment.sys.id,
+        tagId: tag.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Tag',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTag(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Tag',
+                action: 'delete',
+                params: {
+                    ...getParams(raw),
+                    version: raw.sys.version,
+                },
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapTag(makeRequest, data) {
+    const tag = toPlainObject(copy(data));
+    const tagWithMethods = enhanceWithMethods(tag, createTagApi(makeRequest));
+    return freezeSys(tagWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTagCollection = wrapCollection(wrapTag);
+
+export { createTagApi as default, wrapTag, wrapTagCollection };

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

@@ -1,6 +1,6 @@
-import type { BasicMetaSysProps, DefaultElements, GetEntryParams, GetTaskParams, Link, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, GetEntryParams, GetTaskParams, Link, MakeRequest } from '../common-types.js';
 export type TaskStatus = 'active' | 'resolved';
-export type TaskSysProps = Pick<BasicMetaSysProps<'Task', 'User' | 'AppDefinition'>, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
+export type TaskSysProps = Pick<BasicMetaSysProps, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
     type: 'Task';
     space: Link<'Space'>;
     environment: Link<'Environment'>;
@@ -39,5 +39,5 @@ export declare function wrapTask(makeRequest: MakeRequest, data: TaskProps): Tas
 /**
  * @private
  */
-export declare const wrapTaskCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<TaskProps>) => import("../common-types").Collection<Task, TaskProps>;
+export declare const wrapTaskCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<TaskProps>) => import("../common-types.js").Collection<Task, TaskProps>;
 export {};

package/dist/types/entities/task.js

@@ -0,0 +1,54 @@
+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 createTaskApi(makeRequest) {
+    const getParams = (task) => ({
+        spaceId: task.sys.space.sys.id,
+        environmentId: task.sys.environment.sys.id,
+        entryId: task.sys.parentEntity.sys.id,
+        taskId: task.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Task',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTask(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Task',
+                action: 'delete',
+                params: {
+                    ...getParams(raw),
+                    version: raw.sys.version,
+                },
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapTask(makeRequest, data) {
+    const task = toPlainObject(copy(data));
+    const taskWithMethods = enhanceWithMethods(task, createTaskApi(makeRequest));
+    return freezeSys(taskWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTaskCollection = wrapCollection(wrapTask);
+
+export { createTaskApi as default, wrapTask, wrapTaskCollection };

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

@@ -1,9 +1,9 @@
-import type { DefaultElements, MetaSysProps, MakeRequest, Link } from '../common-types';
+import type { DefaultElements, MetaSysProps, MakeRequest, Link } from '../common-types.js';
 export type TeamMembershipProps = {
     /**
      * System metadata
      */
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         team: Link<'Team'>;
         organization: Link<'Organization'>;
         organizationMembership: Link<'OrganizationMembership'>;
@@ -69,4 +69,4 @@ export declare function wrapTeamMembership(makeRequest: MakeRequest, data: TeamM
 /**
  * @private
  */
-export declare const wrapTeamMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<TeamMembershipProps>) => import("../common-types").Collection<TeamMembership, TeamMembershipProps>;
+export declare const wrapTeamMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<TeamMembershipProps>) => import("../common-types.js").Collection<TeamMembership, TeamMembershipProps>;

package/dist/types/entities/team-membership.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 createTeamMembershipApi(makeRequest) {
+    const getParams = (data) => ({
+        teamMembershipId: data.sys.id,
+        teamId: data.sys.team.sys.id,
+        organizationId: data.sys.organization.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTeamMembership(makeRequest, data));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamMembership',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw team membership data
+ * @return Wrapped team membership data
+ */
+function wrapTeamMembership(makeRequest, data) {
+    const teamMembership = toPlainObject(copy(data));
+    const teamMembershipWithMethods = enhanceWithMethods(teamMembership, createTeamMembershipApi(makeRequest));
+    return freezeSys(teamMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamMembershipCollection = wrapCollection(wrapTeamMembership);
+
+export { wrapTeamMembership, wrapTeamMembershipCollection };

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

@@ -1,4 +1,4 @@
-import type { DefaultElements, Link, MakeRequest, MetaSysProps, QueryOptions } from '../common-types';
+import type { DefaultElements, Link, MakeRequest, MetaSysProps, QueryOptions } from '../common-types.js';
 export interface Options {
     teamId?: string;
     query?: QueryOptions;
@@ -7,7 +7,7 @@ export type TeamSpaceMembershipProps = {
     /**
      * System metadata
      */
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         team: Link<'Team'>;
         space: Link<'Space'>;
     };
@@ -79,4 +79,4 @@ export declare function wrapTeamSpaceMembership(makeRequest: MakeRequest, data:
 /**
  * @private
  */
-export declare const wrapTeamSpaceMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<TeamSpaceMembershipProps>) => import("../common-types").Collection<TeamSpaceMembership, TeamSpaceMembershipProps>;
+export declare const wrapTeamSpaceMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<TeamSpaceMembershipProps>) => import("../common-types.js").Collection<TeamSpaceMembership, TeamSpaceMembershipProps>;

package/dist/types/entities/team-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 createTeamSpaceMembershipApi(makeRequest) {
+    const getParams = (data) => ({
+        teamSpaceMembershipId: data.sys.id,
+        spaceId: data.sys.space.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamSpaceMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTeamSpaceMembership(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamSpaceMembership',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space membership data
+ * @return Wrapped team space membership data
+ */
+function wrapTeamSpaceMembership(makeRequest, data) {
+    const teamSpaceMembership = toPlainObject(copy(data));
+    const teamSpaceMembershipWithMethods = enhanceWithMethods(teamSpaceMembership, createTeamSpaceMembershipApi(makeRequest));
+    return freezeSys(teamSpaceMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamSpaceMembershipCollection = wrapCollection(wrapTeamSpaceMembership);
+
+export { wrapTeamSpaceMembership, wrapTeamSpaceMembershipCollection };

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

@@ -1,9 +1,9 @@
-import type { DefaultElements, MetaSysProps, MakeRequest, Link } from '../common-types';
+import type { DefaultElements, MetaSysProps, MakeRequest, Link } from '../common-types.js';
 export type TeamProps = {
     /**
      * System metadata
      */
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         memberCount: number;
         organization: Link<'Organization'>;
     };
@@ -68,4 +68,4 @@ export declare function wrapTeam(makeRequest: MakeRequest, data: TeamProps): Tea
 /**
  * @private
  */
-export declare const wrapTeamCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<TeamProps>) => import("../common-types").Collection<Team, TeamProps>;
+export declare const wrapTeamCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<TeamProps>) => import("../common-types.js").Collection<Team, TeamProps>;