contentful-management

  • Version 11.24.5
  • Published
  • 7.53 MB
  • 7 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

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ReleaseReferenceFilters

const ReleaseReferenceFilters: typeof ScheduledActionReferenceFilters;

    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;
      (
      params: any,
      opts: { type?: 'plain'; alphaFeatures: string[]; defaults?: DefaultParams }
      ):
      | {
      getEnvironmentTemplates: (
      organizationId: string,
      query?: BasicCursorPaginationOptions & { select?: string }
      ) => Promise<
      CursorPaginatedCollection<
      EnvironmentTemplate,
      EnvironmentTemplateProps
      >
      >;
      getEnvironmentTemplate: ({
      organizationId,
      environmentTemplateId,
      version,
      query,
      }: GetOrganizationParams & { environmentTemplateId: string } & {
      version?: number;
      query?: { select?: string };
      }) => Promise<EnvironmentTemplate>;
      createEnvironmentTemplate: (
      organizationId: string,
      environmentTemplateData: CreateEnvironmentTemplateProps
      ) => Promise<EnvironmentTemplate>;
      getSpaces: (
      query?: QueryOptions
      ) => Promise<Collection<Space, SpaceProps>>;
      getSpace: (spaceId: string) => Promise<Space>;
      createSpace: (
      spaceData: CreateSpaceProps,
      organizationId: string
      ) => Promise<Space>;
      getOrganization: (id: string) => Promise<Organization>;
      getOrganizations: (
      query?: PaginationQueryOptions
      ) => Promise<Collection<Organization, OrganizationProp>>;
      getCurrentUser: <T = UserProps>(params?: QueryParams) => Promise<T>;
      getAppDefinition: (
      params: GetAppDefinitionParams
      ) => Promise<AppDefinition>;
      createPersonalAccessToken: (
      data: CreatePersonalAccessTokenProps
      ) => Promise<PersonalAccessToken>;
      getPersonalAccessToken: (
      tokenId: string
      ) => Promise<PersonalAccessToken>;
      getPersonalAccessTokens: () => Promise<
      Collection<PersonalAccessToken, PersonalAccessTokenProp>
      >;
      getAccessToken: (tokenId: string) => Promise<AccessToken>;
      getAccessTokens: () => Promise<
      Collection<AccessToken, AccessTokenProp>
      >;
      getOrganizationAccessTokens: (
      organizationId: string,
      query?: QueryOptions
      ) => Promise<Collection<AccessToken, AccessTokenProp>>;
      getOrganizationUsage: (
      organizationId: string,
      query?: QueryOptions
      ) => Promise<Collection<Usage, UsageProps>>;
      getSpaceUsage: (
      organizationId: string,
      query?: UsageQuery
      ) => Promise<Collection<Usage, UsageProps>>;
      rawRequest: ({ url, ...config }: any) => Promise<any>;
      }
      | PlainClientAPI;
      };
      • Create a client instance

        Parameter params

        Client initialization parameters

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

        The alphaFeatures option is no longer supported. Please use the function without this option.

      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 AccessToken

                  interface AccessToken extends AccessTokenProp, DefaultElements<AccessTokenProp> {}

                    method revoke

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

                      Example 1

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

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

                      client.getAccessToken('') .then((AccessToken) => { return accessToken.revoke() }) .catch(console.error) ```

                    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 AppAccessToken

                          interface AppAccessToken
                          extends AppAccessTokenProps,
                          DefaultElements<AppAccessTokenProps> {}

                            interface AppActionCall

                            interface AppActionCall
                            extends AppActionCallProps,
                            DefaultElements<AppActionCallProps> {}

                              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 AppEventSubscription

                                  interface AppEventSubscription
                                  extends AppEventSubscriptionProps,
                                  DefaultElements<AppEventSubscriptionProps> {}

                                    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.getAppEventSubscription()) .then((eventSubscription) => eventSubscription.delete()) .then(() => console.log('eventSubscription 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 AppKey

                                            interface AppKey extends AppKeyProps, DefaultElements<AppKeyProps> {}

                                              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.getAppKey()) .then((signingSecret) => signingSecret.delete()) .then(() => console.log('signingSecret deleted')) .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 extends Omit<BasicQueryOptions, 'skip'> {}

                                                                      property pageNext

                                                                      pageNext?: string;

                                                                        property pagePrev

                                                                        pagePrev?: 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 allowedResources

                                                                                                                                        allowedResources?: ContentTypeAllowedResources[];

                                                                                                                                          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 ContentfulEntryResource

                                                                                                                                                              interface ContentfulEntryResource {}

                                                                                                                                                                property contentTypes

                                                                                                                                                                contentTypes: string[];

                                                                                                                                                                  property source

                                                                                                                                                                  source: string;

                                                                                                                                                                    property type

                                                                                                                                                                    type: 'Contentful:Entry';

                                                                                                                                                                      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?: (`${BLOCKS}` | `${INLINES}`)[];

                                                                                                                                                                                    property in

                                                                                                                                                                                    in?: (string | number)[];

                                                                                                                                                                                      property linkContentType

                                                                                                                                                                                      linkContentType?: string[];

                                                                                                                                                                                        property linkMimetypeGroup

                                                                                                                                                                                        linkMimetypeGroup?: string[];

                                                                                                                                                                                          property message

                                                                                                                                                                                          message?: string | null;

                                                                                                                                                                                            property nodes

                                                                                                                                                                                            nodes?: NodesValidation;

                                                                                                                                                                                              property prohibitRegexp

                                                                                                                                                                                              prohibitRegexp?: RegExp;

                                                                                                                                                                                                property range

                                                                                                                                                                                                range?: NumRange;

                                                                                                                                                                                                  property regexp

                                                                                                                                                                                                  regexp?: RegExp;

                                                                                                                                                                                                    property size

                                                                                                                                                                                                    size?: NumRange;

                                                                                                                                                                                                      property unique

                                                                                                                                                                                                      unique?: boolean;

                                                                                                                                                                                                        interface ContentTypeTemplateProps

                                                                                                                                                                                                        interface ContentTypeTemplateProps extends Omit<ContentTypeProps, 'sys'> {}

                                                                                                                                                                                                          property basedOn

                                                                                                                                                                                                          basedOn?: {
                                                                                                                                                                                                          space: Link<'Space'>;
                                                                                                                                                                                                          environment: Link<'Environment'>;
                                                                                                                                                                                                          contentType: Link<'ContentType'>;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            property hints

                                                                                                                                                                                                            hints?: Array<Hint>;

                                                                                                                                                                                                              property id

                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                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?: {
                                                                                                                                                                                                                      next?: string;
                                                                                                                                                                                                                      prev?: string;
                                                                                                                                                                                                                      };

                                                                                                                                                                                                                        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 EditorInterfaceTemplateProps

                                                                                                                                                                                                                                interface EditorInterfaceTemplateProps extends Omit<EditorInterfaceProps, 'sys'> {}

                                                                                                                                                                                                                                  property contentTypeTemplate

                                                                                                                                                                                                                                  contentTypeTemplate: Link<'ContentTypeTemplate'>;

                                                                                                                                                                                                                                    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 EntryMetaSysProps

                                                                                                                                                                                                                                                              interface EntryMetaSysProps extends EntityMetaSysProps {}

                                                                                                                                                                                                                                                                property automationTags

                                                                                                                                                                                                                                                                automationTags: Link<'Tag'>[];

                                                                                                                                                                                                                                                                  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 ExternalResource

                                                                                                                                                                                                                                                                    interface ExternalResource {}

                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                        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?: RawAxiosRequestHeaders;

                                                                                                                                                                                                                                                                                                  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 'sys.release.sys.id[in]'

                                                                                                                                                                                                                                                                                                                                                                                                                    'sys.release.sys.id[in]'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property 'sys.status[in]'

                                                                                                                                                                                                                                                                                                                                                                                                                      'sys.status[in]'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property 'sys.status[nin]'

                                                                                                                                                                                                                                                                                                                                                                                                                        'sys.status[nin]'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property action

                                                                                                                                                                                                                                                                                                                                                                                                                          action?: ReleaseActionTypes;

                                                                                                                                                                                                                                                                                                                                                                                                                            property limit

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

                                                                                                                                                                                                                                                                                                                                                                                                                            property order

                                                                                                                                                                                                                                                                                                                                                                                                                            order?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            • -sys.updatedAt

                                                                                                                                                                                                                                                                                                                                                                                                                            property uniqueBy

                                                                                                                                                                                                                                                                                                                                                                                                                            uniqueBy?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Get unique results by this field. Currently supports sys.release.sys.id

                                                                                                                                                                                                                                                                                                                                                                                                                            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 metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                    metadata?: ReleaseMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                      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 'entities[exists]'

                                                                                                                                                                                                                                                                                                                                                                                                                                            'entities[exists]'?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Filter by empty Releases (exists=false) or Releases with items (exists=true)

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            'sys.createdBy.sys.id[in]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comma-separated list of user Ids to find releases by creator

                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'sys.id[in]'

                                                                                                                                                                                                                                                                                                                                                                                                                                            'sys.id[in]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comma-separated list of Ids to find (inclusion)

                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'sys.id[nin]'

                                                                                                                                                                                                                                                                                                                                                                                                                                            'sys.id[nin]'?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comma-separated list of ids to exclude from the query

                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'sys.status[in]'

                                                                                                                                                                                                                                                                                                                                                                                                                                            'sys.status[in]'?: ReleaseStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comma-separated filter (inclusion) by Release status (active, archived)

                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'sys.status[nin]'

                                                                                                                                                                                                                                                                                                                                                                                                                                            'sys.status[nin]'?: ReleaseStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comma-separated filter (exclusion) by Release status (active, archived)

                                                                                                                                                                                                                                                                                                                                                                                                                                            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 Supported values include - title, -title - sys.updatedAt, -sys.updatedAt - sys.createdAt, -sys.createdAt -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 ResourceLink<T extends string> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ResourceLink is a reference object to another entity outside of the current space/environment

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sys

                                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'ResourceLink';
                                                                                                                                                                                                                                                                                                                                                                                                                                                  linkType: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  urn: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RichTextCommentDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RichTextCommentDocument extends Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                      content: RootParagraph[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property nodeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                        nodeType: CommentNode.Document;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 SpaceQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpaceQueryOptions extends PaginationQueryOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property spaceId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spaceId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 UIConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UIConfig extends UIConfigProps, DefaultElements<UIConfigProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 UserUIConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UserUIConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extends UserUIConfigProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DefaultElements<UserUIConfigProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WorkflowsChangelogEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WorkflowsChangelogEntry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extends WorkflowsChangelogEntryProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DefaultElements<WorkflowsChangelogEntryProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WorkflowStepPermission

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WorkflowStepPermission {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      configuration: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      actors: WorkflowStepPermissionActors;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      action: WorkflowStepPermissionAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      effect: WorkflowStepPermissionEffect;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: WorkflowStepPermissionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 ScheduledActionReferenceFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enum ScheduledActionReferenceFilters {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contentTypeAnnotationNotIn = 'sys.contentType.metadata.annotations.ContentType[nin]',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member contentTypeAnnotationNotIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contentTypeAnnotationNotIn = 'sys.contentType.metadata.annotations.ContentType[nin]'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum WorkflowStepActionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum WorkflowStepActionType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              App = 'app',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Email = 'email',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Task = 'task',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member App

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                App = 'app'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Email = 'email'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Task

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Task = 'task'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum WorkflowStepPermissionAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum WorkflowStepPermissionAction {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Edit = 'edit',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Publish = 'publish',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Edit = 'edit'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Publish = 'publish'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum WorkflowStepPermissionEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum WorkflowStepPermissionEffect {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Allow = 'allow',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deny = 'deny',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Allow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Allow = 'allow'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Deny

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deny = 'deny'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum WorkflowStepPermissionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum WorkflowStepPermissionType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  EntityPermission = 'entity_permission',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WorkflowPermission = 'workflow_permission',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member EntityPermission

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    EntityPermission = 'entity_permission'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member WorkflowPermission

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WorkflowPermission = 'workflow_permission'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AccessTokenProp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AccessTokenProp = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: AccessTokenSysProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scopes: 'content_management_manage'[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        revokedAt: null | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        token?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AnnotationAssignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AnnotationAssignment = Link<'Annotation'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parameters?: Record<string, string | number | boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 AppAccessTokenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AppAccessTokenProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sys: AppAccessTokenSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Token for an app installation in a space environment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              token: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AppAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AppAction = AppActionProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DefaultElements<AppActionProps> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Deletes this object on the server.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @example ```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.getAppAction('<app-action-id>'))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * .then((appAction) => appAction.delete())
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * .catch(console.error)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                delete(): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AppActionCallProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AppActionCallProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: AppActionCallSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppActionCategoryProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppActionCategoryProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: AppActionCategoryType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'AppActionCategory';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    version: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parameters?: AppActionParameterDefinition[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AppActionCategoryType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AppActionCategoryType = AppActionCategory['category'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AppActionParameterDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AppActionParameterDefinition = Omit<ParameterDefinition, 'labels'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AppActionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AppActionProps = AppActionCategory & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sys: AppActionSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Url that will be called when the action is invoked
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Human readable name for the action
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Human readable description of the action
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: 'endpoint' | 'function';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  installation?: ParameterDefinition[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AppDetailsProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AppEventSubscriptionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AppEventSubscriptionProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sys: AppEventSubscriptionSys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /** Subscription url that will receive events */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      targetUrl: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /** List of topics to subscribe to */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      topics: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AppInstallationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AppInstallationProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: Omit<BasicMetaSysProps, 'id'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        appDefinition: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        environment: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        space: SysLink;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Free-form installation parameters (API limits stringified length to 32KB)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parameters?: FreeFormParameters;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AppKeyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AppKeyProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * System metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sys: AppKeySys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * JSON Web Key
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          jwk: JWK;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * If generated, private key is returned
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generated?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Base64 PEM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          privateKey: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              status: CommentStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ContentTypeMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ContentTypeMetadata = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                annotations?: RequireAtLeastOne<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ContentType?: AnnotationAssignment[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ContentTypeField?: Record<string, AnnotationAssignment[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'ContentType' | 'ContentTypeField'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metadata?: ContentTypeMetadata;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateApiKeyProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateAppAccessTokenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateAppAccessTokenProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * JSON Web Token
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      jwt: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateAppActionCallProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateAppActionCallProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** The body for the call */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parameters: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateAppActionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateAppActionProps = AppActionCategory & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateAppBundleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateAppBundleProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            appUploadId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            comment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            actions?: ActionManifestProps[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            functions?: FunctionManifestProps[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateAppDefinitionProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateAppDetailsProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAppEventSubscriptionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAppEventSubscriptionProps = Except<AppEventSubscriptionProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateAppInstallationProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateAppKeyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateAppKeyProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Toggle for automatic private key generation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generate?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * JSON Web Key, required if generate is falsy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      jwk?: JWK;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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' | 'status'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                status?: CommentStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 CreateEnvironmentTemplateInstallationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateEnvironmentTemplateInstallationProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          takeover?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          items: Link<'ContentType'>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          changeSet?: Link<'ChangeSet'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateEnvironmentTemplateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateEnvironmentTemplateProps = Omit<EnvironmentTemplateProps, 'sys'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateLocaleProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateOrganizationInvitationProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreatePATProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreatePersonalAccessTokenProps = Pick<AccessToken, 'name' | 'scopes'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expiresIn: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreatePersonalAccessTokenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreatePersonalAccessTokenProps = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PersonalAccessToken,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name' | 'scopes'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expiresIn?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 CreateWithResponseParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateWithResponseParams = GetAppActionCallParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        retries?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        retryInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateWorkflowDefinitionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateWorkflowDefinitionParams = GetSpaceEnvironmentParams;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateWorkflowDefinitionProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateWorkflowProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateWorkflowStepProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreateWorkflowStepProps = Omit<WorkflowStepProps, 'id'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DefinedParameters

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteCommentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteCommentParams = GetCommentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteWorkflowDefinitionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteWorkflowDefinitionParams = GetWorkflowDefinitionParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DeleteWorkflowParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DeleteWorkflowParams = GetWorkflowParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: EntryMetaSysProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 EnvironmentTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EnvironmentTemplate = EnvironmentTemplateProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DefaultElements<EnvironmentTemplateProps> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ContentfulEnvironmentTemplateApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnvironmentTemplateInstallation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EnvironmentTemplateInstallation = EnvironmentTemplateInstallationProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DefaultElements<EnvironmentTemplateInstallationProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnvironmentTemplateInstallationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EnvironmentTemplateInstallationProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'EnvironmentTemplateInstallation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          space: Link<'Space'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          template: VersionedLink<'Template'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          status: EnvironmentTemplateInstallationStatus;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createdAt: ISO8601Timestamp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updatedAt: ISO8601Timestamp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createdBy: Link<'User' | 'AppDefinition'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updatedBy: Link<'User' | 'AppDefinition'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          completedAt?: ISO8601Timestamp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          errors?: JsonArray;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          environment: Link<'Environment'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EnvironmentTemplateInstallationStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EnvironmentTemplateInstallationStatus =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyof typeof EnvironmentTemplateInstallationStatuses;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EnvironmentTemplateParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EnvironmentTemplateParams = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              spaceId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              environmentId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              environmentTemplateId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnvironmentTemplateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnvironmentTemplateProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sys: BasicMetaSysProps & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                organization: Link<'Organization'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                versionName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                versionDescription?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                entities: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                contentTypeTemplates: Array<ContentTypeTemplateProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                editorInterfaceTemplates: Array<EditorInterfaceTemplateProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnvironmentTemplateValidationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnvironmentTemplateValidationProps<T = ValidationFinding> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  environment: Link<'Environment'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  space: Link<'Space'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  changeSet: Link<'ChangeSet'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  items: T[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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: 'ResourceLink';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    linkType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Symbol';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    linkType: 'Entry';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Resourcelink';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    linkType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Array';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    items: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Link';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    linkType: 'Asset';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FreeFormParameters

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionProps = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'Function';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createdBy: Link<'User'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createdAt: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updatedBy: Link<'User'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updatedAt: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        organization: Link<'Organization'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        appDefinition: Link<'AppDefinition'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        description: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        accepts: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allowNetworks?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetAppActionCallDetailsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetAppActionCallDetailsParams = GetSpaceEnvironmentParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          appActionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetAppActionCallParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetAppActionCallParams = GetAppInstallationParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            appActionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetAppActionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetAppActionParams = GetAppDefinitionParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              appActionId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetAppActionsForEnvParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetAppActionsForEnvParams = GetSpaceParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                environmentId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetAppBundleParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetAppDefinitionParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetAppInstallationParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetAppInstallationsForOrgParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetAppKeyParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetAppKeyParams = GetAppDefinitionParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fingerprint: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetAppUploadParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetBulkActionParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetCommentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetCommentParams = (GetEntryParams | GetCommentParentEntityParams) & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                commentId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetCommentParentEntityParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetCommentParentEntityParams = GetSpaceEnvironmentParams &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityType: 'ContentType';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityReference?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityType: 'Entry';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityReference?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityType: 'Workflow';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentEntityVersion?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetContentTypeParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetEditorInterfaceParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetEntryParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetEnvironmentTemplateParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetEnvironmentTemplateParams = GetOrganizationParams & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          environmentTemplateId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetExtensionParams