contentful-management 12.0.0-new-beta.3 → 12.0.0-new-beta.5

package/dist/types/methods/content-type.js

@@ -0,0 +1,47 @@
+/**
+ * @private
+ * @param id - unique ID of the field
+ * @param key - the attribute on the field to change
+ * @param value - the value to set the attribute to
+ */
+const findAndUpdateField = function (contentType, fieldId, omitOrDelete) {
+    const field = contentType.fields.find((field) => field.id === fieldId);
+    if (!field) {
+        return Promise.reject(new Error(`Tried to omitAndDeleteField on a nonexistent field, ${fieldId}, on the content type ${contentType.name}.`));
+    }
+    field[omitOrDelete] = true;
+    return Promise.resolve(contentType);
+};
+const omitAndDeleteField = (makeRequest, { fieldId, ...params }, contentType) => {
+    return findAndUpdateField(contentType, fieldId, 'omitted')
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'update',
+            params,
+            payload: newContentType,
+        });
+    })
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'publish',
+            params,
+            payload: newContentType,
+        });
+    })
+        .then((newContentType) => {
+        return findAndUpdateField(newContentType, fieldId, 'deleted');
+    })
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'update',
+            params,
+            payload: newContentType,
+        });
+    });
+};
+
+export { omitAndDeleteField };
+//# sourceMappingURL=content-type.js.map

package/dist/types/methods/content-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type.js","sources":["../../../lib/methods/content-type.ts"],"sourcesContent":[null],"names":[],"mappings":"AAKA;;;;;AAKG;AACH,MAAM,kBAAkB,GAAG,UACzB,WAA6B,EAC7B,OAAe,EACf,YAA0B,EAAA;AAE1B,IAAA,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,EAAE,KAAK,OAAO,CAAC;IACtE,IAAI,CAAC,KAAK,EAAE;AACV,QAAA,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,KAAK,CACP,CAAA,oDAAA,EAAuD,OAAO,CAAA,sBAAA,EAAyB,WAAW,CAAC,IAAI,CAAA,CAAA,CAAG,CAC3G,CACF;IACH;AAEA,IAAA,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI;AAE1B,IAAA,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;AACrC,CAAC;AAEM,MAAM,kBAAkB,GAAG,CAChC,WAAwB,EACxB,EACE,OAAO,EACP,GAAG,MAAM,EAGa,EACxB,WAA6B,KAC3B;AACF,IAAA,OAAO,kBAAkB,CAAC,WAAW,EAAE,OAAO,EAAE,SAAS;AACtD,SAAA,IAAI,CAAC,CAAC,cAAc,KAAI;AACvB,QAAA,OAAO,WAAW,CAAC;AACjB,YAAA,UAAU,EAAE,aAAa;AACzB,YAAA,MAAM,EAAE,QAAQ;YAChB,MAAM;AACN,YAAA,OAAO,EAAE,cAAc;AACxB,SAAA,CAAC;AACJ,IAAA,CAAC;AACA,SAAA,IAAI,CAAC,CAAC,cAAc,KAAI;AACvB,QAAA,OAAO,WAAW,CAAC;AACjB,YAAA,UAAU,EAAE,aAAa;AACzB,YAAA,MAAM,EAAE,SAAS;YACjB,MAAM;AACN,YAAA,OAAO,EAAE,cAAc;AACxB,SAAA,CAAC;AACJ,IAAA,CAAC;AACA,SAAA,IAAI,CAAC,CAAC,cAAc,KAAI;QACvB,OAAO,kBAAkB,CAAC,cAAc,EAAE,OAAO,EAAE,SAAS,CAAC;AAC/D,IAAA,CAAC;AACA,SAAA,IAAI,CAAC,CAAC,cAAc,KAAI;AACvB,QAAA,OAAO,WAAW,CAAC;AACjB,YAAA,UAAU,EAAE,aAAa;AACzB,YAAA,MAAM,EAAE,QAAQ;YAChB,MAAM;AACN,YAAA,OAAO,EAAE,cAAc;AACxB,SAAA,CAAC;AACJ,IAAA,CAAC,CAAC;AACN;;;;"}

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

@@ -0,0 +1,15 @@
+import type { ReleaseActionProps, ReleaseActionTypes } from '../entities/release-action';
+import type { PlainClientAPI } from '../plain/common-types';
+import type { AsyncActionProcessingOptions } from './action';
+type PlainOptions = {
+    /** Used by the PlainClient to perform a poll for the BulkAction status */
+    plainClient: PlainClientAPI;
+    spaceId: string;
+    environmentId: string;
+    releaseId: string;
+    actionId: string;
+};
+/** Waits for a ReleaseAction status to be either succeeded or failed.
+ * Used by the Plain client */
+export declare function waitForReleaseActionProcessing<T extends ReleaseActionTypes = any>({ plainClient, spaceId, environmentId, releaseId, actionId }: PlainOptions, options?: AsyncActionProcessingOptions): Promise<ReleaseActionProps<T>>;
+export {};

package/dist/types/methods/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Helper function that resolves a Promise after the specified duration (in milliseconds)
+ * @private
+ */
+export declare function sleep(durationMs: number): Promise<void>;

package/dist/types/methods/utils.js

@@ -0,0 +1,10 @@
+/**
+ * Helper function that resolves a Promise after the specified duration (in milliseconds)
+ * @private
+ */
+function sleep(durationMs) {
+    return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+
+export { sleep };
+//# sourceMappingURL=utils.js.map

package/dist/types/methods/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../lib/methods/utils.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;AAGG;AACG,SAAU,KAAK,CAAC,UAAkB,EAAA;AACtC,IAAA,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAClE;;;;"}

package/dist/types/plain/as-iterator.d.ts

@@ -0,0 +1,5 @@
+import type { CollectionProp, QueryParams } from '../common-types';
+type IterableFn<P = any, T = any> = (params: P) => Promise<CollectionProp<T>>;
+type ParamsType<T extends IterableFn> = T extends (params: infer P) => any ? P : never;
+export declare const asIterator: <P extends QueryParams, T, F extends IterableFn<P, T>>(fn: F, params: ParamsType<F>) => AsyncIterable<T>;
+export {};

package/dist/types/plain/as-iterator.js

@@ -0,0 +1,37 @@
+import copy from 'fast-copy';
+
+const asIterator = (fn, params) => {
+    return {
+        [Symbol.asyncIterator]() {
+            let options = copy(params);
+            const get = () => fn(copy(options));
+            let currentResult = get();
+            return {
+                current: 0,
+                async next() {
+                    const { total = 0, items = [], skip = 0, limit = 100 } = await currentResult;
+                    if (total === this.current) {
+                        return { done: true, value: null };
+                    }
+                    const value = items[this.current++ - skip];
+                    const endOfPage = this.current % limit === 0;
+                    const endOfList = this.current === total;
+                    if (endOfPage && !endOfList) {
+                        options = {
+                            ...options,
+                            query: {
+                                ...options.query,
+                                skip: skip + limit,
+                            },
+                        };
+                        currentResult = get();
+                    }
+                    return { done: false, value };
+                },
+            };
+        },
+    };
+};
+
+export { asIterator };
+//# sourceMappingURL=as-iterator.js.map

package/dist/types/plain/as-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"as-iterator.js","sources":["../../../lib/plain/as-iterator.ts"],"sourcesContent":[null],"names":[],"mappings":";;MAMa,UAAU,GAAG,CACxB,EAAK,EACL,MAAqB,KACD;IACpB,OAAO;QACL,CAAC,MAAM,CAAC,aAAa,CAAC,GAAA;AACpB,YAAA,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC;AAC1B,YAAA,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACnC,YAAA,IAAI,aAAa,GAAG,GAAG,EAAE;YAEzB,OAAO;AACL,gBAAA,OAAO,EAAE,CAAC;AACV,gBAAA,MAAM,IAAI,GAAA;oBACR,MAAM,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,EAAE,EAAE,IAAI,GAAG,CAAC,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG,MAAM,aAAa;AAE5E,oBAAA,IAAI,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE;wBAC1B,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE;oBACpC;oBAEA,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;oBAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,GAAG,KAAK,KAAK,CAAC;AAC5C,oBAAA,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,KAAK,KAAK;AAExC,oBAAA,IAAI,SAAS,IAAI,CAAC,SAAS,EAAE;AAC3B,wBAAA,OAAO,GAAG;AACR,4BAAA,GAAG,OAAO;AACV,4BAAA,KAAK,EAAE;gCACL,GAAG,OAAO,CAAC,KAAK;gCAChB,IAAI,EAAE,IAAI,GAAG,KAAK;AACnB,6BAAA;yBACF;wBACD,aAAa,GAAG,GAAG,EAAE;oBACvB;AAEA,oBAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE;gBAC/B,CAAC;aACF;QACH,CAAC;KACF;AACH;;;;"}

package/dist/types/plain/checks.d.ts

@@ -0,0 +1,13 @@
+import type { MetaSysProps } from '../common-types';
+export declare const isPublished: (data: {
+    sys: MetaSysProps;
+}) => boolean;
+export declare const isUpdated: (data: {
+    sys: MetaSysProps;
+}) => boolean;
+export declare const isDraft: (data: {
+    sys: MetaSysProps;
+}) => boolean;
+export declare const isArchived: (data: {
+    sys: MetaSysProps;
+}) => boolean;

