contentful-management

  • Version 7.51.0
  • Published
  • 7.14 MB
  • 6 dependencies
  • MIT license

Install

npm i contentful-management
yarn add contentful-management
pnpm add contentful-management

Overview

Contentful Management API SDK. Allows you to create instances of a client with access to the Contentful Content Management API.

Index

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Functions

function asIterator

asIterator: <P extends QueryParams, T, F extends IterableFn<P, T>>(
fn: F,
params: ParamsType<F>
) => AsyncIterable<T>;

    function createClient

    createClient: {
    (params: ClientOptions): ClientAPI;
    (params: any, opts: { type: 'plain'; defaults?: DefaultParams }): PlainClientAPI;
    <
    T extends (readonly string[] | readonly ['workflows']) &
    { [K in keyof T]: { [P in K]: 'workflows' } }[number]
    >(
    params: any,
    opts: { type: 'plain'; alphaFeatures: T; defaults?: DefaultParams }
    ): AlphaPlainClientAPI;
    (
    params: any,
    opts: { type: 'plain'; alphaFeatures: string[]; defaults?: DefaultParams }
    ): PlainClientAPI;
    };
    • Create a client instance

      Parameter params

      Client initialization parameters

      const client = contentfulManagement.createClient({
      accessToken: 'myAccessToken'
      })

    function isDraft

    isDraft: (data: { sys: MetaSysProps }) => boolean;

      function isPublished

      isPublished: (data: { sys: MetaSysProps }) => boolean;

        function isUpdated

        isUpdated: (data: { sys: MetaSysProps }) => boolean;

          Classes

          class RestAdapter

          class RestAdapter implements Adapter {}

            constructor

            constructor(params: any);

              method makeRequest

              makeRequest: <R>({
              entityType,
              action: actionInput,
              params,
              payload,
              headers,
              userAgent,
              }: MakeRequestOptions) => Promise<R>;

                Interfaces

                interface Adapter

                interface Adapter {}

                  property makeRequest

                  makeRequest: MakeRequestWithUserAgent;

                    interface ApiKey

                    interface ApiKey extends ApiKeyProps, DefaultElements<ApiKeyProps> {}

                      method delete

                      delete: () => Promise<void>;
                      • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                        Example 1

                        ```javascript const contentful = require('contentful-management')

                        const client = contentful.createClient({ accessToken: '<content_management_api_key>' }) client.getSpace('<space_id>') .then((space) => space.getApiKey()) .then((apiKey) => apiKey.delete()) .then(() => console.log('apikey deleted')) .catch(console.error) ```

                      method update

                      update: () => Promise<ApiKey>;
                      • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                        Example 1

                        ```javascript const contentful = require('contentful-management')

                        const client = contentful.createClient({ accessToken: '<content_management_api_key>' }) client.getSpace('<space_id>') .then((space) => space.getApiKey()) .then((apiKey) => { apiKey.name = 'New name' return apiKey.update() }) .then(apiKey => console.log(apiKey.name)) .catch(console.error) ```

                      interface AppBundle

                      interface AppBundle extends AppBundleProps, DefaultElements<AppBundleProps> {}

                        method delete

                        delete: () => Promise<void>;
                        • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                          Example 1

                          ```javascript const contentful = require('contentful-management')

                          const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                          client.getOrganization('<org_id>') .then((org) => org.getAppDefinition('<app_def_id>')) .then((appDefinition) => appDefinition.getAppBundle('')) .then((appBundle) => appBundle.delete()) .catch(console.error) ```

                        interface AppDetails

                        interface AppDetails extends AppDetailsProps, DefaultElements<AppDetailsProps> {}

                          method delete

                          delete: () => Promise<void>;
                          • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                            Example 1

                            ```javascript const contentful = require('contentful-management')

                            const client = contentful.createClient({ accessToken: '<content_management_api_key>' }) client.getOrganization('<organization_id>') .then((organization) => organization.getAppDetails()) .then((appDetails) => appDetails.delete()) .then(() => console.log('appDetails deleted')) .catch(console.error) ```

                          interface AppIcon

                          interface AppIcon {}

                            property type

                            type: IconType;

                              property value

                              value: string;

                                interface AppInstallation

                                interface AppInstallation
                                extends AppInstallationProps,
                                DefaultElements<AppInstallationProps> {}

                                  method delete

                                  delete: () => Promise<void>;
                                  • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                    Example 1

                                    ```javascript const contentful = require('contentful-management')

                                    const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                    client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getAppInstallation('<app_definition_id>')) .then((appInstallation) => appInstallation.delete()) .then(() => console.log(App installation deleted.)) .catch(console.error) ```

                                  method update

                                  update: () => Promise<AppInstallation>;
                                  • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                    Example 1

                                    ```javascript const contentful = require('contentful-management')

                                    const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                    client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getAppInstallation('<app_definition_id>')) .then((appInstallation) => { appInstallation.parameters.someParameter = 'New Value' return appInstallation.update() }) .then((appInstallation) => console.log(App installation ${appInstallation.sys.id} was updated)) .catch(console.error) ```

                                  interface AppSignedRequest

                                  interface AppSignedRequest
                                  extends AppSignedRequestProps,
                                  DefaultElements<AppSignedRequestProps> {}

                                    interface AppSigningSecret

                                    interface AppSigningSecret
                                    extends AppSigningSecretProps,
                                    DefaultElements<AppSigningSecretProps> {}

                                      method delete

                                      delete: () => Promise<void>;
                                      • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                        Example 1

                                        ```javascript const contentful = require('contentful-management')

                                        const client = contentful.createClient({ accessToken: '<content_management_api_key>' }) client.getOrganization('<organization_id>') .then((organization) => organization.getAppSigningSecret()) .then((signingSecret) => signingSecret.delete()) .then(() => console.log('signingSecret deleted')) .catch(console.error) ```

                                      interface AppUpload

                                      interface AppUpload extends AppUploadProps, DefaultElements<AppUploadProps> {}

                                        method delete

                                        delete: () => Promise<void>;
                                        • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                          Example 1

                                          ```javascript const contentful = require('contentful-management')

                                          const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                          client.getOrganization('<org_id>') .then((org) => org.getAppUpload('<app_upload_id>')) .then((appUpload) => appUpload.delete()) .then(() => console.log(App Upload deleted.)) .catch(console.error) ```

                                        interface Asset

                                        interface Asset extends AssetProps, DefaultElements<AssetProps>, AssetApi {}

                                          interface AssetFileProp

                                          interface AssetFileProp {}

                                            property fields

                                            fields: {
                                            title: {
                                            [key: string]: string;
                                            };
                                            description: {
                                            [key: string]: string;
                                            };
                                            file: {
                                            [key: string]: {
                                            file: string | ArrayBuffer | Stream;
                                            contentType: string;
                                            fileName: string;
                                            };
                                            };
                                            };

                                              property sys

                                              sys: MetaSysProps;

                                                interface AssetKey

                                                interface AssetKey extends AssetKeyProps, DefaultElements<AssetKeyProps> {}

                                                  interface BaseCollection

                                                  interface BaseCollection<T> {}

                                                    property items

                                                    items: T[];

                                                      property sys

                                                      sys: {
                                                      type: 'Array';
                                                      };

                                                        interface BasicCursorPaginationOptions

                                                        interface BasicCursorPaginationOptions {}

                                                          property next

                                                          next?: string;

                                                            property prev

                                                            prev?: string;

                                                              interface BasicMetaSysProps

                                                              interface BasicMetaSysProps {}

                                                                property createdAt

                                                                createdAt: string;

                                                                  property createdBy

                                                                  createdBy?: SysLink;

                                                                    property id

                                                                    id: string;

                                                                      property type

                                                                      type: string;

                                                                        property updatedAt

                                                                        updatedAt: string;

                                                                          property updatedBy

                                                                          updatedBy?: SysLink;

                                                                            property version

                                                                            version: number;

                                                                              interface BasicQueryOptions

                                                                              interface BasicQueryOptions {}

                                                                                property limit

                                                                                limit?: number;

                                                                                  property skip

                                                                                  skip?: number;

                                                                                    index signature

                                                                                    [key: string]: any;

                                                                                      interface BulkAction

                                                                                      interface BulkAction<T extends BulkActionPayload = any>
                                                                                      extends BulkActionProps<T>,
                                                                                      BulkActionApiMethods,
                                                                                      DefaultElements<BulkActionProps<T>> {}

                                                                                        interface BulkActionProps

                                                                                        interface BulkActionProps<TPayload extends BulkActionPayload = any> {}
                                                                                        • The object returned by the BulkActions API

                                                                                        property action

                                                                                        action: BulkActionType;

                                                                                          property error

                                                                                          error?: BulkActionFailedError;
                                                                                          • error information, if present

                                                                                          property payload

                                                                                          payload: TPayload;
                                                                                          • original payload when BulkAction was created

                                                                                          property sys

                                                                                          sys: BulkActionSysProps;

                                                                                            interface BulkActionPublishPayload

                                                                                            interface BulkActionPublishPayload extends MakeRequestPayload {}

                                                                                              property entities

                                                                                              entities: {
                                                                                              sys?: {
                                                                                              type: 'Array';
                                                                                              };
                                                                                              items: Collection<VersionedLink<Entity>>;
                                                                                              };

                                                                                                interface BulkActionUnpublishPayload

                                                                                                interface BulkActionUnpublishPayload extends MakeRequestPayload {}

                                                                                                  property entities

                                                                                                  entities: {
                                                                                                  sys?: {
                                                                                                  type: 'Array';
                                                                                                  };
                                                                                                  items: Collection<Link<Entity>>;
                                                                                                  };

                                                                                                    interface BulkActionValidatePayload

                                                                                                    interface BulkActionValidatePayload extends MakeRequestPayload {}

                                                                                                      property action

                                                                                                      action?: 'publish';

                                                                                                        property entities

                                                                                                        entities: {
                                                                                                        sys?: {
                                                                                                        type: 'Array';
                                                                                                        };
                                                                                                        items: Collection<Link<Entity>>;
                                                                                                        };

                                                                                                          interface Collection

                                                                                                          interface Collection<T, TPlain>
                                                                                                          extends CollectionProp<T>,
                                                                                                          DefaultElements<CollectionProp<TPlain>> {}

                                                                                                            interface CollectionProp

                                                                                                            interface CollectionProp<TObj> {}

                                                                                                              property items

                                                                                                              items: TObj[];

                                                                                                                property limit

                                                                                                                limit: number;

                                                                                                                  property skip

                                                                                                                  skip: number;

                                                                                                                    property sys

                                                                                                                    sys: {
                                                                                                                    type: 'Array';
                                                                                                                    };

                                                                                                                      property total

                                                                                                                      total: number;

                                                                                                                        interface Comment

                                                                                                                        interface Comment extends CommentProps, DefaultElements<CommentProps>, CommentApi {}

                                                                                                                          interface ContentFields

                                                                                                                          interface ContentFields<T = KeyValueMap> extends Item {}

                                                                                                                            property apiName

                                                                                                                            apiName?: string;

                                                                                                                              property defaultValue

                                                                                                                              defaultValue?: T;

                                                                                                                                property deleted

                                                                                                                                deleted?: boolean;

                                                                                                                                  property disabled

                                                                                                                                  disabled?: boolean;

                                                                                                                                    property id

                                                                                                                                    id: string;

                                                                                                                                      property items

                                                                                                                                      items?: Item;

                                                                                                                                        property localized

                                                                                                                                        localized: boolean;

                                                                                                                                          property name

                                                                                                                                          name: string;

                                                                                                                                            property omitted

                                                                                                                                            omitted?: boolean;

                                                                                                                                              property required

                                                                                                                                              required: boolean;

                                                                                                                                                interface ContentType

                                                                                                                                                interface ContentType
                                                                                                                                                extends ContentTypeProps,
                                                                                                                                                DefaultElements<ContentTypeProps>,
                                                                                                                                                ContentTypeApi {}

                                                                                                                                                  interface ContentTypeFieldValidation

                                                                                                                                                  interface ContentTypeFieldValidation {}

                                                                                                                                                    property assetFileSize

                                                                                                                                                    assetFileSize?: NumRange;

                                                                                                                                                      property assetImageDimensions

                                                                                                                                                      assetImageDimensions?: {
                                                                                                                                                      width?: NumRange;
                                                                                                                                                      height?: NumRange;
                                                                                                                                                      };

                                                                                                                                                        property dateRange

                                                                                                                                                        dateRange?: DateRange;

                                                                                                                                                          property enabledMarks

                                                                                                                                                          enabledMarks?: string[];

                                                                                                                                                            property enabledNodeTypes

                                                                                                                                                            enabledNodeTypes?: string[];

                                                                                                                                                              property in

                                                                                                                                                              in?: (string | number)[];

                                                                                                                                                                property linkContentType

                                                                                                                                                                linkContentType?: string[];

                                                                                                                                                                  property linkMimetypeGroup

                                                                                                                                                                  linkMimetypeGroup?: string[];

                                                                                                                                                                    property prohibitRegexp

                                                                                                                                                                    prohibitRegexp?: RegExp;

                                                                                                                                                                      property range

                                                                                                                                                                      range?: NumRange;

                                                                                                                                                                        property regexp

                                                                                                                                                                        regexp?: RegExp;

                                                                                                                                                                          property size

                                                                                                                                                                          size?: NumRange;

                                                                                                                                                                            property unique

                                                                                                                                                                            unique?: boolean;

                                                                                                                                                                              interface Control

                                                                                                                                                                              interface Control extends WidgetConfig {}

                                                                                                                                                                                property fieldId

                                                                                                                                                                                fieldId: string;
                                                                                                                                                                                • ID of the customized field

                                                                                                                                                                                interface CursorPaginatedCollection

                                                                                                                                                                                interface CursorPaginatedCollection<T, TPlain>
                                                                                                                                                                                extends CursorPaginatedCollectionProp<T>,
                                                                                                                                                                                DefaultElements<CursorPaginatedCollectionProp<TPlain>> {}

                                                                                                                                                                                  interface CursorPaginatedCollectionProp

                                                                                                                                                                                  interface CursorPaginatedCollectionProp<TObj>
                                                                                                                                                                                  extends Omit<CollectionProp<TObj>, 'total' | 'skip'> {}

                                                                                                                                                                                    property pages

                                                                                                                                                                                    pages?: BasicCursorPaginationOptions;

                                                                                                                                                                                      interface DefaultElements

                                                                                                                                                                                      interface DefaultElements<TPlainObject extends object = object> {}

                                                                                                                                                                                        method toPlainObject

                                                                                                                                                                                        toPlainObject: () => TPlainObject;

                                                                                                                                                                                          interface Editor

                                                                                                                                                                                          interface Editor {}

                                                                                                                                                                                            property disabled

                                                                                                                                                                                            disabled?: boolean;
                                                                                                                                                                                            • Widget will be enabled if disabled property is missing

                                                                                                                                                                                            property settings

                                                                                                                                                                                            settings?: DefinedParameters;
                                                                                                                                                                                            • Instance parameter values

                                                                                                                                                                                            property widgetId

                                                                                                                                                                                            widgetId: string;
                                                                                                                                                                                            • ID of the widget used

                                                                                                                                                                                            property widgetNamespace

                                                                                                                                                                                            widgetNamespace: string;
                                                                                                                                                                                            • Type of the widget used

                                                                                                                                                                                            interface EditorInterface

                                                                                                                                                                                            interface EditorInterface
                                                                                                                                                                                            extends EditorInterfaceProps,
                                                                                                                                                                                            DefaultElements<EditorInterfaceProps> {}

                                                                                                                                                                                              method getControlForField

                                                                                                                                                                                              getControlForField: (id: string) => null | Control;
                                                                                                                                                                                              • Gets a control for a specific field control object for specific field

                                                                                                                                                                                                const contentful = require('contentful-management')
                                                                                                                                                                                                const client = contentful.createClient({
                                                                                                                                                                                                accessToken: '<content_management_api_key>'
                                                                                                                                                                                                })
                                                                                                                                                                                                client.getSpace('<space_id>')
                                                                                                                                                                                                .then((space) => space.getEnvironment('<environment_id>'))
                                                                                                                                                                                                .then((environment) => environment.getContentType('<contentType_id>'))
                                                                                                                                                                                                .then((contentType) => contentType.getEditorInterface())
                                                                                                                                                                                                .then((editorInterface) => {
                                                                                                                                                                                                control = editorInterface.getControlForField('<field-id>')
                                                                                                                                                                                                console.log(control)
                                                                                                                                                                                                })
                                                                                                                                                                                                .catch(console.error)

                                                                                                                                                                                              method update

                                                                                                                                                                                              update: () => Promise<EditorInterface>;
                                                                                                                                                                                              • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                const contentful = require('contentful-management')
                                                                                                                                                                                                const client = contentful.createClient({
                                                                                                                                                                                                accessToken: '<content_management_api_key>'
                                                                                                                                                                                                })
                                                                                                                                                                                                client.getSpace('<space_id>')
                                                                                                                                                                                                .then((space) => space.getEnvironment('<environment_id>'))
                                                                                                                                                                                                .then((environment) => environment.getContentType('<contentType_id>'))
                                                                                                                                                                                                .then((contentType) => contentType.getEditorInterface())
                                                                                                                                                                                                .then((editorInterface) => {
                                                                                                                                                                                                editorInterface.controls[0] = { "fieldId": "title", "widgetId": "singleLine"}
                                                                                                                                                                                                editorInterface.editors = [
                                                                                                                                                                                                { "widgetId": "custom-widget", "widgetNamespace": "app" }
                                                                                                                                                                                                ]
                                                                                                                                                                                                return editorInterface.update()
                                                                                                                                                                                                })
                                                                                                                                                                                                .catch(console.error)

                                                                                                                                                                                              interface EntityMetaSysProps

                                                                                                                                                                                              interface EntityMetaSysProps extends MetaSysProps {}

                                                                                                                                                                                                property contentType

                                                                                                                                                                                                contentType: SysLink;

                                                                                                                                                                                                  property environment

                                                                                                                                                                                                  environment: SysLink;

                                                                                                                                                                                                    property firstPublishedAt

                                                                                                                                                                                                    firstPublishedAt?: string;

                                                                                                                                                                                                      property locale

                                                                                                                                                                                                      locale?: string;

                                                                                                                                                                                                        property publishedAt

                                                                                                                                                                                                        publishedAt?: string;

                                                                                                                                                                                                          property publishedBy

                                                                                                                                                                                                          publishedBy?: Link<'User'> | Link<'AppDefinition'>;

                                                                                                                                                                                                            property publishedCounter

                                                                                                                                                                                                            publishedCounter?: number;

                                                                                                                                                                                                              property space

                                                                                                                                                                                                              space: SysLink;

                                                                                                                                                                                                                interface Entry

                                                                                                                                                                                                                interface Entry
                                                                                                                                                                                                                extends EntryProps,
                                                                                                                                                                                                                DefaultElements<EntryProps>,
                                                                                                                                                                                                                ContentfulEntryApi {}

                                                                                                                                                                                                                  interface EntryFieldLocation

                                                                                                                                                                                                                  interface EntryFieldLocation {}

                                                                                                                                                                                                                    property fieldTypes

                                                                                                                                                                                                                    fieldTypes: FieldType[];

                                                                                                                                                                                                                      property location

                                                                                                                                                                                                                      location: 'entry-field';

                                                                                                                                                                                                                        interface EnvironmentAlias

                                                                                                                                                                                                                        interface EnvironmentAlias
                                                                                                                                                                                                                        extends EnvironmentAliasProps,
                                                                                                                                                                                                                        DefaultElements<EnvironmentAliasProps> {}

                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                          delete: () => Promise<void>;
                                                                                                                                                                                                                          • Deletes this object on the server. EnvironmentAlias delete {Promise} Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                            const contentful = require('contentful-management')
                                                                                                                                                                                                                            const client = contentful.createClient({
                                                                                                                                                                                                                            accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                            })
                                                                                                                                                                                                                            client.getSpace('<space_id>')
                                                                                                                                                                                                                            .then((space) => space.getEnvironmentAlias('<environment_alias_id>'))
                                                                                                                                                                                                                            .then((alias) => {
                                                                                                                                                                                                                            return alias.delete()
                                                                                                                                                                                                                            })
                                                                                                                                                                                                                            .then(() => console.log(`Alias deleted.`))
                                                                                                                                                                                                                            .catch(console.error)

                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                          update: () => Promise<EnvironmentAlias>;
                                                                                                                                                                                                                          • Sends an update to the server with any changes made to the object's properties. Currently, you can only change the id of the alias's underlying environment. See the example below. EnvironmentAlias update {Promise} Object returned from the server with updated changes.

                                                                                                                                                                                                                            const contentful = require('contentful-management')
                                                                                                                                                                                                                            const client = contentful.createClient({
                                                                                                                                                                                                                            accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                            })
                                                                                                                                                                                                                            client.getSpace('<space_id>')
                                                                                                                                                                                                                            .then((space) => space.getEnvironmentAlias('<environment_alias_id>'))
                                                                                                                                                                                                                            .then((alias) => {
                                                                                                                                                                                                                            alias.environment.sys.id = '<environment_id>'
                                                                                                                                                                                                                            return alias.update()
                                                                                                                                                                                                                            })
                                                                                                                                                                                                                            .then((alias) => console.log(`alias ${alias.sys.id} updated.`))
                                                                                                                                                                                                                            .catch(console.error)

                                                                                                                                                                                                                          interface FieldGroupItem

                                                                                                                                                                                                                          interface FieldGroupItem {}

                                                                                                                                                                                                                            property groupId

                                                                                                                                                                                                                            groupId: string;

                                                                                                                                                                                                                              property items

                                                                                                                                                                                                                              items: EditorLayoutItem[];

                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                  interface FieldItem

                                                                                                                                                                                                                                  interface FieldItem {}

                                                                                                                                                                                                                                    property fieldId

                                                                                                                                                                                                                                    fieldId: string;

                                                                                                                                                                                                                                      interface GroupControl

                                                                                                                                                                                                                                      interface GroupControl extends WidgetConfig {}

                                                                                                                                                                                                                                        property groupId

                                                                                                                                                                                                                                        groupId: string;
                                                                                                                                                                                                                                        • ID of the customized field group

                                                                                                                                                                                                                                        interface Link<T extends string> {}
                                                                                                                                                                                                                                        • Link is a reference object to another entity that can be resolved using tools such as contentful-resolve

                                                                                                                                                                                                                                        property sys

                                                                                                                                                                                                                                        sys: {
                                                                                                                                                                                                                                        type: 'Link';
                                                                                                                                                                                                                                        linkType: T;
                                                                                                                                                                                                                                        id: string;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          interface Locale

                                                                                                                                                                                                                                          interface Locale extends LocaleProps, DefaultElements<LocaleProps> {}

                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                            delete: () => Promise<void>;
                                                                                                                                                                                                                                            • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                              ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                              const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                              client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getLocale('<locale_id>')) .then((locale) => locale.delete()) .then(() => console.log(locale deleted.)) .catch(console.error) ```

                                                                                                                                                                                                                                            method update

                                                                                                                                                                                                                                            update: () => Promise<Locale>;
                                                                                                                                                                                                                                            • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                              ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                              const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                              client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getLocale('<locale_id>')) .then((locale) => { locale.name = 'New locale name' return locale.update() }) .then((locale) => console.log(locale ${locale.sys.id} updated.)) .catch(console.error) ```

                                                                                                                                                                                                                                            interface MakeRequestOptions

                                                                                                                                                                                                                                            interface MakeRequestOptions {}

                                                                                                                                                                                                                                              property action

                                                                                                                                                                                                                                              action: string;

                                                                                                                                                                                                                                                property entityType

                                                                                                                                                                                                                                                entityType: keyof MRActions;

                                                                                                                                                                                                                                                  property headers

                                                                                                                                                                                                                                                  headers?: Record<string, unknown>;

                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                    params?: Record<string, unknown>;

                                                                                                                                                                                                                                                      property payload

                                                                                                                                                                                                                                                      payload?: Record<string, unknown> | OpPatch[] | MakeRequestPayload;

                                                                                                                                                                                                                                                        property userAgent

                                                                                                                                                                                                                                                        userAgent: string;

                                                                                                                                                                                                                                                          interface MakeRequestPayload

                                                                                                                                                                                                                                                          interface MakeRequestPayload {}
                                                                                                                                                                                                                                                          • Base interface for all Payload interfaces. Used as part of the MakeRequestOptions to simplify payload definitions.

                                                                                                                                                                                                                                                          interface MetadataProps

                                                                                                                                                                                                                                                          interface MetadataProps {}

                                                                                                                                                                                                                                                            property tags

                                                                                                                                                                                                                                                            tags: Link<'Tag'>[];

                                                                                                                                                                                                                                                              interface MetaLinkProps

                                                                                                                                                                                                                                                              interface MetaLinkProps {}

                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                  property linkType

                                                                                                                                                                                                                                                                  linkType: string;

                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                      interface MetaSysProps

                                                                                                                                                                                                                                                                      interface MetaSysProps extends BasicMetaSysProps {}

                                                                                                                                                                                                                                                                        property archivedAt

                                                                                                                                                                                                                                                                        archivedAt?: string;

                                                                                                                                                                                                                                                                          property archivedBy

                                                                                                                                                                                                                                                                          archivedBy?: SysLink;

                                                                                                                                                                                                                                                                            property archivedVersion

                                                                                                                                                                                                                                                                            archivedVersion?: number;

                                                                                                                                                                                                                                                                              property deletedAt

                                                                                                                                                                                                                                                                              deletedAt?: string;

                                                                                                                                                                                                                                                                                property deletedBy

                                                                                                                                                                                                                                                                                deletedBy?: SysLink;

                                                                                                                                                                                                                                                                                  property deletedVersion

                                                                                                                                                                                                                                                                                  deletedVersion?: number;

                                                                                                                                                                                                                                                                                    property publishedVersion

                                                                                                                                                                                                                                                                                    publishedVersion?: number;

                                                                                                                                                                                                                                                                                      property space

                                                                                                                                                                                                                                                                                      space?: SysLink;

                                                                                                                                                                                                                                                                                        property status

                                                                                                                                                                                                                                                                                        status?: SysLink;
                                                                                                                                                                                                                                                                                          interface NavigationItem {}
                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                              path: string;

                                                                                                                                                                                                                                                                                                interface OrganizationInvitation

                                                                                                                                                                                                                                                                                                interface OrganizationInvitation
                                                                                                                                                                                                                                                                                                extends OrganizationInvitationProps,
                                                                                                                                                                                                                                                                                                DefaultElements<OrganizationInvitationProps> {}

                                                                                                                                                                                                                                                                                                  interface OrganizationMembership

                                                                                                                                                                                                                                                                                                  interface OrganizationMembership
                                                                                                                                                                                                                                                                                                  extends OrganizationMembershipProps,
                                                                                                                                                                                                                                                                                                  DefaultElements<OrganizationMembershipProps> {}

                                                                                                                                                                                                                                                                                                    method delete

                                                                                                                                                                                                                                                                                                    delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                    • Deletes this object on the server. @example```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                      const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                      client.getOrganization('organization_id') .then(org => org.getOrganizationMembership('organizationMembership_id')) .then((organizationMembership) => { organizationMembership.delete(); }) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                    method update

                                                                                                                                                                                                                                                                                                    update: () => Promise<OrganizationMembership>;
                                                                                                                                                                                                                                                                                                    • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                                      ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                      const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                      client.getOrganization('organization_id') .then(org => org.getOrganizationMembership('organizationMembership_id')) .then((organizationMembership) => { organizationMembership.role = 'member'; organizationMembership.update(); }) .catch(console.error)

                                                                                                                                                                                                                                                                                                    interface PageLocation

                                                                                                                                                                                                                                                                                                    interface PageLocation {}

                                                                                                                                                                                                                                                                                                      property location

                                                                                                                                                                                                                                                                                                      location: 'page';

                                                                                                                                                                                                                                                                                                        property navigationItem

                                                                                                                                                                                                                                                                                                        navigationItem?: NavigationItem;

                                                                                                                                                                                                                                                                                                          interface PaginationQueryOptions

                                                                                                                                                                                                                                                                                                          interface PaginationQueryOptions {}

                                                                                                                                                                                                                                                                                                            property limit

                                                                                                                                                                                                                                                                                                            limit?: number;

                                                                                                                                                                                                                                                                                                              property order

                                                                                                                                                                                                                                                                                                              order?: string;

                                                                                                                                                                                                                                                                                                                property skip

                                                                                                                                                                                                                                                                                                                skip?: number;

                                                                                                                                                                                                                                                                                                                  interface ParameterDefinition

                                                                                                                                                                                                                                                                                                                  interface ParameterDefinition {}

                                                                                                                                                                                                                                                                                                                    property default

                                                                                                                                                                                                                                                                                                                    default?: boolean | string | number;

                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                      description?: string;

                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                          property labels

                                                                                                                                                                                                                                                                                                                          labels?: {
                                                                                                                                                                                                                                                                                                                          empty?: string;
                                                                                                                                                                                                                                                                                                                          true?: string;
                                                                                                                                                                                                                                                                                                                          false?: string;
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                                                                                              options?: ParameterOption[];

                                                                                                                                                                                                                                                                                                                                property required

                                                                                                                                                                                                                                                                                                                                required?: boolean;

                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                  type: ParameterType;

                                                                                                                                                                                                                                                                                                                                    interface PersonalAccessToken

                                                                                                                                                                                                                                                                                                                                    interface PersonalAccessToken
                                                                                                                                                                                                                                                                                                                                    extends PersonalAccessTokenProp,
                                                                                                                                                                                                                                                                                                                                    DefaultElements<PersonalAccessTokenProp> {}

                                                                                                                                                                                                                                                                                                                                      method revoke

                                                                                                                                                                                                                                                                                                                                      revoke: () => Promise<PersonalAccessToken>;
                                                                                                                                                                                                                                                                                                                                      • Revokes a personal access token Object the revoked personal access token

                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                        ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({ accessToken: <content_management_api_key> })

                                                                                                                                                                                                                                                                                                                                        client.getPersonalAccessToken('') .then((personalAccessToken) => { return personalAccessToken.revoke() }) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                      interface PreviewApiKey

                                                                                                                                                                                                                                                                                                                                      interface PreviewApiKey
                                                                                                                                                                                                                                                                                                                                      extends PreviewApiKeyProps,
                                                                                                                                                                                                                                                                                                                                      DefaultElements<PreviewApiKeyProps> {}

                                                                                                                                                                                                                                                                                                                                        interface QueryOptions

                                                                                                                                                                                                                                                                                                                                        interface QueryOptions extends PaginationQueryOptions {}

                                                                                                                                                                                                                                                                                                                                          property content_type

                                                                                                                                                                                                                                                                                                                                          content_type?: string;

                                                                                                                                                                                                                                                                                                                                            property include

                                                                                                                                                                                                                                                                                                                                            include?: number;

                                                                                                                                                                                                                                                                                                                                              property links_to_entry

                                                                                                                                                                                                                                                                                                                                              links_to_entry?: string;

                                                                                                                                                                                                                                                                                                                                                property select

                                                                                                                                                                                                                                                                                                                                                select?: string;

                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                    interface QueryOptions

                                                                                                                                                                                                                                                                                                                                                    interface QueryOptions extends BasicQueryOptions {}

                                                                                                                                                                                                                                                                                                                                                      property content_type

                                                                                                                                                                                                                                                                                                                                                      content_type?: string;

                                                                                                                                                                                                                                                                                                                                                        property include

                                                                                                                                                                                                                                                                                                                                                        include?: number;

                                                                                                                                                                                                                                                                                                                                                          property select

                                                                                                                                                                                                                                                                                                                                                          select?: string;

                                                                                                                                                                                                                                                                                                                                                            interface Release

                                                                                                                                                                                                                                                                                                                                                            interface Release
                                                                                                                                                                                                                                                                                                                                                            extends ReleaseProps,
                                                                                                                                                                                                                                                                                                                                                            ReleaseApiMethods,
                                                                                                                                                                                                                                                                                                                                                            DefaultElements<ReleaseProps> {}

                                                                                                                                                                                                                                                                                                                                                              interface ReleaseAction

                                                                                                                                                                                                                                                                                                                                                              interface ReleaseAction<T extends ReleaseActionTypes = any>
                                                                                                                                                                                                                                                                                                                                                              extends ReleaseActionProps<T>,
                                                                                                                                                                                                                                                                                                                                                              ReleaseActionApiMethods,
                                                                                                                                                                                                                                                                                                                                                              DefaultElements<ReleaseActionProps<T>> {}

                                                                                                                                                                                                                                                                                                                                                                interface ReleaseActionProps

                                                                                                                                                                                                                                                                                                                                                                interface ReleaseActionProps<T extends ReleaseActionTypes = any> {}
                                                                                                                                                                                                                                                                                                                                                                • The object returned by the Releases API

                                                                                                                                                                                                                                                                                                                                                                property action

                                                                                                                                                                                                                                                                                                                                                                action: T;

                                                                                                                                                                                                                                                                                                                                                                  property sys

                                                                                                                                                                                                                                                                                                                                                                  sys: ReleaseActionSysProps;

                                                                                                                                                                                                                                                                                                                                                                    interface ReleaseActionQueryOptions

                                                                                                                                                                                                                                                                                                                                                                    interface ReleaseActionQueryOptions {}

                                                                                                                                                                                                                                                                                                                                                                      property 'sys.id[in]'

                                                                                                                                                                                                                                                                                                                                                                      'sys.id[in]'?: string;
                                                                                                                                                                                                                                                                                                                                                                      • Find Release Actions by using a comma-separated list of Ids

                                                                                                                                                                                                                                                                                                                                                                      property limit

                                                                                                                                                                                                                                                                                                                                                                      limit?: number;
                                                                                                                                                                                                                                                                                                                                                                      • Limit of how many records are returned in the query result 100

                                                                                                                                                                                                                                                                                                                                                                      interface ReleasePayload

                                                                                                                                                                                                                                                                                                                                                                      interface ReleasePayload extends MakeRequestPayload {}

                                                                                                                                                                                                                                                                                                                                                                        property entities

                                                                                                                                                                                                                                                                                                                                                                        entities: BaseCollection<Link<Entity>>;

                                                                                                                                                                                                                                                                                                                                                                          property title

                                                                                                                                                                                                                                                                                                                                                                          title: string;

                                                                                                                                                                                                                                                                                                                                                                            interface ReleaseProps

                                                                                                                                                                                                                                                                                                                                                                            interface ReleaseProps {}
                                                                                                                                                                                                                                                                                                                                                                            • The object returned by the Releases API

                                                                                                                                                                                                                                                                                                                                                                            property entities

                                                                                                                                                                                                                                                                                                                                                                            entities: BaseCollection<Link<Entity>>;

                                                                                                                                                                                                                                                                                                                                                                              property sys

                                                                                                                                                                                                                                                                                                                                                                              sys: ReleaseSysProps;

                                                                                                                                                                                                                                                                                                                                                                                property title

                                                                                                                                                                                                                                                                                                                                                                                title: string;

                                                                                                                                                                                                                                                                                                                                                                                  interface ReleaseQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                  interface ReleaseQueryOptions {}

                                                                                                                                                                                                                                                                                                                                                                                    property 'entities.sys.id[in]'

                                                                                                                                                                                                                                                                                                                                                                                    'entities.sys.id[in]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Find releases containing the specified, comma-separated entities. Requires entities.sys.linkType

                                                                                                                                                                                                                                                                                                                                                                                    property 'entities.sys.linkType'

                                                                                                                                                                                                                                                                                                                                                                                    'entities.sys.linkType'?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Find releases filtered by the Entity type (Asset, Entry)

                                                                                                                                                                                                                                                                                                                                                                                    property 'sys.createdBy.sys.id[in]'

                                                                                                                                                                                                                                                                                                                                                                                    'sys.createdBy.sys.id[in]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Filters by creator of release

                                                                                                                                                                                                                                                                                                                                                                                    property 'sys.id[in]'

                                                                                                                                                                                                                                                                                                                                                                                    'sys.id[in]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Find releases by using a comma-separated list of Ids

                                                                                                                                                                                                                                                                                                                                                                                    property 'title[match]'

                                                                                                                                                                                                                                                                                                                                                                                    'title[match]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Find releases using full text phrase and term matching

                                                                                                                                                                                                                                                                                                                                                                                    property limit

                                                                                                                                                                                                                                                                                                                                                                                    limit?: number;
                                                                                                                                                                                                                                                                                                                                                                                    • Limit how many records are returned in the result 100

                                                                                                                                                                                                                                                                                                                                                                                    property order

                                                                                                                                                                                                                                                                                                                                                                                    order?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • Order releases by -sys.updatedAt

                                                                                                                                                                                                                                                                                                                                                                                    property pageNext

                                                                                                                                                                                                                                                                                                                                                                                    pageNext?: string;
                                                                                                                                                                                                                                                                                                                                                                                    • If present, will return results based on a pagination cursor

                                                                                                                                                                                                                                                                                                                                                                                    interface ReleaseValidateOptions

                                                                                                                                                                                                                                                                                                                                                                                    interface ReleaseValidateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                      property payload

                                                                                                                                                                                                                                                                                                                                                                                      payload?: ReleaseValidatePayload;

                                                                                                                                                                                                                                                                                                                                                                                        property processingOptions

                                                                                                                                                                                                                                                                                                                                                                                        processingOptions?: AsyncActionProcessingOptions;

                                                                                                                                                                                                                                                                                                                                                                                          interface Role

                                                                                                                                                                                                                                                                                                                                                                                          interface Role extends RoleProps, DefaultElements<RoleProps> {}

                                                                                                                                                                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                                                                                                                                                                            delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                            • Deletes this object on the server. Role delete {Promise} Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                                                                                                                                                              ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                              const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                              client.getSpace('<space_id>') .then((space) => space.getRole('<role_id>')) .then((role) => role.delete()) .then((role) => console.log(role deleted.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                            method update

                                                                                                                                                                                                                                                                                                                                                                                            update: () => Promise<Role>;
                                                                                                                                                                                                                                                                                                                                                                                            • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                                                                                                                                                              ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                              const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                              client.getSpace('<space_id>') .then((space) => space.getRole('<roles_id>')) .then((roles) => { roles.name = 'New role name' return roles.update() }) .then((roles) => console.log(roles ${roles.sys.id} updated.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                            interface ScheduledAction

                                                                                                                                                                                                                                                                                                                                                                                            interface ScheduledAction
                                                                                                                                                                                                                                                                                                                                                                                            extends ScheduledActionProps,
                                                                                                                                                                                                                                                                                                                                                                                            DefaultElements<ScheduledActionProps>,
                                                                                                                                                                                                                                                                                                                                                                                            ScheduledActionApi {}

                                                                                                                                                                                                                                                                                                                                                                                              interface SidebarItem

                                                                                                                                                                                                                                                                                                                                                                                              interface SidebarItem {}

                                                                                                                                                                                                                                                                                                                                                                                                property disabled

                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                • Widget will be enabled if disabled property is missing

                                                                                                                                                                                                                                                                                                                                                                                                property settings

                                                                                                                                                                                                                                                                                                                                                                                                settings?: DefinedParameters;
                                                                                                                                                                                                                                                                                                                                                                                                • Instance parameter values

                                                                                                                                                                                                                                                                                                                                                                                                property widgetId

                                                                                                                                                                                                                                                                                                                                                                                                widgetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                • ID of the widget used

                                                                                                                                                                                                                                                                                                                                                                                                property widgetNamespace

                                                                                                                                                                                                                                                                                                                                                                                                widgetNamespace: string;
                                                                                                                                                                                                                                                                                                                                                                                                • Type of the widget used

                                                                                                                                                                                                                                                                                                                                                                                                interface SimpleLocation

                                                                                                                                                                                                                                                                                                                                                                                                interface SimpleLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                  property location

                                                                                                                                                                                                                                                                                                                                                                                                  location: LocationType;

                                                                                                                                                                                                                                                                                                                                                                                                    interface Snapshot

                                                                                                                                                                                                                                                                                                                                                                                                    interface Snapshot<T> extends SnapshotProps<T>, DefaultElements<SnapshotProps<T>> {}

                                                                                                                                                                                                                                                                                                                                                                                                      interface SpaceMember

                                                                                                                                                                                                                                                                                                                                                                                                      interface SpaceMember extends SpaceMemberProps, DefaultElements<SpaceMemberProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                        interface SpaceMembership

                                                                                                                                                                                                                                                                                                                                                                                                        interface SpaceMembership
                                                                                                                                                                                                                                                                                                                                                                                                        extends SpaceMembershipProps,
                                                                                                                                                                                                                                                                                                                                                                                                        DefaultElements<SpaceMembershipProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                                                                                          delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                          • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                            ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                            const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                            client.getSpace('<space_id>') .then((space) => space.getSpaceMembership('<spaceMembership_id>')) .then((spaceMembership) => spaceMembership.delete()) .then(() => console.log(spaceMembership deleted.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                                                                                                                                                                                                          update: () => Promise<SpaceMembership>;
                                                                                                                                                                                                                                                                                                                                                                                                          • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                            ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                            const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                            client.getSpace('<space_id>') .then((space) => space.getSpaceMembership('<spaceMembership_id>')) .then((spaceMembership) => { spaceMembership.name = 'new space membership name' }) .then((spaceMembership) => console.log(spaceMembership ${spaceMembership.sys.id} updated.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                          interface SysLink {}

                                                                                                                                                                                                                                                                                                                                                                                                            property sys

                                                                                                                                                                                                                                                                                                                                                                                                            sys: MetaLinkProps;

                                                                                                                                                                                                                                                                                                                                                                                                              interface Tag

                                                                                                                                                                                                                                                                                                                                                                                                              interface Tag extends TagProps, DefaultElements<TagProps>, TagApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                interface Task

                                                                                                                                                                                                                                                                                                                                                                                                                interface Task extends TaskProps, DefaultElements<TaskProps>, TaskApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                  interface Team

                                                                                                                                                                                                                                                                                                                                                                                                                  interface Team extends TeamProps, DefaultElements<TeamProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    method delete

                                                                                                                                                                                                                                                                                                                                                                                                                    delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                      ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                      const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                      client.getOrganization('organization_id') .then(org => org.getOrganizationMembership('organizationMembership_id')) .then((team) => { team.delete(); }) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                    method update

                                                                                                                                                                                                                                                                                                                                                                                                                    update: () => Promise<Team>;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                      ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                      const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                      client.getOrganization('organization_id') .then(org => org.getTeam('team_id')) .then((team) => { team.description = 'new description'; team.update(); }) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                    interface TeamMembership

                                                                                                                                                                                                                                                                                                                                                                                                                    interface TeamMembership
                                                                                                                                                                                                                                                                                                                                                                                                                    extends TeamMembershipProps,
                                                                                                                                                                                                                                                                                                                                                                                                                    DefaultElements<TeamMembershipProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                      method delete

                                                                                                                                                                                                                                                                                                                                                                                                                      delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                        ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                        client.getOrganization('organizationId') .then(org => org.getTeamMembership('teamId', 'teamMembershipId')) .then((teamMembership) => { teamMembership.delete(); }) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                      method update

                                                                                                                                                                                                                                                                                                                                                                                                                      update: () => Promise<TeamMembership>;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                        ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                        client.getOrganization('organizationId') .then(org => org.getTeamMembership('teamId', 'teamMembershipId')) .then((teamMembership) => { teamMembership.admin = true; teamMembership.update(); }) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                      interface TeamSpaceMembership

                                                                                                                                                                                                                                                                                                                                                                                                                      interface TeamSpaceMembership
                                                                                                                                                                                                                                                                                                                                                                                                                      extends TeamSpaceMembershipProps,
                                                                                                                                                                                                                                                                                                                                                                                                                      DefaultElements<TeamSpaceMembershipProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                        method delete

                                                                                                                                                                                                                                                                                                                                                                                                                        delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                          ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                          const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                          client.getSpace('<space_id>') .then((space) => space.getTeamSpaceMembership('<team_space_membership_id>')) .then((teamSpaceMembership) => teamSpaceMembership.delete()) .then(() => console.log(spaceMembership deleted.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                        update: () => Promise<TeamSpaceMembership>;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                          ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                          const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                          client.getSpace('<space_id>') .then((space) => space.getTeamSpaceMembership('team_space_membership_id')) .then((teamSpaceMembership) => { item.roles = [ { sys: { type: 'Link', linkType: 'Role', id: 'role_id' } } ] }) .then((spaceMembership) => console.log(spaceMembership ${spaceMembership.sys.id} updated.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                        interface UIExtension

                                                                                                                                                                                                                                                                                                                                                                                                                        interface Extension extends ExtensionProps, DefaultElements<ExtensionProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                                                                                                          delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                            ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                            const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                            client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getUiExtension('<ui_extension_id>')) .then((extension) => extension.delete()) .then(() => console.log(UI Extension deleted.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                                                                                                                                                                                                                          update: () => Promise<Extension>;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                            ```javascript const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                            const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                            client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getUiExtension('<ui_extension_id>')) .then((extension) => { extension.extension.name = 'New UI Extension name' return extension.update() }) .then((extension) => console.log(UI Extension ${extension.sys.id} updated.)) .catch(console.error) ```

                                                                                                                                                                                                                                                                                                                                                                                                                          interface Upload

                                                                                                                                                                                                                                                                                                                                                                                                                          interface Upload extends UploadProps, DefaultElements<UploadProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                                                                                                                                                                                                            delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                              const contentful = require('contentful-management')

                                                                                                                                                                                                                                                                                                                                                                                                                              const client = contentful.createClient({ accessToken: '<content_management_api_key>' })

                                                                                                                                                                                                                                                                                                                                                                                                                              client.getSpace('<space_id>') .then((space) => space.getEnvironment('<environment_id>')) .then((environment) => environment.getUpload('<upload_id>')) .then((upload) => upload.delete()) .then((upload) => console.log(upload ${upload.sys.id} updated.)) .catch(console.error)

                                                                                                                                                                                                                                                                                                                                                                                                                            interface Usage

                                                                                                                                                                                                                                                                                                                                                                                                                            interface Usage extends UsageProps, DefaultElements<UsageProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                              interface User

                                                                                                                                                                                                                                                                                                                                                                                                                              interface User extends UserProps, DefaultElements<UserProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                interface VersionedLink<T extends string> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property sys

                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                  linkType: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                  id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WebHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WebHooks extends WebhookProps, DefaultElements<WebhookProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                      delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deletes this object on the server. Promise for the deletion. It contains no data, but the Promise error case should be handled.

                                                                                                                                                                                                                                                                                                                                                                                                                                        const contentful = require('contentful-management')
                                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({
                                                                                                                                                                                                                                                                                                                                                                                                                                        accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                        client.getSpace('<space_id>')
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((space) => space.getWebhook('<webhook_id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => webhook.delete())
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => console.log(`webhook ${webhook.sys.id} updated.`))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .catch(console.error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getCall

                                                                                                                                                                                                                                                                                                                                                                                                                                      getCall: (id: string) => Promise<WebhookCallDetailsProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Webhook call with specific id. See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhook-calls/webhook-call-overviews for more details Promise for call details

                                                                                                                                                                                                                                                                                                                                                                                                                                        const contentful = require('contentful-management')
                                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({
                                                                                                                                                                                                                                                                                                                                                                                                                                        accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                        client.getSpace('<space_id>')
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((space) => space.getWebhook('<webhook_id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => webhook.getCall('<call-id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhookCall) => console.log(webhookCall))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .catch(console.error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                      getCalls: () => Promise<CollectionProp<WebhookCallOverviewProps>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • List of the most recent webhook calls. See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhook-calls/webhook-call-overviews for more details. Promise for list of calls

                                                                                                                                                                                                                                                                                                                                                                                                                                        const contentful = require('contentful-management')
                                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({
                                                                                                                                                                                                                                                                                                                                                                                                                                        accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                        client.getSpace('<space_id>')
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((space) => space.getWebhook('<webhook_id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => webhook.getCalls())
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((response) => console.log(response.items)) // webhook calls
                                                                                                                                                                                                                                                                                                                                                                                                                                        .catch(console.error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getHealth

                                                                                                                                                                                                                                                                                                                                                                                                                                      getHealth: () => Promise<WebhookHealthProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Overview of the health of webhook calls. See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhook-calls/webhook-call-overviews for more details. Promise for health info

                                                                                                                                                                                                                                                                                                                                                                                                                                        const contentful = require('contentful-management')
                                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({
                                                                                                                                                                                                                                                                                                                                                                                                                                        accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                        client.getSpace('<space_id>')
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((space) => space.getWebhook('<webhook_id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => webhook.getHealth())
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhookHealth) => console.log(webhookHealth))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .catch(console.error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      method update

                                                                                                                                                                                                                                                                                                                                                                                                                                      update: () => Promise<WebHooks>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Sends an update to the server with any changes made to the object's properties Object returned from the server with updated changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                        const contentful = require('contentful-management')
                                                                                                                                                                                                                                                                                                                                                                                                                                        const client = contentful.createClient({
                                                                                                                                                                                                                                                                                                                                                                                                                                        accessToken: '<content_management_api_key>'
                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                        client.getSpace('<space_id>')
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((space) => space.getWebhook('<webhook_id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                        webhook.name = 'new webhook name'
                                                                                                                                                                                                                                                                                                                                                                                                                                        return webhook.update()
                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then((webhook) => console.log(`webhook ${webhook.sys.id} updated.`))
                                                                                                                                                                                                                                                                                                                                                                                                                                        .catch(console.error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Workflow

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Workflow
                                                                                                                                                                                                                                                                                                                                                                                                                                      extends WorkflowProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                      DefaultElements<WorkflowProps>,
                                                                                                                                                                                                                                                                                                                                                                                                                                      WorkflowApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WorkflowDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WorkflowDefinition
                                                                                                                                                                                                                                                                                                                                                                                                                                        extends WorkflowDefinitionProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                        DefaultElements<WorkflowDefinitionProps>,
                                                                                                                                                                                                                                                                                                                                                                                                                                        WorkflowDefinitionApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                          enum BulkActionStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                          enum BulkActionStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                          created = 'created',
                                                                                                                                                                                                                                                                                                                                                                                                                                          inProgress = 'inProgress',
                                                                                                                                                                                                                                                                                                                                                                                                                                          succeeded = 'succeeded',
                                                                                                                                                                                                                                                                                                                                                                                                                                          failed = 'failed',
                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Represents the state of the BulkAction

                                                                                                                                                                                                                                                                                                                                                                                                                                          member created

                                                                                                                                                                                                                                                                                                                                                                                                                                          created = 'created'
                                                                                                                                                                                                                                                                                                                                                                                                                                          • BulkAction is pending execution

                                                                                                                                                                                                                                                                                                                                                                                                                                          member failed

                                                                                                                                                                                                                                                                                                                                                                                                                                          failed = 'failed'
                                                                                                                                                                                                                                                                                                                                                                                                                                          • BulkAction failed to complete (terminal state)

                                                                                                                                                                                                                                                                                                                                                                                                                                          member inProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                          inProgress = 'inProgress'
                                                                                                                                                                                                                                                                                                                                                                                                                                          • BulkAction has been started and pending completion

                                                                                                                                                                                                                                                                                                                                                                                                                                          member succeeded

                                                                                                                                                                                                                                                                                                                                                                                                                                          succeeded = 'succeeded'
                                                                                                                                                                                                                                                                                                                                                                                                                                          • BulkAction was completed successfully (terminal state)

                                                                                                                                                                                                                                                                                                                                                                                                                                          enum IconType

                                                                                                                                                                                                                                                                                                                                                                                                                                          enum IconType {
                                                                                                                                                                                                                                                                                                                                                                                                                                          Base64 = 'base64',
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                            member Base64

                                                                                                                                                                                                                                                                                                                                                                                                                                            Base64 = 'base64'

                                                                                                                                                                                                                                                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                              type AlphaPlainClientAPI

                                                                                                                                                                                                                                                                                                                                                                                                                                              type AlphaPlainClientAPI = PlainClientAPI & AlphaWorkflowExtension;

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ApiKeyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ApiKeyProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                sys: MetaSysProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                accessToken: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                environments: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                sys: MetaLinkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                preview_api_key: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                sys: MetaLinkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                policies?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                effect: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                action: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AppBundleFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AppBundleFile = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  size: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  md5: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppBundleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppBundleProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                    * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                                                                    sys: AppBundleSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                    * List of all the files that are in this bundle
                                                                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                                                                    files: AppBundleFile[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                    * A comment that describes this bundle
                                                                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                                                                    comment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AppDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AppDefinition = ContentfulAppDefinitionAPI &
                                                                                                                                                                                                                                                                                                                                                                                                                                                      AppDefinitionProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                      DefaultElements<AppDefinitionProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AppDefinitionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AppDefinitionProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                        * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        organization: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        shared: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                        * App name
                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                        * URL where the root HTML document of the app can be found
                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        src?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Link to an AppBundle
                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        bundle?: Link<'AppBundle'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Locations where the app can be installed
                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        locations?: AppLocation[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Instance parameter definitions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        parameters?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        instance?: ParameterDefinition[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AppDetailsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AppDetailsProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                          * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                          sys: AppDetailsSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                          * An Icon that represents the App
                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                          icon?: AppIcon;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AppInstallationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AppInstallationProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            appDefinition: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            environment: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            space: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                            * Free-form installation parameters (API limits stringified length to 16kB)
                                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                                            parameters?: FreeFormParameters;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AppLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AppLocation = SimpleLocation | EntryFieldLocation | PageLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AppSignedRequestProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AppSignedRequestProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                sys: AppSignedRequestSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                /** new headers to be included in the request */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                additionalHeaders: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'x-contentful-signature': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'x-contentful-signed-headers': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'x-contentful-timestamp': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'x-contentful-space-id': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'x-contentful-environment-id': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'x-contentful-user-id': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AppSigningSecretProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AppSigningSecretProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: AppSigningSecretSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** The last four characters of the signing secret */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  redactedValue: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppUploadProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppUploadProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sys: AppUploadSys & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expiresAt: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    organization: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AssetKeyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AssetKeyProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /** A JWT describing a policy; needs to be attached to signed URLs */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      policy: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /** A secret key to be used for signing URLs */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      secret: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AssetProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AssetProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: EntityMetaSysProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fields: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** Title for this asset */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        title: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** Description for this asset */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        description?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** File object for this asset */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        file: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fileName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contentType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** Url where the file is available to be downloaded from, into the Contentful asset system. After the asset is processed this field is gone. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        upload?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** Url where the file is available at the Contentful media asset system. This field won't be available until the asset is processed. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** Details for the file, depending on file type (example: image size in bytes, etc) */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        details?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uploadFrom?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        metadata?: MetadataProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BulkActionPayload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BulkActionPayload =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | BulkActionPublishPayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | BulkActionUnpublishPayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | BulkActionValidatePayload;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BulkActionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BulkActionType = 'publish' | 'unpublish' | 'validate';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ClientAPI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ClientAPI = ReturnType<typeof createClientApi>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ClientParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ClientParams = RestAdapterParams & UserAgentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CommentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CommentProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sys: CommentSysProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ContentTypeProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ContentTypeProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  space: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  environment: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  firstPublishedAt?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  publishedCounter?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  publishedVersion?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  description: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Field used as the main display field for Entries */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  displayField: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** All the fields contained in this Content Type */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fields: ContentFields[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateApiKeyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateApiKeyProps = Pick<ApiKeyProps, 'name' | 'environments' | 'description'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateAppBundleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateAppBundleProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      appUploadId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      comment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateAppDefinitionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateAppDefinitionProps = SetOptional<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Except<AppDefinitionProps, 'sys' | 'bundle'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'src' | 'locations'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateAppDetailsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateAppDetailsProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * An Icon that represents the App
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          icon?: AppIcon;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateAppInstallationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateAppInstallationProps = Except<AppInstallationProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateAppSignedRequestProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateAppSignedRequestProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** the request method */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'PATCH' | 'HEAD';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** the path of the request method */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** optional stringified body of the request */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              body?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** optional headers of the request */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateAppSigningSecretProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateAppSigningSecretProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /** A 64 character matching the regular expression /^[0-9a-zA-Z+/=_-]+$/ */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAssetKeyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAssetKeyProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** (required) UNIX timestamp in the future (but not more than 48 hours from now) */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expiresAt: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateAssetProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateAssetProps = Omit<AssetProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateCommentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateCommentProps = Omit<CommentProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateContentTypeProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateContentTypeProps = SetOptional<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Except<ContentTypeProps, 'sys'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'description' | 'displayField'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateEntryProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateEntryProps<TFields = KeyValueMap> = Omit<EntryProps<TFields>, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateEnvironmentAliasProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateEnvironmentAliasProps = Omit<EnvironmentAliasProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateEnvironmentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateEnvironmentProps = Partial<Omit<EnvironmentProps, 'sys'>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateLocaleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateLocaleProps = Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetOptional<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Except<LocaleProps, 'sys'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'optional' | 'contentManagementApi' | 'default' | 'contentDeliveryApi'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'internal_code'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateOrganizationInvitationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateOrganizationInvitationProps = Omit<OrganizationInvitationProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreatePersonalAccessTokenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreatePersonalAccessTokenProps = Pick<PersonalAccessToken, 'name' | 'scopes'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateRoleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateRoleProps = Omit<RoleProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateSpaceMembershipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateSpaceMembershipProps = Omit<SpaceMembershipProps, 'sys' | 'user'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        email: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTagProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTagProps = Omit<TagProps, 'sys'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sys: Pick<TagSysProps, 'visibility'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateTaskProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateTaskProps = Omit<TaskProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateTeamMembershipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateTeamMembershipProps = Omit<TeamMembershipProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateTeamProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateTeamProps = Omit<TeamProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateTeamSpaceMembershipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateTeamSpaceMembershipProps = Omit<TeamSpaceMembershipProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateUIExtensionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateExtensionProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extension: RequireExactlyOne<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetRequired<ExtensionProps['extension'], 'name' | 'fieldTypes' | 'sidebar'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'src' | 'srcdoc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateWebhooksProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateWebhooksProps = SetOptional<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Except<WebhookProps, 'sys'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'headers' | 'active'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateWorkflowDefinitionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateWorkflowDefinitionProps = Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WorkflowDefinitionProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'sys' | 'steps'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        steps: CreateWorkflowStepProps[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateWorkflowProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateWorkflowProps = Omit<WorkflowProps, 'sys'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entity: Link<'Entry'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          workflowDefinition: Link<'WorkflowDefinition'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DefinedParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DefinedParameters = Record<string, string | number | boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EditorInterfaceProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EditorInterfaceProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sys: MetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              space: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sys: MetaLinkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              environment: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sys: MetaLinkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              contentType: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sys: MetaLinkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Array of fields and their associated widgetId
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              controls?: Control[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Array of field groups and their associated widgetId
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              groupControls?: GroupControl[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Array of editors. Defaults will be used if property is missing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editors?: Editor[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Legacy singular editor override
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor?: Editor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Array of editor layout field groups
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editorLayout?: FieldGroupItem[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Array of sidebar widgets. Defaults will be used if property is missing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sidebar?: SidebarItem[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EditorLayoutItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EditorLayoutItem = FieldItem | FieldGroupItem;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EntryProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EntryProps<T = KeyValueMap> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: EntityMetaSysProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metadata?: MetadataProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fields: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Environment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Environment = ContentfulEnvironmentAPI &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EnvironmentProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DefaultElements<EnvironmentProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnvironmentAliasProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnvironmentAliasProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * System meta data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      space: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      environment: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sys: MetaLinkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnvironmentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnvironmentProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: EnvironmentMetaSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Name of the environment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FieldType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FieldType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Symbol';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Text';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'RichText';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Integer';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Number';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Date';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Boolean';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Object';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Location';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkType: 'Asset';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkType: 'Entry';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Symbol';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkType: 'Entry';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkType: 'Asset';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FreeFormParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FreeFormParameters =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Array<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetAppBundleParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetAppBundleParams = GetAppDefinitionParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              appBundleId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetAppDefinitionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetAppDefinitionParams = GetOrganizationParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                appDefinitionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetAppInstallationParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetAppInstallationParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  appDefinitionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetAppUploadParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetAppUploadParams = GetOrganizationParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    appUploadId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetBulkActionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetBulkActionParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bulkActionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetCommentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetCommentParams = GetEntryParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        commentId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetContentTypeParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetContentTypeParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contentTypeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetEditorInterfaceParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetEditorInterfaceParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contentTypeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetEntryParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetEntryParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetExtensionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetExtensionParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extensionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetOrganizationMembershipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetOrganizationMembershipProps = GetOrganizationParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  organizationMembershipId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetOrganizationParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetOrganizationParams = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    organizationId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetReleaseParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetReleaseParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      releaseId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetSnapshotForContentTypeParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetSnapshotForContentTypeParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contentTypeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetSnapshotForEntryParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetSnapshotForEntryParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetSpaceEnvAliasParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetSpaceEnvAliasParams = GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            environmentAliasId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetSpaceEnvironmentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetSpaceEnvironmentParams = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              spaceId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              environmentId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetSpaceMembershipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetSpaceMembershipProps = GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                spaceMembershipId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetSpaceParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetSpaceParams = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  spaceId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetTagParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetTagParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tagId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetTaskParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetTaskParams = GetEntryParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      taskId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetTeamMembershipParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetTeamMembershipParams = GetTeamParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        teamMembershipId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetTeamParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetTeamParams = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          organizationId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          teamId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetTeamSpaceMembershipParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetTeamSpaceMembershipParams = GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            teamSpaceMembershipId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetWebhookCallDetailsUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetWebhookCallDetailsUrl = GetWebhookParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetWebhookParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetWebhookParams = GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                webhookDefinitionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetWorkflowDefinitionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetWorkflowDefinitionParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  workflowDefinitionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetWorkflowParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetWorkflowParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    workflowId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ISO8601Timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ISO8601Timestamp = string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • String will be in ISO8601 datetime format e.g. 2013-06-26T13:57:24Z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KeyValueMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KeyValueMap = Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LocaleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LocaleProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        space: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        environment: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Locale name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Locale code (example: en-us)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        code: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Internal locale code
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        internal_code: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Locale code to fallback to when there is not content for the current locale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fallbackCode: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * If the content under this locale should be available on the CDA (for public reading)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contentDeliveryApi: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * If the content under this locale should be available on the CMA (for editing)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contentManagementApi: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * If this is the default locale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        default: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * If the locale needs to be filled in on entries or not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MakeRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MakeRequest = MRInternal<false>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MakeRequestWithUserAgent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MakeRequestWithUserAgent = MRInternal<true>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MRActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MRActions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Http: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: AxiosRequestConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          patch: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: AxiosRequestConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          post: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: AxiosRequestConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          put: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: AxiosRequestConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: AxiosRequestConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          request: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          config?: AxiosRequestConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppBundle: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppBundleParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppBundleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<AppBundleProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppBundleParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAppBundleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppBundleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ApiKey: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          apiKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<ApiKeyProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          apiKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          apiKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: ApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          apiKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppDefinition: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          appDefinitionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppDefinitionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<AppDefinitionProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAppDefinitionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppDefinitionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: AppDefinitionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppDefinitionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppInstallation: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppInstallationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppInstallationProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & PaginationQueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<AppInstallationProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          upsert: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppInstallationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAppInstallationProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppInstallationProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppInstallationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppUpload: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppUploadParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppUploadProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppUploadParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          file: string | ArrayBuffer | Stream;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppUploadProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppDetails: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          upsert: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAppDetailsProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppDetailsProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppDetailsProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppSignedRequest: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppInstallationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAppSignedRequestProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppSignedRequestProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AppSigningSecret: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          upsert: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAppSigningSecretProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppSigningSecretProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AppSigningSecretProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetAppDefinitionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Asset: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<AssetProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          publish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unpublish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          archive: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unarchive: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assetId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createFromFiles: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: Omit<AssetFileProp, 'sys'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          processForAllLocales: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          asset: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: AssetProcessingForLocale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          processForLocale: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          asset: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          locale: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: AssetProcessingForLocale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AssetKey: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateAssetKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: AssetKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BulkAction: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetBulkActionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: BulkActionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          publish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: BulkActionPublishPayload;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: BulkActionProps<BulkActionPublishPayload>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unpublish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: BulkActionUnpublishPayload;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: BulkActionProps<BulkActionUnpublishPayload>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          validate: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: BulkActionValidatePayload;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: BulkActionProps<BulkActionValidatePayload>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Comment: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetCommentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CommentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getAll: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetEntryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<CommentProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: CreateCommentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateCommentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CommentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: UpdateCommentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: UpdateCommentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CommentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: DeleteCommentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ContentType: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetContentTypeParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<ContentTypeProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetContentTypeParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetContentTypeParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetContentTypeParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          publish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetContentTypeParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unpublish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetContentTypeParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ContentTypeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorInterface: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetEditorInterfaceParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EditorInterfaceProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<EditorInterfaceProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetEditorInterfaceParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: EditorInterfaceProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EditorInterfaceProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Environment: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & PaginationQueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<EnvironmentProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: Partial<Pick<EnvironmentProps, 'name'>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceEnvironmentId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateEnvironmentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: EnvironmentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EnvironmentAlias: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvAliasParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentAliasProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & PaginationQueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<EnvironmentAliasProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvAliasParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateEnvironmentAliasProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentAliasProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvAliasParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: EnvironmentAliasProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EnvironmentAliasProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvAliasParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Entry: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<EntryProps<any>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          patch: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: OpPatch[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          publish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unpublish: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          archive: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unarchive: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contentTypeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateEntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contentTypeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateEntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryProps<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          references: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entryId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @deprecated use `include` param instead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxDepth?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          include?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: EntryReferenceProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Extension: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetExtensionParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<ExtensionProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createWithId: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetExtensionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetExtensionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: ExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: ExtensionProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetExtensionParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Locale: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          localeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: LocaleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<LocaleProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          localeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          localeId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: LocaleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: LocaleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceEnvironmentParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateLocaleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: LocaleProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Organization: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: PaginationQueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<OrganizationProp>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: OrganizationProp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OrganizationInvitation: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          organizationId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          invitationId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: OrganizationInvitationProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          organizationId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreateOrganizationInvitationProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: OrganizationInvitationProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OrganizationMembership: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationMembershipProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: OrganizationMembershipProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<OrganizationMembershipProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationMembershipProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: OrganizationMembershipProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: OrganizationMembershipProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetOrganizationMembershipProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PersonalAccessToken: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tokenId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: PersonalAccessTokenProp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<PersonalAccessTokenProp>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {};
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payload: CreatePersonalAccessTokenProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: PersonalAccessTokenProp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          revoke: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tokenId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: PersonalAccessTokenProp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PreviewApiKey: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          previewApiKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: PreviewApiKeyProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getMany: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetSpaceParams & QueryParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return: CollectionProp<PreviewApiKeyProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Release: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: GetReleaseParams;