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

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,5 +1,5 @@
 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'> & {
         space: Link<'Space'>;
@@ -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,4 +1,4 @@
-import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
 type OAuthApplicationSysProps = BasicMetaSysProps<'Application', 'User'> & {
     lastUsedAt: string | null;
 };
@@ -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,4 +1,4 @@
-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'> & {
         organizationMembership: Link<'OrganizationMembership'>;

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,4 +1,4 @@
-import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types';
+import type { MetaSysProps, DefaultElements, MakeRequest, Link } from '../common-types.js';
 export type OrganizationMembershipProps = {
     /**
      * System metadata
@@ -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,5 +1,5 @@
-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 = {
     /**
@@ -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,4 +1,4 @@
-import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
 export type PersonalAccessTokenProps = {
     sys: MetaSysProps<'User'> & {
         expiresAt?: 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>;

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,4 +1,4 @@
-import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types';
+import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types.js';
 export type PreviewApiKeyProps = {
     sys: MetaSysProps<'User'>;
     name: 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';

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