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

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

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

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

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

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

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

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

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

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

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

package/dist/types/entities/environment.js

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

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

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

package/dist/types/entities/extension.js

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

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

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

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

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

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

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

package/dist/types/entities/function.js

@@ -0,0 +1,63 @@
+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 createFunctionApi(makeRequest) {
+    return {
+        getFunction: function getFunction() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Function',
+                action: 'get',
+                params: {
+                    organizationId: raw.sys.organization.sys.id,
+                    appDefinitionId: raw.sys.appDefinition.sys.id,
+                    functionId: raw.sys.id,
+                },
+            }).then((data) => wrapFunction(makeRequest, data));
+        },
+        getManyFunctions: function getManyFunctions() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Function',
+                action: 'getMany',
+                params: {
+                    appDefinitionId: raw.sys.appDefinition.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+            }).then((data) => wrapFunctionCollection(makeRequest, data));
+        },
+        getManyFunctionsForEnvironment(spaceId, environmentId, appInstallationId) {
+            return makeRequest({
+                entityType: 'Function',
+                action: 'getManyForEnvironment',
+                params: {
+                    spaceId: spaceId,
+                    environmentId: environmentId,
+                    appInstallationId: appInstallationId,
+                },
+            }).then((data) => wrapFunctionCollection(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - (real) function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+function wrapFunction(makeRequest, data) {
+    const func = toPlainObject(copy(data));
+    const funcWithMethods = enhanceWithMethods(func, createFunctionApi(makeRequest));
+    return freezeSys(funcWithMethods);
+}
+/**
+ * @private
+ */
+const wrapFunctionCollection = wrapCollection(wrapFunction);
+
+export { wrapFunction, wrapFunctionCollection };

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

@@ -1,7 +1,7 @@
 import type { Except, SetOptional } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
 export type LocaleProps = {
-    sys: BasicMetaSysProps<'Locale', 'User' | 'AppDefinition'> & {
+    sys: BasicMetaSysProps & {
         space: Link<'Space'>;
         environment: Link<'Environment'>;
     };
@@ -92,4 +92,4 @@ export declare function wrapLocale(makeRequest: MakeRequest, data: LocaleProps):
 /**
  * @private
  */
-export declare const wrapLocaleCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<LocaleProps>) => import("../common-types").Collection<Locale, LocaleProps>;
+export declare const wrapLocaleCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<LocaleProps>) => import("../common-types.js").Collection<Locale, LocaleProps>;

package/dist/types/entities/locale.js

@@ -0,0 +1,54 @@
+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 createLocaleApi(makeRequest) {
+    const getParams = (locale) => ({
+        spaceId: locale.sys.space.sys.id,
+        environmentId: locale.sys.environment.sys.id,
+        localeId: locale.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Locale',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapLocale(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Locale',
+                action: 'delete',
+                params: getParams(raw),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw locale data
+ * @return Wrapped locale data
+ */
+function wrapLocale(makeRequest, data) {
+    delete data.internal_code;
+    const locale = toPlainObject(copy(data));
+    const localeWithMethods = enhanceWithMethods(locale, createLocaleApi(makeRequest));
+    return freezeSys(localeWithMethods);
+}
+/**
+ * @private
+ */
+const wrapLocaleCollection = wrapCollection(wrapLocale);
+
+export { wrapLocale, wrapLocaleCollection };

package/dist/types/entities/oauth-application.d.ts

@@ -1,5 +1,5 @@
-import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types';
-type OAuthApplicationSysProps = BasicMetaSysProps<'Application', 'User'> & {
+import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
+type OAuthApplicationSysProps = BasicMetaSysProps & {
     lastUsedAt: string | null;
 };
 export declare enum ScopeValues {
@@ -52,5 +52,5 @@ export declare function wrapOAuthApplication(makeRequest: MakeRequest, data: OAu
 /**
  * @private
  */
-export declare const wrapOAuthApplicationCollection: (makeRequest: MakeRequest, data: import("../common-types").CursorPaginatedCollectionProp<OAuthApplicationProps>, userId: string) => import("../common-types").CursorPaginatedCollection<OAuthApplication, OAuthApplicationProps>;
+export declare const wrapOAuthApplicationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CursorPaginatedCollectionProp<OAuthApplicationProps>, userId: string) => import("../common-types.js").CursorPaginatedCollection<OAuthApplication, OAuthApplicationProps>;
 export {};

package/dist/types/entities/oauth-application.js

@@ -0,0 +1,63 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+
+var ScopeValues;
+(function (ScopeValues) {
+    ScopeValues["Read"] = "content_management_read";
+    ScopeValues["Manage"] = "content_management_manage";
+})(ScopeValues || (ScopeValues = {}));
+/**
+ * @private
+ */
+function createOAuthApplicationApi(makeRequest, userId) {
+    const getParams = (data) => ({
+        userId,
+        oauthApplicationId: data.sys.id,
+    });
+    return {
+        /**
+         * Updates an OAuth application
+         * @return Promise for the updated OAuth application
+         */
+        async update() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OAuthApplication',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            });
+        },
+        /**
+         * Deletes an OAuth application
+         * @return Promise for the deleted OAuth application
+         */
+        async delete() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OAuthApplication',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw OAuth application data
+ * @return Wrapped OAuth application data
+ */
+function wrapOAuthApplication(makeRequest, data, userId) {
+    const oauthApplication = toPlainObject(copy(data));
+    const oauthApplicationWithMethods = enhanceWithMethods(oauthApplication, createOAuthApplicationApi(makeRequest, userId));
+    return freezeSys(oauthApplicationWithMethods);
+}
+/**
+ * @private
+ */
+const wrapOAuthApplicationCollection = wrapCursorPaginatedCollection(wrapOAuthApplication);
+
+export { ScopeValues, wrapOAuthApplication, wrapOAuthApplicationCollection };

package/dist/types/entities/organization-invitation.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 OrganizationInvitationProps = {
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         organizationMembership: Link<'OrganizationMembership'>;
         user: Record<string, any> | null;
         invitationUrl: string;

package/dist/types/entities/organization-invitation.js

@@ -0,0 +1,15 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw invitation data
+ * @return {OrganizationInvitation} Wrapped Inviation data
+ */
+function wrapOrganizationInvitation(_makeRequest, data) {
+    const invitation = toPlainObject(copy(data));
+    return freezeSys(invitation);
+}
+
+export { wrapOrganizationInvitation };

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

@@ -1,9 +1,9 @@
-import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types';
+import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
 export type OrganizationMembershipProps = {
     /**
      * System metadata
      */
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         user: Link<'User'>;
     };
     /**
@@ -64,4 +64,4 @@ export declare function wrapOrganizationMembership(makeRequest: MakeRequest, dat
 /**
  * @private
  */
-export declare const wrapOrganizationMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<OrganizationMembershipProps>, organizationId: string) => import("../common-types").Collection<OrganizationMembership, OrganizationMembershipProps>;
+export declare const wrapOrganizationMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<OrganizationMembershipProps>, organizationId: string) => import("../common-types.js").Collection<OrganizationMembership, OrganizationMembershipProps>;

package/dist/types/entities/organization-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 createOrganizationMembershipApi(makeRequest, organizationId) {
+    const getParams = (data) => ({
+        organizationMembershipId: data.sys.id,
+        organizationId,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OrganizationMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapOrganizationMembership(makeRequest, data, organizationId));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OrganizationMembership',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {Object} data - Raw organization membership data
+ * @return {OrganizationMembership} Wrapped organization membership data
+ */
+function wrapOrganizationMembership(makeRequest, data, organizationId) {
+    const organizationMembership = toPlainObject(copy(data));
+    const organizationMembershipWithMethods = enhanceWithMethods(organizationMembership, createOrganizationMembershipApi(makeRequest, organizationId));
+    return freezeSys(organizationMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapOrganizationMembershipCollection = wrapCollection(wrapOrganizationMembership);
+
+export { wrapOrganizationMembership, wrapOrganizationMembershipCollection };

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

@@ -1,11 +1,11 @@
-import type { ContentfulOrganizationAPI } from '../create-organization-api';
-import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+import type { ContentfulOrganizationAPI } from '../create-organization-api.js';
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
 export type Organization = DefaultElements<OrganizationProps> & OrganizationProps & ContentfulOrganizationAPI;
 export type OrganizationProps = {
     /**
      * System metadata
      */
-    sys: MetaSysProps<'User'>;
+    sys: MetaSysProps;
     /**
      * Name
      */
@@ -30,4 +30,4 @@ export declare function wrapOrganization(makeRequest: MakeRequest, data: Organiz
  * This method normalizes each organization in a collection.
  * @private
  */
-export declare const wrapOrganizationCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<OrganizationProps>) => import("../common-types").Collection<Organization, OrganizationProps>;
+export declare const wrapOrganizationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<OrganizationProps>) => import("../common-types.js").Collection<Organization, OrganizationProps>;

package/dist/types/entities/organization.js

@@ -0,0 +1,29 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import createOrganizationApi from '../create-organization-api.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * This method creates the API for the given organization with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with an organization id, so the base path for requests now has the
+ * organization id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for an Organization
+ * @return {Organization}
+ */
+function wrapOrganization(makeRequest, data) {
+    const org = toPlainObject(copy(data));
+    const orgApi = createOrganizationApi(makeRequest);
+    const enhancedOrganization = enhanceWithMethods(org, orgApi);
+    return freezeSys(enhancedOrganization);
+}
+/**
+ * This method normalizes each organization in a collection.
+ * @private
+ */
+const wrapOrganizationCollection = wrapCollection(wrapOrganization);
+
+export { wrapOrganization, wrapOrganizationCollection };

package/dist/types/entities/personal-access-token.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 PersonalAccessTokenProps = {
-    sys: MetaSysProps<'User'> & {
+    sys: MetaSysProps & {
         expiresAt?: string;
     };
     name: string;
@@ -48,4 +48,4 @@ export declare function wrapPersonalAccessToken(makeRequest: MakeRequest, data:
  * @param data - Raw personal access collection data
  * @return Wrapped personal access token collection data
  */
-export declare const wrapPersonalAccessTokenCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<PersonalAccessTokenProps>) => import("../common-types").Collection<PersonalAccessToken, PersonalAccessTokenProps>;
+export declare const wrapPersonalAccessTokenCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<PersonalAccessTokenProps>) => import("../common-types.js").Collection<PersonalAccessToken, PersonalAccessTokenProps>;