contentful-management 11.64.0-new-beta.5 → 11.65.0

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

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

@@ -1 +0,0 @@
-{"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.js

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

@@ -1 +0,0 @@
-{"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

@@ -1,464 +0,0 @@
-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;
-};

package/dist/types/plain/entities/app-upload.d.ts

@@ -1,54 +0,0 @@
-import type { GetAppUploadParams, GetOrganizationParams } from '../../common-types';
-import type { AppUploadProps } from '../../entities/app-upload';
-import type { OptionalDefaults } from '../wrappers/wrap';
-export type AppUploadPlainClientAPI = {
-    /**
-     * Fetches the App Upload
-     * @param params entity IDs to identify the App Upload
-     * @returns the App Upload
-     * @throws if the request fails, or the App Upload is not found
-     * @example
-     * ```javascript
-     * const appUpload = await client.appUpload.get({
-     *   organizationId: '<organization_id>',
-     *   appUploadId: '<app_upload_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetAppUploadParams>): Promise<AppUploadProps>;
-    /**
-     * Deletes the App Upload
-     * @param params entity IDs to identify the App Upload
-     * @throws if the request fails, or the App Upload is not found
-     * @example
-     * ```javascript
-     * await client.appUpload.delete({
-     *   organizationId: '<organization_id>',
-     *   appUploadId: '<app_upload_id>',
-     * });
-     * ```
-     */
-    delete(params: OptionalDefaults<GetAppUploadParams>): Promise<void>;
-    /**
-     * Creates an App Upload
-     * @param params entity IDs to identify the Organization to upload the App to
-     * @param payload the App Upload
-     * @returns the App Upload
-     * @throws if the request fails, or the Organization is not found
-     * @example
-     * ```javascript
-     * const file = fs.readFileSync('<path_to_file>');
-     * const appUpload = await client.appUpload.create(
-     *   {
-     *     organizationId: '<organization_id>',
-     *   },
-     *   {
-     *     file: new ArrayBuffer(file.length),
-     *   }
-     * );
-     * ```
-     */
-    create(params: OptionalDefaults<GetOrganizationParams>, payload: {
-        file: string | ArrayBuffer | ReadableStream;
-    }): Promise<AppUploadProps>;
-};

package/dist/types/plain/entities/upload.d.ts

@@ -1,56 +0,0 @@
-import type { OptionalDefaults } from '../wrappers/wrap';
-import type { GetSpaceEnvironmentParams, GetSpaceEnvironmentUploadParams } from '../../common-types';
-export type UploadPlainClientAPI = {
-    /** Fetches the Space Environment Upload
-     *
-     * @param params Upload Id, Space Id and Environment Id to identify the Space Environment Upload
-     * @returns the Space Environment Upload
-     * @throws if the request fails, or the Space Environment Upload is not found
-     * @example
-     * ```javascript
-     * const upload = await client.upload.get({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   uploadId: '<upload_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetSpaceEnvironmentUploadParams>): Promise<any>;
-    /** Creates a Space Environment Upload
-     *
-     * @param params Space Id and Environment Id to identify the Space Environment
-     * @param data the Space Environment Upload
-     * @returns the Space Environment Upload
-     * @throws if the request fails, or the Space Environment is not found
-     * @example
-     * ```javascript
-     * const file = fs.readFileSync('<path_to_file>');
-     * const upload = await client.upload.create(
-     *   {
-     *     spaceId: '<space_id>',
-     *     environmentId: '<environment_id>',
-     *   },
-     *   {
-     *     file: new ArrayBuffer(file.length),
-     *   }
-     * );
-     * ```
-     */
-    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: {
-        file: string | ArrayBuffer | ReadableStream;
-    }): Promise<any>;
-    /** Deletes the Space Environment Upload
-     *
-     * @param params Space Id, Environment Id and Upload Id to identify the Space Environment Upload
-     * @throws if the request fails, or the Space Environment Upload is not found
-     * @example
-     * ```javascript
-     * await client.upload.delete({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   uploadId: '<upload_id>',
-     * });
-     * ```
-     */
-    delete(params: OptionalDefaults<GetSpaceEnvironmentUploadParams>): Promise<any>;
-};