package/dist/types/plain/checks.js

@@ -0,0 +1,11 @@
+const isPublished = (data) => !!data.sys.publishedVersion;
+const isUpdated = (data) => {
+    // The act of publishing an entity increases its version by 1, so any entry which has
+    // 2 versions higher or more than the publishedVersion has unpublished changes.
+    return !!(data.sys.publishedVersion && data.sys.version > data.sys.publishedVersion + 1);
+};
+const isDraft = (data) => !data.sys.publishedVersion;
+const isArchived = (data) => !!data.sys.archivedVersion;
+
+export { isArchived, isDraft, isPublished, isUpdated };
+//# sourceMappingURL=checks.js.map

package/dist/types/plain/checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.js","sources":["../../../lib/plain/checks.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEO,MAAM,WAAW,GAAG,CAAC,IAA2B,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;AAEhE,MAAM,SAAS,GAAG,CAAC,IAA2B,KAAI;;;IAGvD,OAAO,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,gBAAgB,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,CAAC,CAAC;AAC1F;AAEO,MAAM,OAAO,GAAG,CAAC,IAA2B,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;AAE3D,MAAM,UAAU,GAAG,CAAC,IAA2B,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;;;;"}

package/dist/types/plain/common-types.d.ts

@@ -0,0 +1,464 @@
+import type { RawAxiosRequestConfig, RawAxiosRequestHeaders } from 'axios';
+import type { OpPatch } from 'json-patch';
+import type { BasicCursorPaginationOptions, CollectionProp, CreateReleaseAssetParams, CreateReleaseEntryParams, CreateWithFilesReleaseAssetParams, CreateWithIdReleaseAssetParams, CreateWithIdReleaseEntryParams, CursorPaginatedCollectionProp, EnvironmentTemplateParams, GetBulkActionParams, GetContentTypeParams, GetEnvironmentTemplateParams, GetManyReleaseAssetParams, GetManyReleaseEntryParams, GetOrganizationMembershipParams, GetOrganizationParams, GetReleaseAssetParams, GetReleaseEntryParams, GetReleaseParams, GetSnapshotForContentTypeParams, GetSnapshotForEntryParams, GetSpaceEnvironmentParams, GetSpaceParams, KeyValueMap, Link, PatchReleaseEntryParams, QueryParams, ReleaseEnvironmentParams, UpdateReleaseAssetParams, UpdateReleaseEntryParams } from '../common-types';
+import type { AccessTokenProps, CreatePersonalAccessTokenProps as CreatePATProps } from '../entities/access-token';
+import type { ApiKeyProps, CreateApiKeyProps } from '../entities/api-key';
+import type { AssetFileProp, AssetProcessingForLocale, AssetProps, CreateAssetProps } from '../entities/asset';
+import type { AssetKeyProps, CreateAssetKeyProps } from '../entities/asset-key';
+import type { BulkActionPayload, BulkActionProps, BulkActionPublishPayload, BulkActionUnpublishPayload, BulkActionV2Payload, BulkActionValidatePayload, PublishBulkActionV2Payload, UnpublishBulkActionV2Payload, ValidateBulkActionV2Payload } from '../entities/bulk-action';
+import type { ContentTypeProps, CreateContentTypeProps } from '../entities/content-type';
+import type { CreateEntryProps, EntryProps, EntryReferenceProps } from '../entities/entry';
+import type { CreateEnvironmentTemplateProps, EnvironmentTemplateProps } from '../entities/environment-template';
+import type { CreateEnvironmentTemplateInstallationProps, EnvironmentTemplateInstallationProps, EnvironmentTemplateValidationProps, ValidateEnvironmentTemplateInstallationProps } from '../entities/environment-template-installation';
+import type { CreateOrganizationInvitationProps, OrganizationInvitationProps } from '../entities/organization-invitation';
+import type { OrganizationMembershipProps } from '../entities/organization-membership';
+import type { CreatePersonalAccessTokenProps, PersonalAccessTokenProps } from '../entities/personal-access-token';
+import type { PreviewApiKeyProps } from '../entities/preview-api-key';
+import type { ReleasePayload, ReleasePayloadV2, ReleaseProps, ReleaseQueryOptions, ReleaseValidatePayload } from '../entities/release';
+import type { ReleaseActionProps, ReleaseActionQueryOptions } from '../entities/release-action';
+import type { CreateUpdateScheduledActionProps, ScheduledActionProps } from '../entities/scheduled-action';
+import type { SnapshotProps } from '../entities/snapshot';
+import type { AppAccessTokenPlainClientAPI } from './entities/app-access-token';
+import type { AppActionPlainClientAPI } from './entities/app-action';
+import type { AppActionCallPlainClientAPI } from './entities/app-action-call';
+import type { AppBundlePlainClientAPI } from './entities/app-bundle';
+import type { AppDefinitionPlainClientAPI } from './entities/app-definition';
+import type { AppDetailsPlainClientAPI } from './entities/app-details';
+import type { AppEventSubscriptionPlainClientAPI } from './entities/app-event-subscription';
+import type { AppInstallationPlainClientAPI } from './entities/app-installation';
+import type { AppKeyPlainClientAPI } from './entities/app-key';
+import type { AppSignedRequestPlainClientAPI } from './entities/app-signed-request';
+import type { AppSigningSecretPlainClientAPI } from './entities/app-signing-secret';
+import type { AppUploadPlainClientAPI } from './entities/app-upload';
+import type { CommentPlainClientAPI } from './entities/comment';
+import type { ConceptPlainClientAPI } from './entities/concept';
+import type { ConceptSchemePlainClientAPI } from './entities/concept-scheme';
+import type { EditorInterfacePlainClientAPI } from './entities/editor-interface';
+import type { EnvironmentPlainClientAPI } from './entities/environment';
+import type { EnvironmentAliasPlainClientAPI } from './entities/environment-alias';
+import type { ExtensionPlainClientAPI } from './entities/extension';
+import type { FunctionPlainClientAPI } from './entities/function';
+import type { LocalePlainClientAPI } from './entities/locale';
+import type { OrganizationPlainClientAPI } from './entities/organization';
+import type { ResourcePlainAPI } from './entities/resource';
+import type { ResourceProviderPlainClientAPI } from './entities/resource-provider';
+import type { ResourceTypePlainClientAPI } from './entities/resource-type';
+import type { RolePlainClientAPI } from './entities/role';
+import type { SpacePlainClientAPI } from './entities/space';
+import type { SpaceMemberPlainClientAPI } from './entities/space-member';
+import type { SpaceMembershipPlainClientAPI } from './entities/space-membership';
+import type { TagPlainClientAPI } from './entities/tag';
+import type { TaskPlainClientAPI } from './entities/task';
+import type { TeamPlainClientAPI } from './entities/team';
+import type { TeamMembershipPlainClientAPI } from './entities/team-membership';
+import type { TeamSpaceMembershipPlainClientAPI } from './entities/team-space-membership';
+import type { UIConfigPlainClientAPI } from './entities/ui-config';
+import type { UploadPlainClientAPI } from './entities/upload';
+import type { UploadCredentialAPI } from './entities/upload-credential';
+import type { UsagePlainClientAPI } from './entities/usage';
+import type { UserPlainClientAPI } from './entities/user';
+import type { UserUIConfigPlainClientAPI } from './entities/user-ui-config';
+import type { WebhookPlainClientAPI } from './entities/webhook';
+import type { WorkflowPlainClientAPI } from './entities/workflow';
+import type { WorkflowDefinitionPlainClientAPI } from './entities/workflow-definition';
+import type { WorkflowsChangelogPlainClientAPI } from './entities/workflows-changelog';
+import type { DefaultParams, OptionalDefaults } from './wrappers/wrap';
+import type { OAuthApplicationPlainClientAPI } from './entities/oauth-application';
+import type { FunctionLogPlainClientAPI } from './entities/function-log';
+import type { AiActionPlainClientAPI } from './entities/ai-action';
+import type { AiActionInvocationPlainClientAPI } from './entities/ai-action-invocation';
+export type PlainClientAPI = {
+    raw: {
+        getDefaultParams(): DefaultParams | undefined;
+        get<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
+        post<T = unknown>(url: string, payload?: any, config?: RawAxiosRequestConfig): Promise<T>;
+        patch<T = unknown>(url: string, payload?: any, config?: RawAxiosRequestConfig): Promise<T>;
+        put<T = unknown>(url: string, payload?: any, config?: RawAxiosRequestConfig): Promise<T>;
+        delete<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
+        http<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
+    };
+    aiAction: AiActionPlainClientAPI;
+    aiActionInvocation: AiActionInvocationPlainClientAPI;
+    appAction: AppActionPlainClientAPI;
+    appActionCall: AppActionCallPlainClientAPI;
+    appBundle: AppBundlePlainClientAPI;
+    appDetails: AppDetailsPlainClientAPI;
+    appEventSubscription: AppEventSubscriptionPlainClientAPI;
+    appKey: AppKeyPlainClientAPI;
+    appSignedRequest: AppSignedRequestPlainClientAPI;
+    appSigningSecret: AppSigningSecretPlainClientAPI;
+    appAccessToken: AppAccessTokenPlainClientAPI;
+    function: FunctionPlainClientAPI;
+    functionLog: FunctionLogPlainClientAPI;
+    editorInterface: EditorInterfacePlainClientAPI;
+    space: SpacePlainClientAPI;
+    environment: EnvironmentPlainClientAPI;
+    environmentAlias: EnvironmentAliasPlainClientAPI;
+    environmentTemplate: {
+        get(params: GetEnvironmentTemplateParams & {
+            version?: number;
+            query?: {
+                select?: string;
+            };
+        }, headers?: RawAxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
+        getMany(params: GetOrganizationParams & {
+            query?: BasicCursorPaginationOptions & {
+                select?: string;
+                forTemplatedSpaces?: boolean;
+            };
+        }, headers?: RawAxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
+        create(params: GetOrganizationParams, rawData: CreateEnvironmentTemplateProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
+        versionUpdate(params: GetEnvironmentTemplateParams & {
+            version: number;
+        }, rawData: {
+            versionName?: string;
+            versionDescription?: string;
+        }, headers?: RawAxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
+        update(params: GetEnvironmentTemplateParams, rawData: EnvironmentTemplateProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentTemplateProps>;
+        delete(params: GetEnvironmentTemplateParams, headers?: RawAxiosRequestHeaders): Promise<void>;
+        versions(params: GetEnvironmentTemplateParams & {
+            query?: BasicCursorPaginationOptions & {
+                select?: string;
+                installable?: boolean;
+            };
+        }, headers?: RawAxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
+        validate(params: EnvironmentTemplateParams & {
+            version?: number;
+        }, rawData: ValidateEnvironmentTemplateInstallationProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentTemplateValidationProps>;
+        install(params: EnvironmentTemplateParams, rawData: CreateEnvironmentTemplateInstallationProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentTemplateInstallationProps>;
+        disconnect(params: EnvironmentTemplateParams, headers?: RawAxiosRequestHeaders): Promise<void>;
+    };
+    environmentTemplateInstallation: {
+        getMany(params: BasicCursorPaginationOptions & {
+            environmentId?: string;
+            environmentTemplateId: string;
+            organizationId: string;
+            spaceId?: string;
+            latestOnly?: boolean;
+        }, headers?: RawAxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>>;
+        getForEnvironment(params: BasicCursorPaginationOptions & EnvironmentTemplateParams & {
+            installationId?: string;
+        }, headers?: RawAxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>>;
+    };
+    bulkAction: {
+        get<T extends BulkActionPayload = any>(params: GetBulkActionParams): Promise<BulkActionProps<T>>;
+        publish(params: GetSpaceEnvironmentParams, payload: BulkActionPublishPayload): Promise<BulkActionProps<BulkActionPublishPayload>>;
+        unpublish(params: GetSpaceEnvironmentParams, payload: BulkActionUnpublishPayload): Promise<BulkActionProps<BulkActionUnpublishPayload>>;
+        validate(params: GetSpaceEnvironmentParams, payload: BulkActionValidatePayload): Promise<BulkActionProps<BulkActionValidatePayload>>;
+        getV2(params: GetBulkActionParams): Promise<BulkActionProps<BulkActionV2Payload>>;
+        publishV2(params: GetSpaceEnvironmentParams, payload: PublishBulkActionV2Payload<'add'>): Promise<BulkActionProps<PublishBulkActionV2Payload<'add'>>>;
+        unpublishV2(params: GetSpaceEnvironmentParams, payload: PublishBulkActionV2Payload<'remove'> | UnpublishBulkActionV2Payload): Promise<BulkActionProps<PublishBulkActionV2Payload<'remove'> | UnpublishBulkActionV2Payload>>;
+        validateV2(params: GetSpaceEnvironmentParams, payload: ValidateBulkActionV2Payload<'add'> | ValidateBulkActionV2Payload<'remove'>): Promise<BulkActionProps<ValidateBulkActionV2Payload<'add'> | ValidateBulkActionV2Payload<'remove'>>>;
+    };
+    comment: CommentPlainClientAPI;
+    concept: ConceptPlainClientAPI;
+    conceptScheme: ConceptSchemePlainClientAPI;
+    contentType: {
+        get(params: OptionalDefaults<GetContentTypeParams & QueryParams>): Promise<ContentTypeProps>;
+        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<ContentTypeProps>>;
+        update(params: OptionalDefaults<GetContentTypeParams>, rawData: ContentTypeProps, headers?: RawAxiosRequestHeaders): Promise<ContentTypeProps>;
+        delete(params: OptionalDefaults<GetContentTypeParams>): Promise<any>;
+        publish(params: OptionalDefaults<GetContentTypeParams>, rawData: ContentTypeProps): Promise<ContentTypeProps>;
+        unpublish(params: OptionalDefaults<GetContentTypeParams>): Promise<ContentTypeProps>;
+        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateContentTypeProps): Promise<ContentTypeProps>;
+        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            contentTypeId: string;
+        }>, rawData: CreateContentTypeProps): Promise<ContentTypeProps>;
+        omitAndDeleteField(params: OptionalDefaults<GetContentTypeParams>, contentType: ContentTypeProps, fieldId: string): Promise<ContentTypeProps>;
+    };
+    user: UserPlainClientAPI;
+    entry: {
+        getPublished<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<EntryProps<T>>>;
+        getMany<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams & {
+            releaseId?: string;
+        }>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<EntryProps<T>>>;
+        get<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            releaseId?: string;
+        }>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T>>;
+        update<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            releaseId?: string;
+        }>, rawData: EntryProps<T>, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T>>;
+        patch<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            version: number;
+            releaseId?: string;
+        }>, rawData: OpPatch[], headers?: RawAxiosRequestHeaders): Promise<EntryProps<T>>;
+        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+        }>): Promise<any>;
+        publish<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            locales?: string[];
+        }>, rawData: EntryProps<T>): Promise<EntryProps<T>>;
+        unpublish<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            locales?: string[];
+        }>, rawData?: EntryProps<T>): Promise<EntryProps<T>>;
+        archive<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+        }>): Promise<EntryProps<T>>;
+        unarchive<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+        }>): Promise<EntryProps<T>>;
+        create<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            contentTypeId: string;
+            releaseId?: string;
+        }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>;
+        createWithId<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            contentTypeId: string;
+            releaseId?: string;
+        }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>;
+        references(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            entryId: string;
+            include?: number;
+        }>): Promise<EntryReferenceProps>;
+    };
+    asset: {
+        getPublished(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<AssetProps>>;
+        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams & {
+            releaseId?: string;
+        }>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<AssetProps>>;
+        get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+            releaseId?: string;
+        } & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<AssetProps>;
+        update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+            releaseId?: string;
+        }>, rawData: AssetProps, headers?: RawAxiosRequestHeaders): Promise<AssetProps>;
+        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+        }>): Promise<any>;
+        publish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+            locales?: string[];
+        }>, rawData: AssetProps): Promise<AssetProps>;
+        unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+            locales?: string[];
+        }>, rawData?: AssetProps): Promise<AssetProps>;
+        archive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+        }>): Promise<AssetProps>;
+        unarchive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+        }>): Promise<AssetProps>;
+        create(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            releaseId?: string;
+        }>, rawData: CreateAssetProps): Promise<AssetProps>;
+        createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            assetId: string;
+            releaseId?: string;
+        }>, rawData: CreateAssetProps): Promise<AssetProps>;
+        createFromFiles(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            releaseId?: string;
+        }>, data: Omit<AssetFileProp, 'sys'>): Promise<AssetProps>;
+        processForAllLocales(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            releaseId?: string;
+        }>, asset: AssetProps, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>;
+        processForLocale(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            releaseId?: string;
+        }>, asset: AssetProps, locale: string, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>;
+    };
+    appUpload: AppUploadPlainClientAPI;
+    assetKey: {
+        create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateAssetKeyProps): Promise<AssetKeyProps>;
+    };
+    upload: UploadPlainClientAPI;
+    uploadCredential: UploadCredentialAPI;
+    locale: LocalePlainClientAPI;
+    personalAccessToken: {
+        get(params: OptionalDefaults<{
+            tokenId: string;
+        }>): Promise<PersonalAccessTokenProps>;
+        getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<PersonalAccessTokenProps>>;
+        create(rawData: CreatePersonalAccessTokenProps, headers?: RawAxiosRequestHeaders): Promise<PersonalAccessTokenProps>;
+        revoke(params: OptionalDefaults<{
+            tokenId: string;
+        }>): Promise<PersonalAccessTokenProps>;
+    };
+    accessToken: {
+        get(params: OptionalDefaults<{
+            tokenId: string;
+        }>): Promise<AccessTokenProps>;
+        getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<AccessTokenProps>>;
+        createPersonalAccessToken(rawData: CreatePATProps, headers?: RawAxiosRequestHeaders): Promise<AccessTokenProps>;
+        revoke(params: OptionalDefaults<{
+            tokenId: string;
+        }>): Promise<AccessTokenProps>;
+        getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<AccessTokenProps>>;
+    };
+    usage: UsagePlainClientAPI;
+    release: {
+        asset: {
+            get(params: OptionalDefaults<GetReleaseAssetParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+            getMany(params: OptionalDefaults<GetManyReleaseAssetParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<AssetProps<{
+                release: Link<'Release'>;
+            }>>>;
+            update(params: OptionalDefaults<UpdateReleaseAssetParams & QueryParams>, rawData: AssetProps, headers?: RawAxiosRequestHeaders): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+            create(params: OptionalDefaults<CreateReleaseAssetParams & QueryParams>, rawData: CreateAssetProps, headers?: RawAxiosRequestHeaders): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+            createWithId(params: OptionalDefaults<CreateWithIdReleaseAssetParams & QueryParams>, rawData: CreateAssetProps, headers?: RawAxiosRequestHeaders): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+            createFromFiles(params: OptionalDefaults<CreateWithFilesReleaseAssetParams & QueryParams>, data: Omit<AssetFileProp, 'sys'>, headers?: RawAxiosRequestHeaders): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+            processForLocale(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps<{
+                release: Link<'Release'>;
+            }>, locale: string, processingOptions?: AssetProcessingForLocale): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+            processForAllLocales(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps<{
+                release: Link<'Release'>;
+            }>, processingOptions?: AssetProcessingForLocale): Promise<AssetProps<{
+                release: Link<'Release'>;
+            }>>;
+        };
+        entry: {
+            get<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetReleaseEntryParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T, {
+                release: Link<'Release'>;
+            }>>;
+            getMany<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetManyReleaseEntryParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<EntryProps<T, {
+                release: Link<'Release'>;
+            }>>>;
+            update<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<UpdateReleaseEntryParams & QueryParams>, rawData: EntryProps<T>, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T, {
+                release: Link<'Release'>;
+            }>>;
+            patch<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<PatchReleaseEntryParams & QueryParams>, rawData: OpPatch[], headers?: RawAxiosRequestHeaders): Promise<EntryProps<T, {
+                release: Link<'Release'>;
+            }>>;
+            create<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<CreateReleaseEntryParams & QueryParams>, rawData: CreateEntryProps<T>, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T, {
+                release: Link<'Release'>;
+            }>>;
+            createWithId<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<CreateWithIdReleaseEntryParams & QueryParams>, rawData: CreateEntryProps<T>, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T, {
+                release: Link<'Release'>;
+            }>>;
+        };
+        archive(params: OptionalDefaults<GetReleaseParams & {
+            version: number;
+        }>): Promise<ReleaseProps>;
+        get(params: OptionalDefaults<GetReleaseParams>): Promise<ReleaseProps>;
+        query(params: OptionalDefaults<ReleaseEnvironmentParams> & {
+            query?: ReleaseQueryOptions;
+        }): Promise<CursorPaginatedCollectionProp<ReleaseProps>>;
+        create(params: OptionalDefaults<ReleaseEnvironmentParams>, data: ReleasePayload | ReleasePayloadV2): Promise<ReleaseProps>;
+        update(params: OptionalDefaults<GetReleaseParams & {
+            version: number;
+        }>, data: ReleasePayload | ReleasePayloadV2): Promise<ReleaseProps>;
+        delete(params: OptionalDefaults<GetReleaseParams>): Promise<void>;
+        publish(params: OptionalDefaults<GetReleaseParams & {
+            version: number;
+        }>): Promise<ReleaseActionProps<'publish'>>;
+        unarchive(params: OptionalDefaults<GetReleaseParams & {
+            version: number;
+        }>): Promise<ReleaseProps>;
+        unpublish(params: OptionalDefaults<GetReleaseParams & {
+            version: number;
+        }>): Promise<ReleaseActionProps<'unpublish'>>;
+        validate(params: OptionalDefaults<GetReleaseParams>, data?: ReleaseValidatePayload): Promise<ReleaseActionProps<'validate'>>;
+    };
+    releaseAction: {
+        get(params: OptionalDefaults<GetReleaseParams> & {
+            actionId: string;
+        }): Promise<ReleaseActionProps>;
+        getMany(params: OptionalDefaults<GetSpaceEnvironmentParams> & {
+            query?: ReleaseActionQueryOptions;
+        }): Promise<CollectionProp<ReleaseActionProps>>;
+        queryForRelease(params: OptionalDefaults<GetReleaseParams> & {
+            query?: ReleaseActionQueryOptions;
+        }): Promise<CollectionProp<ReleaseActionProps>>;
+    };
+    resource: ResourcePlainAPI;
+    resourceProvider: ResourceProviderPlainClientAPI;
+    resourceType: ResourceTypePlainClientAPI;
+    role: RolePlainClientAPI;
+    scheduledActions: {
+        get(params: OptionalDefaults<GetSpaceParams> & {
+            scheduledActionId: string;
+            environmentId: string;
+        }): Promise<ScheduledActionProps>;
+        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CursorPaginatedCollectionProp<ScheduledActionProps>>;
+        create(params: OptionalDefaults<GetSpaceParams>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>;
+        delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+            scheduledActionId: string;
+        }>): Promise<ScheduledActionProps>;
+        update(params: OptionalDefaults<GetSpaceParams & {
+            scheduledActionId: string;
+            version: number;
+        }>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>;
+    };
+    previewApiKey: {
+        get(params: OptionalDefaults<GetSpaceParams & {
+            previewApiKeyId: string;
+        }>): Promise<PreviewApiKeyProps>;
+        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<PreviewApiKeyProps>>;
+    };
+    apiKey: {
+        get(params: OptionalDefaults<GetSpaceParams & {
+            apiKeyId: string;
+        }>): Promise<ApiKeyProps>;
+        getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<ApiKeyProps>>;
+        create(params: OptionalDefaults<GetSpaceParams>, data: CreateApiKeyProps, headers?: RawAxiosRequestHeaders): Promise<ApiKeyProps>;
+        createWithId(params: OptionalDefaults<GetSpaceParams & {
+            apiKeyId: string;
+        }>, data: CreateApiKeyProps, headers?: RawAxiosRequestHeaders): Promise<ApiKeyProps>;
+        update(params: OptionalDefaults<GetSpaceParams & {
+            apiKeyId: string;
+        }>, rawData: ApiKeyProps, headers?: RawAxiosRequestHeaders): Promise<ApiKeyProps>;
+        delete(params: OptionalDefaults<GetSpaceParams & {
+            apiKeyId: string;
+        }>): Promise<any>;
+    };
+    appDefinition: AppDefinitionPlainClientAPI;
+    appInstallation: AppInstallationPlainClientAPI;
+    extension: ExtensionPlainClientAPI;
+    webhook: WebhookPlainClientAPI;
+    snapshot: {
+        getManyForEntry<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSnapshotForEntryParams & QueryParams>): Promise<CollectionProp<SnapshotProps<Omit<EntryProps<T>, 'metadata'>>>>;
+        getForEntry<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSnapshotForEntryParams & {
+            snapshotId: string;
+        }>): Promise<SnapshotProps<Omit<EntryProps<T>, 'metadata'>>>;
+        getManyForContentType(params: OptionalDefaults<GetSnapshotForContentTypeParams & QueryParams>): Promise<CollectionProp<SnapshotProps<ContentTypeProps>>>;
+        getForContentType(params: OptionalDefaults<GetSnapshotForContentTypeParams & {
+            snapshotId: string;
+        }>): Promise<SnapshotProps<ContentTypeProps>>;
+    };
+    tag: TagPlainClientAPI;
+    organization: OrganizationPlainClientAPI;
+    organizationInvitation: {
+        get(params: OptionalDefaults<{
+            organizationId: string;
+            invitationId: string;
+        }>, headers?: RawAxiosRequestHeaders): Promise<OrganizationInvitationProps>;
+        create(params: OptionalDefaults<{
+            organizationId: string;
+        }>, data: CreateOrganizationInvitationProps, headers?: RawAxiosRequestHeaders): Promise<OrganizationInvitationProps>;
+    };
+    organizationMembership: {
+        get(params: OptionalDefaults<GetOrganizationMembershipParams>): Promise<OrganizationMembershipProps>;
+        getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<OrganizationMembershipProps>>;
+        update(params: OptionalDefaults<GetOrganizationMembershipParams>, rawData: OrganizationMembershipProps, headers?: RawAxiosRequestHeaders): Promise<OrganizationMembershipProps>;
+        delete(params: OptionalDefaults<GetOrganizationMembershipParams>): Promise<any>;
+    };
+    spaceMember: SpaceMemberPlainClientAPI;
+    spaceMembership: SpaceMembershipPlainClientAPI;
+    task: TaskPlainClientAPI;
+    team: TeamPlainClientAPI;
+    teamMembership: TeamMembershipPlainClientAPI;
+    teamSpaceMembership: TeamSpaceMembershipPlainClientAPI;
+    uiConfig: UIConfigPlainClientAPI;
+    userUIConfig: UserUIConfigPlainClientAPI;
+    workflowDefinition: WorkflowDefinitionPlainClientAPI;
+    workflow: WorkflowPlainClientAPI;
+    workflowsChangelog: WorkflowsChangelogPlainClientAPI;
+    oauthApplication: OAuthApplicationPlainClientAPI;
+};