contentful-management

contentful-management

Version 11.57.3
Published 11 hours ago
8.27 MB
5 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

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, OrganizationProps>>;
              getCurrentUser: <T = UserProps>(params?: QueryParams) => Promise<T>;
              getOAuthApplication: (
                  params: GetOAuthApplicationParams
              ) => Promise<OAuthApplicationProps>;
              getOAuthApplications: (
                  params: GetUserParams & QueryParams
              ) => Promise<
                  CursorPaginatedCollection<OAuthApplication, OAuthApplicationProps>
              >;
              createOAuthApplication: (
                  params: GetUserParams,
                  rawData: CreateOAuthApplicationProps
              ) => Promise<OAuthApplicationProps>;
              getAppDefinition: (
                  params: GetAppDefinitionParams
              ) => Promise<AppDefinition>;
              createPersonalAccessToken: (
                  data: CreatePersonalAccessTokenProps
              ) => Promise<PersonalAccessToken>;
              getPersonalAccessToken: (
                  tokenId: string
              ) => Promise<PersonalAccessToken>;
              getPersonalAccessTokens: () => Promise<
                  Collection<PersonalAccessToken, PersonalAccessTokenProps>
              >;
              getAccessToken: (tokenId: string) => Promise<AccessToken>;
              getAccessTokens: () => Promise<
                  Collection<AccessToken, AccessTokenProps>
              >;
              getOrganizationAccessTokens: (
                  organizationId: string,
                  query?: QueryOptions
              ) => Promise<Collection<AccessToken, AccessTokenProps>>;
              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 fetchAll

fetchAll: <
    Params extends ExpectedParams,
    Entity,
    F extends FetchFn<Params, Entity>
>(
    fetchFn: FetchFn<Params, Entity>,
    params: ParamsType<Params, F>
) => Promise<Entity[]>;

Parameters for endpoint methods that can be paginated are inconsistent, fetchAll will only work with the more common version of supplying the limit, skip, and pageNext parameters via a distinct query property in the parameters.

function isDraft

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

function isPublished

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

function isUpdated

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

function makeRequest

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

Classes

class RestAdapter

class RestAdapter implements Adapter {}

constructor

constructor(params: any);

method makeRequest

makeRequest: <R>(opts: MakeRequestOptions) => Promise<R>;

Interfaces

interface AcceptsQueryOptions

interface AcceptsQueryOptions {}

property 'accepts[all]'

'accepts[all]'?: string;

interface AccessToken

interface AccessToken extends AccessTokenProps, DefaultElements<AccessTokenProps> {}

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 AiAction

interface AiAction extends AiActionProps, DefaultElements<AiActionProps> {}

method delete

delete: () => Promise<void>;

method invoke

invoke: (
    environmentId: string,
    payload: AiActionInvocationType
) => Promise<AiActionInvocation>;

method publish

publish: () => Promise<AiAction>;

method unpublish

unpublish: () => Promise<AiAction>;

method update

update: () => Promise<AiAction>;

interface AiActionInvocation

interface AiActionInvocation
    extends AiActionInvocationProps,
        DefaultElements<AiActionInvocationProps> {}

The AI Action Invocation entity. This entity is read-only and primarily used to inspect the result of an AI action invocation.

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 AppActionCallErrorProps

interface AppActionCallErrorProps {}

property details

details?: Record<string, unknown>;

property message

message: string;

property statusCode

statusCode?: number;

property sys

sys: {
    type: 'Error';
    id: string;
};

interface AppActionCallRawResponseProps

interface AppActionCallRawResponseProps {}

property response

response: {
    headers?: {
        contentType?: string;
    };
    body: string;
};

property sys

sys: {
    id: string;
    type: 'AppActionCallResponse';
    space: SysLink;
    environment: SysLink;
    appInstallation: SysLink;
    appAction: SysLink;
    createdAt: string;
};

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

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;

Deprecated
contentType only exists on entries. Please refactor to use a type guard to get the correct EntryMetaSysProps type with this property.

property environment

environment: SysLink;

property fieldStatus

fieldStatus?: {
    '*': Record<string, 'draft' | 'changed' | 'published'>;
};

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;

property status

status?: 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'>[];

property contentType

contentType: SysLink;

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

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 concepts

concepts?: Link<'TaxonomyConcept'>[];

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;

Deprecated
status only exists on entities. Please refactor to use a type guard to get the correct EntityMetaSysProps type with this property.

interface NavigationItem

interface NavigationItem {}

property name

name: string;

property path

path: string;

interface OAuthApplication

interface OAuthApplication
    extends OAuthApplicationProps,
        DefaultElements<OAuthApplicationProps> {}

method delete

delete: () => Promise<void>;

Deletes an OAuth application Promise for the deleted OAuth application

method update

update: () => Promise<OAuthApplicationProps>;

Updates an OAuth application Promise for the updated OAuth application

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<T = ParameterType> {}

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: T;

interface PersonalAccessToken

interface PersonalAccessToken
    extends PersonalAccessTokenProps,
        DefaultElements<PersonalAccessTokenProps> {}

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

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 ResourceProvider

interface ResourceProvider
    extends ResourceProviderProps,
        DefaultElements<ResourceProviderProps> {}

method delete

delete: () => Promise<void>;

method getResourceType

getResourceType: (id: string) => Promise<ResourceType>;

method getResourceTypes

getResourceTypes: () => Promise<CollectionProp<ResourceType>>;

method upsert

upsert: () => Promise<ResourceProvider>;

method upsertResourceType

upsertResourceType: (
    id: string,
    data: UpsertResourceTypeProps
) => Promise<ResourceType>;

interface ResourceType

interface ResourceType
    extends ResourceTypeProps,
        DefaultElements<ResourceTypeProps> {}

method delete

delete: () => Promise<void>;

method upsert

upsert: () => Promise<ResourceType>;

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

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 UploadCredential

interface UploadCredential
    extends UploadCredentialProps,
        DefaultElements<UploadCredentialProps> {}

method create

create: () => Promise<UploadCredentialProps>;

creates the upload credentials. upload credentials for file uploads
Example 1
const contentful = require('contentful-management')
const client = contentful.createClient({ accessToken: '<content_management_api_key>' })
try { const space = await client.getSpace('<space_id>') const environment = await space.getEnvironment('<environment_id>')
const upload = await client.uploadCredential.create({ spaceId: space.sys.id, environmentId: environment.sys.id }) } catch (error) { console.error(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

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',
    Delete = 'delete',
}

member Delete

Delete = 'delete'

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 AcceptsQueryParams

type AcceptsQueryParams = {
    query?: AcceptsQueryOptions;
};

type AccessTokenProp

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

type AiActionInvocationProps

type AiActionInvocationProps = {
    sys: {
        id: string;
        type: 'AiActionInvocation';
        space: SysLink;
        environment: SysLink;
        aiAction: SysLink;
        status: InvocationStatus;
        errorCode?: string;
    };
    result?: InvocationResult;
};

type AiActionProps

type AiActionProps = {
    sys: MetaSysProps & {
        type: 'AiAction';
        space: {
            sys: {
                id: string;
            };
        };
        publishedBy?: Link<'User'> | Link<'AppDefinition'>;
        updatedBy: Link<'User'> | Link<'AppDefinition'>;
        createdBy: Link<'User'> | Link<'AppDefinition'>;
        publishedVersion?: number;
        version: number;
        publishedAt?: string;
        updatedAt: string;
        createdAt: string;
        id: string;
    };
    name: string;
    description: string;
    configuration: Configuration;
    instruction: Instruction;
    testCases?: Array<AiActionTestCase>;
};

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;
    /** The execution status of the app action call, if available */
    status?: AppActionCallStatus;
    /** Structured result when execution succeeded */
    result?: unknown;
    /** Structured error when execution failed */
    error?: AppActionCallErrorProps;
};

type AppActionCallRetryOptions

type AppActionCallRetryOptions = {
    retries?: number;
    retryInterval?: number;
};

type AppActionCallStatus

type AppActionCallStatus = 'processing' | 'succeeded' | 'failed';

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 = BaseAppActionProps &
    (EndpointAppActionProps | FunctionAppActionProps | LegacyFunctionAppActionProps);

type AppActionType

type AppActionType = 'endpoint' | 'function' | 'function-invocation';

'function' is deprecated, use 'function-invocation' instead

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;
    /**
     * List of all functions in the bundle
     */
    functions?: FunctionManifestProps[];
};

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<InstallationParameterType>[];
    };
};

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[];
    /** Optional filter, transformation, or handler function */
    functions?: {
        filter?: Link<'Function'>;
        transformation?: Link<'Function'>;
        handler?: Link<'Function'>;
    };
};

type AppInstallationProps

type AppInstallationProps = {
    sys: Omit<BasicMetaSysProps, 'id'> & {
        appDefinition: SysLink;
        environment: SysLink;
        space: SysLink;
        organization: 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 ClientOptions

type ClientOptions = UserAgentParams & XOR<RestAdapterParams, AdapterParams>;

type ClientParams

type ClientParams = RestAdapterParams & UserAgentParams;

Deprecated

type CommentProps

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

type ConceptProps

type ConceptProps<Locales extends string = string> = LocalizedEntity<
    Omit<Concept, 'conceptSchemes'>,
    | 'prefLabel'
    | 'altLabels'
    | 'hiddenLabels'
    | 'definition'
    | 'historyNote'
    | 'editorialNote'
    | 'example'
    | 'note'
    | 'scopeNote',
    Locales
>;

type ConceptSchemeProps

type ConceptSchemeProps<Locales extends string = string> = LocalizedEntity<
    ConceptScheme,
    'prefLabel' | 'definition',
    Locales
>;

type ContentTypeMetadata

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

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 CreateAiActionProps

type CreateAiActionProps = Pick<
    Omit<AiActionProps, 'sys'>,
    'name' | 'description' | 'configuration' | 'instruction' | 'testCases'
>;

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]: unknown;
    };
};

type CreateAppActionProps

type CreateAppActionProps = AppActionCategory & {
    name: string;
    description?: string;
    /**
     * Optional JSON Schema describing the request payload shape
     */
    parametersSchema?: Record<string, unknown>;
    /**
     * Optional JSON Schema describing the result shape
     */
    resultSchema?: Record<string, unknown>;
} & (
        | CreateEndpointAppActionProps
        | CreateFunctionAppActionProps
        | LegacyFunctionAppActionProps
    );

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 CreateConceptProps

type CreateConceptProps = Partial<Omit<ConceptProps, 'sys'>> &
    Pick<ConceptProps, 'prefLabel'>;

type CreateConceptSchemeProps

type CreateConceptSchemeProps = Partial<Omit<ConceptSchemeProps, 'sys'>> &
    Pick<ConceptSchemeProps, 'prefLabel'>;

type CreateContentTypeProps

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

type CreatedAtIntervalParams

type CreatedAtIntervalParams = {
    query?: CreatedAtIntervalQueryOptions;
};

type CreatedAtIntervalQueryOptions

type CreatedAtIntervalQueryOptions = IntervalQuery<'sys.createdAt'>;

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 CreateOAuthApplicationProps

type CreateOAuthApplicationProps = {
    name: string;
    description: string;
    redirectUri: string;
    scopes: ScopeValues[];
    confidential: boolean;
};

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 & AppActionCallRetryOptions;

type CreateWithResultParams

type CreateWithResultParams = GetAppActionCallParams & AppActionCallRetryOptions;

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 CursorBasedParams

type CursorBasedParams = CursorPaginationXORParams;

type CursorPaginationXORParams

type CursorPaginationXORParams = {
    query?: (
        | CursorPaginationPageNext
        | CursorPaginationPagePrev
        | CursorPaginationNone
    ) & {
        limit?: number;
    };
};

type DefinedParameters

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

type DeleteCommentParams

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

type DeleteConceptParams

type DeleteConceptParams = GetOrganizationParams & {
    conceptId: string;
    version: number;
};

type DeleteConceptSchemeParams

type DeleteConceptSchemeParams = GetOrganizationParams & {
    conceptSchemeId: string;
    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>;
    };
    forTemplatedSpaces?: boolean;
};

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 GetAppActionCallParamsWithId

type GetAppActionCallParamsWithId = GetAppActionCallParams & {
    callId: 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 GetConceptDescendantsParams

type GetConceptDescendantsParams = GetOrganizationParams & {
    conceptId: string;
} & {
    query?: {
        depth?: number;
        pageUrl?: string;
    };
};

type GetConceptParams

type GetConceptParams = GetOrganizationParams & {
    conceptId: string;
};

type GetConceptSchemeParams

type GetConceptSchemeParams = GetOrganizationParams & {
    conceptSchemeId: string;
};

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

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

type GetFunctionForEnvParams

type GetFunctionForEnvParams = AcceptsQueryParams &
    GetSpaceEnvironmentParams & {
        appInstallationId: string;
    };

type GetFunctionLogParams

type GetFunctionLogParams = GetManyFunctionLogParams & {
    logId: string;
};

type GetFunctionParams

type GetFunctionParams = GetAppDefinitionParams & {
    functionId: string;
};

type GetManyCommentsParams

type GetManyCommentsParams = (GetEntryParams | GetCommentParentEntityParams) & {
    status?: CommentStatus;
};

type GetManyConceptParams

type GetManyConceptParams = GetOrganizationParams & {
    query?:
        | {
              pageUrl?: string;
          }
        | ({
              conceptScheme?: string;
              query?: string;
          } & BasicCursorPaginationOptions &
              Omit<PaginationQueryOptions, 'skip'>);
};

type GetManyConceptSchemeParams

type GetManyConceptSchemeParams = GetOrganizationParams & {
    query?:
        | {
              pageUrl?: string;
          }
        | ({
              query?: string;
          } & BasicCursorPaginationOptions &
              Omit<PaginationQueryOptions, 'skip'>);
};

type GetManyFunctionLogParams

type GetManyFunctionLogParams = CursorBasedParams &
    CreatedAtIntervalParams &
    GetFunctionForEnvParams & {
        functionId: string;
    };

type GetManyFunctionParams

type GetManyFunctionParams = AcceptsQueryParams & GetAppDefinitionParams;

type GetOAuthApplicationParams

type GetOAuthApplicationParams = {
    userId: string;
    oauthApplicationId: string;
};

type GetOrganizationMembershipParams

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

type GetOrganizationParams

type GetOrganizationParams = {
    organizationId: string;
};

type GetReleaseParams

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

type GetResourceParams

type GetResourceParams = GetSpaceEnvironmentParams & {
    resourceTypeId: string;
};

type GetResourceProviderParams

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

type GetResourceTypeParams

type GetResourceTypeParams = GetResourceProviderParams & {
    resourceTypeId: string;
};

type GetSnapshotForContentTypeParams

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

type GetSnapshotForEntryParams

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

type GetSpaceEnvAliasParams

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

type GetSpaceEnvironmentParams

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

type GetSpaceEnvironmentUploadParams

type GetSpaceEnvironmentUploadParams = GetSpaceEnvironmentParams & {
    uploadId: string;
};

type GetSpaceMembershipProps

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

type GetSpaceParams

type GetSpaceParams = {
    spaceId: string;
};

type GetTagParams

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

type GetTaskParams

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

type GetTeamMembershipParams

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

type GetTeamParams

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

type GetTeamSpaceMembershipParams

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

type GetUIConfigParams

type GetUIConfigParams = GetSpaceEnvironmentParams;

type GetUserParams

type GetUserParams = {
    userId: string;
};

type GetUserUIConfigParams

type GetUserUIConfigParams = GetUIConfigParams;

type GetWebhookCallDetailsUrl

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

type GetWebhookParams

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

type GetWorkflowDefinitionParams

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

type GetWorkflowParams

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

type Hint

type Hint = {
    operation: 'renameFieldId';
    fieldId: string;
    previousFieldId: string;
};

type IconType

type IconType = 'base64';

type InstallationParameterType

type InstallationParameterType = ParameterType | 'Secret';

type ISO8601Timestamp

type ISO8601Timestamp = string;

String will be in ISO8601 datetime format e.g. 2013-06-26T13:57:24Z

type KeyValueMap

type KeyValueMap = Record<string, any>;

type LocaleProps

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

type MakeRequest

type MakeRequest = MRInternal<false>;

type MakeRequestWithUserAgent

type MakeRequestWithUserAgent = MRInternal<true>;

type MRActions

type MRActions = {
    Resource: {
        getMany: {
            params: GetResourceParams & {
                query?: ResourceQueryOptions;
            };
            headers?: RawAxiosRequestHeaders;
            return: CursorPaginatedCollectionProp<ResourceProps>;
        };
    };
    ResourceProvider: {
        get: {
            params: GetResourceProviderParams;
            return: ResourceProviderProps;
        };
        upsert: {
            params: GetResourceProviderParams;
            payload: UpsertResourceProviderProps;
            headers?: RawAxiosRequestHeaders;
            return: ResourceProviderProps;
        };
        delete: {
            params: GetResourceProviderParams;
            return: any;
        };
    };
    ResourceType: {
        get: {
            params: GetResourceTypeParams;
            return: ResourceTypeProps;
        };
        getMany: {
            params: Omit<GetResourceTypeParams, 'resourceTypeId'>;
            return: CollectionProp<ResourceTypeProps>;
        };
        upsert: {
            params: GetResourceTypeParams;
            payload: UpsertResourceTypeProps;
            headers?: RawAxiosRequestHeaders;
            return: ResourceTypeProps;
        };
        delete: {
            params: GetResourceTypeParams;
            return: any;
        };
        getForEnvironment: {
            params: GetSpaceEnvironmentParams & {
                query?: BasicCursorPaginationOptions;
            };
            return: CursorPaginatedCollectionProp<SpaceEnvResourceTypeProps>;
        };
    };
    Http: {
        get: {
            params: {
                url: string;
                config?: RawAxiosRequestConfig;
            };
            return: any;
        };
        patch: {
            params: {
                url: string;
                config?: RawAxiosRequestConfig;
            };
            payload: any;
            return: any;
        };
        post: {
            params: {
                url: string;
                config?: RawAxiosRequestConfig;
            };
            payload: any;
            return: any;
        };
        put: {
            params: {
                url: string;
                config?: RawAxiosRequestConfig;
            };
            payload: any;
            return: any;
        };
        delete: {
            params: {
                url: string;
                config?: RawAxiosRequestConfig;
            };
            return: any;
        };
        request: {
            params: {
                url: string;
                config?: RawAxiosRequestConfig;
            };
            return: any;
        };
    };
    AiAction: {
        get: {
            params: GetSpaceParams & {
                aiActionId: string;
            };
            return: AiActionProps;
        };
        getMany: {
            params: GetSpaceParams & {
                query: AiActionQueryOptions;
            };
            return: CollectionProp<AiActionProps>;
        };
        create: {
            params: GetSpaceParams;
            payload: CreateAiActionProps;
            headers?: RawAxiosRequestHeaders;
            return: AiActionProps;
        };
        update: {
            params: GetSpaceParams & {
                aiActionId: string;
            };
            payload: AiActionProps;
            headers?: RawAxiosRequestHeaders;
            return: AiActionProps;
        };
        delete: {
            params: GetSpaceParams & {
                aiActionId: string;
            };
            return: any;
        };
        publish: {
            params: GetSpaceParams & {
                aiActionId: string;
                version: number;
            };
            headers?: RawAxiosRequestHeaders;
            return: AiActionProps;
        };
        unpublish: {
            params: GetSpaceParams & {
                aiActionId: string;
            };
            headers?: RawAxiosRequestHeaders;
            return: AiActionProps;
        };
        invoke: {
            params: GetSpaceEnvironmentParams & {
                aiActionId: string;
            };
            payload: AiActionInvocationType;
            headers?: RawAxiosRequestHeaders;
            return: AiActionInvocationProps;
        };
    };
    AiActionInvocation: {
        get: {
            params: GetSpaceEnvironmentParams & {
                aiActionId: string;
                invocationId: string;
            };
            return: AiActionInvocationProps;
        };
    };
    AppAction: {
        get: {
            params: GetAppActionParams;
            return: AppActionProps;
        };
        getMany: {
            params: GetAppDefinitionParams & QueryParams;
            return: CollectionProp<AppActionProps>;
        };
        getManyForEnvironment: {
            params: GetAppActionsForEnvParams & QueryParams;
            return: CollectionProp<AppActionProps>;
        };
        delete: {
            params: GetAppActionParams;
            return: void;
        };
        create: {
            params: GetAppDefinitionParams;
            payload: CreateAppActionProps;
            return: AppActionProps;
        };
        update: {
            params: GetAppActionParams;
            payload: CreateAppActionProps;
            return: AppActionProps;
        };
    };
    AppActionCall: {
        create: {
            params: GetAppActionCallParams;
            payload: CreateAppActionCallProps;
            return: AppActionCallProps;
        };
        get: {
            params: GetAppActionCallParamsWithId;
            return: AppActionCallProps;
        };
        getCallDetails: {
            params: GetAppActionCallDetailsParams;
            return: AppActionCallResponse;
        };
        createWithResponse: {
            params: CreateWithResponseParams;
            payload: CreateAppActionCallProps;
            return: AppActionCallResponse;
        };
        createWithResult: {
            params: CreateWithResultParams;
            payload: CreateAppActionCallProps;
            return: AppActionCallProps;
        };
        getResponse: {
            params: GetAppActionCallParamsWithId;
            return: AppActionCallRawResponseProps;
        };
    };
    AppBundle: {
        get: {
            params: GetAppBundleParams;
            return: AppBundleProps;
        };
        getMany: {
            params: GetAppDefinitionParams & QueryParams;
            return: CollectionProp<AppBundleProps>;
        };
        delete: {
            params: GetAppBundleParams;
            return: void;
        };
        create: {
            params: GetAppDefinitionParams;
            payload: CreateAppBundleProps;
            return: AppBundleProps;
        };
    };
    ApiKey: {
        get: {
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            return: ApiKeyProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<ApiKeyProps>;
        };
        create: {
            params: GetSpaceParams;
            payload: CreateApiKeyProps;
            headers?: RawAxiosRequestHeaders;
            return: ApiKeyProps;
        };
        createWithId: {
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            payload: CreateApiKeyProps;
            headers?: RawAxiosRequestHeaders;
            return: ApiKeyProps;
        };
        update: {
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            payload: ApiKeyProps;
            headers?: RawAxiosRequestHeaders;
            return: ApiKeyProps;
        };
        delete: {
            params: GetSpaceParams & {
                apiKeyId: string;
            };
            return: any;
        };
    };
    AppDefinition: {
        get: {
            params: GetOrganizationParams & {
                appDefinitionId: string;
            };
            return: AppDefinitionProps;
        };
        getMany: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<AppDefinitionProps>;
        };
        create: {
            params: GetOrganizationParams;
            payload: CreateAppDefinitionProps;
            return: AppDefinitionProps;
        };
        update: {
            params: GetAppDefinitionParams;
            payload: AppDefinitionProps;
            headers?: RawAxiosRequestHeaders;
            return: AppDefinitionProps;
        };
        delete: {
            params: GetAppDefinitionParams;
            return: any;
        };
        getInstallationsForOrg: {
            params: GetOrganizationParams & {
                appDefinitionId: string;
            } & SpaceQueryParams;
            return: AppInstallationsForOrganizationProps;
        };
    };
    AppInstallation: {
        get: {
            params: GetAppInstallationParams;
            return: AppInstallationProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & PaginationQueryParams;
            return: CollectionProp<AppInstallationProps>;
        };
        upsert: {
            params: GetAppInstallationParams & {
                acceptAllTerms?: boolean;
            };
            payload: CreateAppInstallationProps;
            headers?: RawAxiosRequestHeaders;
            return: AppInstallationProps;
        };
        delete: {
            params: GetAppInstallationParams;
            return: any;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                appDefinitionId: string;
                spaceId?: string;
            };
            return: AppInstallationsForOrganizationProps;
        };
    };
    AppUpload: {
        get: {
            params: GetAppUploadParams;
            return: AppUploadProps;
        };
        delete: {
            params: GetAppUploadParams;
            return: void;
        };
        create: {
            params: GetOrganizationParams;
            payload: {
                file: string | ArrayBuffer | Stream;
            };
            return: AppUploadProps;
        };
    };
    AppDetails: {
        upsert: {
            params: GetAppDefinitionParams;
            payload: CreateAppDetailsProps;
            return: AppDetailsProps;
        };
        get: {
            params: GetAppDefinitionParams;
            return: AppDetailsProps;
        };
        delete: {
            params: GetAppDefinitionParams;
            return: void;
        };
    };
    AppSignedRequest: {
        create: {
            params: GetAppInstallationParams;
            payload: CreateAppSignedRequestProps;
            return: AppSignedRequestProps;
        };
    };
    AppSigningSecret: {
        upsert: {
            params: GetAppDefinitionParams;
            payload: CreateAppSigningSecretProps;
            return: AppSigningSecretProps;
        };
        get: {
            params: GetAppDefinitionParams;
            return: AppSigningSecretProps;
        };
        delete: {
            params: GetAppDefinitionParams;
            return: void;
        };
    };
    AppEventSubscription: {
        upsert: {
            params: GetAppDefinitionParams;
            payload: CreateAppEventSubscriptionProps;
            return: AppEventSubscriptionProps;
        };
        get: {
            params: GetAppDefinitionParams;
            return: AppEventSubscriptionProps;
        };
        delete: {
            params: GetAppDefinitionParams;
            return: void;
        };
    };
    AppKey: {
        create: {
            params: GetAppDefinitionParams;
            payload: CreateAppKeyProps;
            return: AppKeyProps;
        };
        get: {
            params: GetAppDefinitionParams & {
                fingerprint: string;
            };
            return: AppKeyProps;
        };
        getMany: {
            params: GetAppDefinitionParams & QueryParams;
            return: CollectionProp<AppKeyProps>;
        };
        delete: {
            params: GetAppDefinitionParams & {
                fingerprint: string;
            };
            return: void;
        };
    };
    AppAccessToken: {
        create: {
            params: GetAppInstallationParams;
            payload: CreateAppAccessTokenProps;
            return: AppAccessTokenProps;
        };
    };
    Asset: {
        getPublished: {
            params: GetSpaceEnvironmentParams & QueryParams;
            headers?: RawAxiosRequestHeaders;
            return: CollectionProp<AssetProps>;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            headers?: RawAxiosRequestHeaders;
            return: CollectionProp<AssetProps>;
        };
        get: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            } & QueryParams;
            headers?: RawAxiosRequestHeaders;
            return: AssetProps;
        };
        update: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            payload: AssetProps;
            headers?: RawAxiosRequestHeaders;
            return: AssetProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: any;
        };
        publish: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            payload: AssetProps;
            return: AssetProps;
        };
        unpublish: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: AssetProps;
        };
        archive: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: AssetProps;
        };
        unarchive: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            return: AssetProps;
        };
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateAssetProps;
            return: AssetProps;
        };
        createWithId: {
            params: GetSpaceEnvironmentParams & {
                assetId: string;
            };
            payload: CreateAssetProps;
            return: AssetProps;
        };
        createFromFiles: {
            params: GetSpaceEnvironmentParams & {
                uploadTimeout?: number;
            };
            payload: Omit<AssetFileProp, 'sys'>;
            return: AssetProps;
        };
        processForAllLocales: {
            params: GetSpaceEnvironmentParams & {
                asset: AssetProps;
                options?: AssetProcessingForLocale;
            };
            return: AssetProps;
        };
        processForLocale: {
            params: GetSpaceEnvironmentParams & {
                asset: AssetProps;
                locale: string;
                options?: AssetProcessingForLocale;
            };
            return: AssetProps;
        };
    };
    AssetKey: {
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateAssetKeyProps;
            return: AssetKeyProps;
        };
    };
    BulkAction: {
        get: {
            params: GetBulkActionParams;
            return: BulkActionProps;
        };
        publish: {
            params: GetSpaceEnvironmentParams;
            payload: BulkActionPublishPayload;
            return: BulkActionProps<BulkActionPublishPayload>;
        };
        unpublish: {
            params: GetSpaceEnvironmentParams;
            payload: BulkActionUnpublishPayload;
            return: BulkActionProps<BulkActionUnpublishPayload>;
        };
        validate: {
            params: GetSpaceEnvironmentParams;
            payload: BulkActionValidatePayload;
            return: BulkActionProps<BulkActionValidatePayload>;
        };
    };
    Comment: {
        get:
            | {
                  params: GetCommentParams & PlainTextBodyFormat;
                  return: CommentProps;
              }
            | {
                  params: GetCommentParams & RichTextBodyFormat;
                  return: RichTextCommentProps;
              };
        getMany:
            | {
                  params: GetManyCommentsParams & PlainTextBodyFormat & QueryParams;
                  return: CollectionProp<CommentProps>;
              }
            | {
                  params: GetManyCommentsParams & QueryParams & RichTextBodyFormat;
                  return: CollectionProp<RichTextCommentProps>;
              };
        getAll:
            | {
                  params: GetManyCommentsParams & QueryParams & PlainTextBodyFormat;
                  return: CollectionProp<CommentProps>;
              }
            | {
                  params: GetManyCommentsParams & QueryParams & RichTextBodyFormat;
                  return: CollectionProp<RichTextCommentProps>;
              };
        create:
            | {
                  params: CreateCommentParams & PlainTextBodyFormat;
                  payload: CreateCommentProps;
                  return: CommentProps;
              }
            | {
                  params: CreateCommentParams & RichTextBodyFormat;
                  payload: RichTextCommentBodyPayload;
                  return: RichTextCommentProps;
              };
        update:
            | {
                  params: UpdateCommentParams;
                  payload: UpdateCommentProps;
                  headers?: RawAxiosRequestHeaders;
                  return: CommentProps;
              }
            | {
                  params: UpdateCommentParams;
                  payload: Omit<UpdateCommentProps, 'body'> &
                      RichTextCommentBodyPayload;
                  headers?: RawAxiosRequestHeaders;
                  return: RichTextCommentProps;
              };
        delete: {
            params: DeleteCommentParams;
            return: void;
        };
    };
    Concept: {
        create: {
            params: GetOrganizationParams;
            payload: CreateConceptProps;
            return: ConceptProps;
        };
        createWithId: {
            params: GetConceptParams;
            payload: CreateConceptProps;
            return: ConceptProps;
        };
        patch: {
            params: UpdateConceptParams;
            payload: OpPatch[];
            return: ConceptProps;
        };
        update: {
            params: UpdateConceptParams;
            payload: OpPatch[];
            return: ConceptProps;
        };
        updatePut: {
            params: UpdateConceptParams;
            payload: CreateConceptProps;
            return: ConceptProps;
        };
        delete: {
            params: DeleteConceptParams;
            return: void;
        };
        get: {
            params: GetConceptParams;
            return: ConceptProps;
        };
        getMany: {
            params: GetManyConceptParams;
            return: CursorPaginatedCollectionProp<ConceptProps>;
        };
        getTotal: {
            params: GetOrganizationParams;
            return: {
                total: number;
            };
        };
        getDescendants: {
            params: GetConceptDescendantsParams;
            return: CursorPaginatedCollectionProp<ConceptProps>;
        };
        getAncestors: {
            params: GetConceptDescendantsParams;
            return: CursorPaginatedCollectionProp<ConceptProps>;
        };
    };
    ConceptScheme: {
        create: {
            params: GetOrganizationParams;
            payload: CreateConceptSchemeProps;
            return: ConceptSchemeProps;
        };
        createWithId: {
            params: GetConceptSchemeParams;
            payload: CreateConceptSchemeProps;
            return: ConceptSchemeProps;
        };
        patch: {
            params: UpdateConceptSchemeParams;
            payload: OpPatch[];
            return: ConceptSchemeProps;
        };
        update: {
            params: UpdateConceptSchemeParams;
            payload: OpPatch[];
            return: ConceptSchemeProps;
        };
        updatePut: {
            params: UpdateConceptSchemeParams;
            payload: CreateConceptSchemeProps;
            return: ConceptSchemeProps;
        };
        get: {
            params: GetConceptSchemeParams;
            return: ConceptSchemeProps;
        };
        getMany: {
            params: GetManyConceptSchemeParams;
            return: CursorPaginatedCollectionProp<ConceptSchemeProps>;
        };
        getTotal: {
            params: GetOrganizationParams;
            return: {
                total: number;
            };
        };
        delete: {
            params: DeleteConceptSchemeParams;
            return: void;
        };
    };
    ContentType: {
        get: {
            params: GetContentTypeParams & QueryParams;
            return: ContentTypeProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<ContentTypeProps>;
        };
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateContentTypeProps;
            return: ContentTypeProps;
        };
        createWithId: {
            params: GetContentTypeParams;
            payload: CreateContentTypeProps;
            return: ContentTypeProps;
        };
        update: {
            params: GetContentTypeParams;
            payload: ContentTypeProps;
            headers?: RawAxiosRequestHeaders;
            return: ContentTypeProps;
        };
        delete: {
            params: GetContentTypeParams;
            return: any;
        };
        publish: {
            params: GetContentTypeParams;
            payload: ContentTypeProps;
            return: ContentTypeProps;
        };
        unpublish: {
            params: GetContentTypeParams;
            return: ContentTypeProps;
        };
    };
    EditorInterface: {
        get: {
            params: GetEditorInterfaceParams;
            return: EditorInterfaceProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<EditorInterfaceProps>;
        };
        update: {
            params: GetEditorInterfaceParams;
            payload: EditorInterfaceProps;
            headers?: RawAxiosRequestHeaders;
            return: EditorInterfaceProps;
        };
    };
    Environment: {
        get: {
            params: GetSpaceEnvironmentParams;
            return: EnvironmentProps;
        };
        getMany: {
            params: GetSpaceParams & PaginationQueryParams;
            return: CollectionProp<EnvironmentProps>;
        };
        create: {
            params: GetSpaceParams;
            payload: Partial<Pick<EnvironmentProps, 'name'>>;
            headers?: RawAxiosRequestHeaders;
            return: EnvironmentProps;
        };
        createWithId: {
            params: GetSpaceEnvironmentParams & {
                sourceEnvironmentId?: string;
            };
            payload: CreateEnvironmentProps;
            headers?: RawAxiosRequestHeaders;
            return: EnvironmentProps;
        };
        update: {
            params: GetSpaceEnvironmentParams;
            payload: EnvironmentProps;
            headers?: RawAxiosRequestHeaders;
            return: EnvironmentProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams;
            return: any;
        };
    };
    EnvironmentAlias: {
        get: {
            params: GetSpaceEnvAliasParams;
            return: EnvironmentAliasProps;
        };
        getMany: {
            params: GetSpaceParams & PaginationQueryParams;
            return: CollectionProp<EnvironmentAliasProps>;
        };
        createWithId: {
            params: GetSpaceEnvAliasParams;
            payload: CreateEnvironmentAliasProps;
            headers?: RawAxiosRequestHeaders;
            return: EnvironmentAliasProps;
        };
        update: {
            params: GetSpaceEnvAliasParams;
            payload: EnvironmentAliasProps;
            headers?: RawAxiosRequestHeaders;
            return: EnvironmentAliasProps;
        };
        delete: {
            params: GetSpaceEnvAliasParams;
            return: any;
        };
    };
    EnvironmentTemplate: {
        get: {
            params: GetEnvironmentTemplateParams & {
                version?: number;
                query?: {
                    select?: string;
                };
            };
            return: EnvironmentTemplateProps;
        };
        getMany: {
            params: GetOrganizationParams & {
                query?: BasicCursorPaginationOptions & {
                    select?: string;
                };
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateProps>;
        };
        create: {
            payload: CreateEnvironmentTemplateProps;
            params: GetOrganizationParams;
            return: EnvironmentTemplateProps;
        };
        versionUpdate: {
            params: GetEnvironmentTemplateParams & {
                version: number;
            };
            payload: {
                versionName: string;
                versionDescription: string;
            };
            return: EnvironmentTemplateProps;
        };
        update: {
            params: GetEnvironmentTemplateParams;
            payload: EnvironmentTemplateProps;
            return: EnvironmentTemplateProps;
        };
        delete: {
            params: GetEnvironmentTemplateParams;
            return: void;
        };
        versions: {
            params: GetEnvironmentTemplateParams & {
                query?: BasicCursorPaginationOptions & {
                    select?: string;
                };
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateProps>;
        };
        validate: {
            params: EnvironmentTemplateParams & {
                version?: number;
            };
            payload: ValidateEnvironmentTemplateInstallationProps;
            return: EnvironmentTemplateValidationProps;
        };
        install: {
            params: EnvironmentTemplateParams;
            payload: CreateEnvironmentTemplateInstallationProps;
            return: EnvironmentTemplateInstallationProps;
        };
        disconnect: {
            params: EnvironmentTemplateParams;
            return: void;
        };
    };
    EnvironmentTemplateInstallation: {
        getMany: {
            params: BasicCursorPaginationOptions & {
                environmentId?: string;
                environmentTemplateId: string;
                organizationId: string;
                spaceId?: string;
            };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>;
        };
        getForEnvironment: {
            params: BasicCursorPaginationOptions &
                EnvironmentTemplateParams & {
                    installationId?: string;
                };
            return: CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>;
        };
    };
    Entry: {
        getPublished: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<EntryProps<any>>;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<EntryProps<any>>;
        };
        get: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            } & QueryParams;
            return: EntryProps<any>;
        };
        patch: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                version: number;
            };
            payload: OpPatch[];
            headers?: RawAxiosRequestHeaders;
            return: EntryProps<any>;
        };
        update: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            payload: EntryProps<any>;
            headers?: RawAxiosRequestHeaders;
            return: EntryProps<any>;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: any;
        };
        publish: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            payload: EntryProps<any>;
            return: EntryProps<any>;
        };
        unpublish: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: EntryProps<any>;
        };
        archive: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: EntryProps<any>;
        };
        unarchive: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
            };
            return: EntryProps<any>;
        };
        create: {
            params: GetSpaceEnvironmentParams & {
                contentTypeId: string;
            };
            payload: CreateEntryProps<any>;
            return: EntryProps<any>;
        };
        createWithId: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                contentTypeId: string;
            };
            payload: CreateEntryProps<any>;
            return: EntryProps<any>;
        };
        references: {
            params: GetSpaceEnvironmentParams & {
                entryId: string;
                include?: number;
            };
            return: EntryReferenceProps;
        };
    };
    Extension: {
        get: {
            params: GetExtensionParams & QueryParams;
            return: ExtensionProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<ExtensionProps>;
        };
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateExtensionProps;
            headers?: RawAxiosRequestHeaders;
            return: ExtensionProps;
        };
        createWithId: {
            params: GetExtensionParams;
            payload: CreateExtensionProps;
            headers?: RawAxiosRequestHeaders;
            return: ExtensionProps;
        };
        update: {
            params: GetExtensionParams;
            payload: ExtensionProps;
            headers?: RawAxiosRequestHeaders;
            return: ExtensionProps;
        };
        delete: {
            params: GetExtensionParams;
            return: any;
        };
    };
    Function: {
        get: {
            params: GetFunctionParams;
            return: FunctionProps;
        };
        getMany: {
            params: GetManyFunctionParams;
            return: CollectionProp<FunctionProps>;
        };
        getManyForEnvironment: {
            params: GetFunctionForEnvParams;
            return: CollectionProp<FunctionProps>;
        };
    };
    FunctionLog: {
        get: {
            params: GetFunctionLogParams;
            return: FunctionLogProps;
            headers?: RawAxiosRequestHeaders;
        };
        getMany: {
            params: GetManyFunctionLogParams;
            return: CollectionProp<FunctionLogProps>;
            headers?: RawAxiosRequestHeaders;
        };
    };
    Locale: {
        get: {
            params: GetSpaceEnvironmentParams & {
                localeId: string;
            };
            return: LocaleProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<LocaleProps>;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                localeId: string;
            };
            return: any;
        };
        update: {
            params: GetSpaceEnvironmentParams & {
                localeId: string;
            };
            payload: LocaleProps;
            headers?: RawAxiosRequestHeaders;
            return: LocaleProps;
        };
        create: {
            params: GetSpaceEnvironmentParams;
            payload: CreateLocaleProps;
            headers?: RawAxiosRequestHeaders;
            return: LocaleProps;
        };
    };
    Organization: {
        getMany: {
            params: PaginationQueryParams;
            return: CollectionProp<OrganizationProps>;
        };
        get: {
            params: GetOrganizationParams;
            return: OrganizationProps;
        };
    };
    OrganizationInvitation: {
        get: {
            params: {
                organizationId: string;
                invitationId: string;
            };
            headers?: RawAxiosRequestHeaders;
            return: OrganizationInvitationProps;
        };
        create: {
            params: {
                organizationId: string;
            };
            payload: CreateOrganizationInvitationProps;
            headers?: RawAxiosRequestHeaders;
            return: OrganizationInvitationProps;
        };
    };
    OrganizationMembership: {
        get: {
            params: GetOrganizationMembershipParams;
            return: OrganizationMembershipProps;
        };
        getMany: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<OrganizationMembershipProps>;
        };
        update: {
            params: GetOrganizationMembershipParams;
            payload: OrganizationMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: OrganizationMembershipProps;
        };
        delete: {
            params: GetOrganizationMembershipParams;
            return: any;
        };
    };
    PersonalAccessToken: {
        get: {
            params: {
                tokenId: string;
            };
            return: PersonalAccessTokenProps;
        };
        getMany: {
            params: QueryParams;
            return: CollectionProp<PersonalAccessTokenProps>;
        };
        create: {
            params: {};
            payload: CreatePersonalAccessTokenProps;
            headers?: RawAxiosRequestHeaders;
            return: PersonalAccessTokenProps;
        };
        revoke: {
            params: {
                tokenId: string;
            };
            return: PersonalAccessTokenProps;
        };
    };
    AccessToken: {
        get: {
            params: {
                tokenId: string;
            };
            return: AccessTokenProps;
        };
        getMany: {
            params: QueryParams;
            return: CollectionProp<AccessTokenProps>;
        };
        createPersonalAccessToken: {
            params: {};
            payload: CreatePATProps;
            headers?: RawAxiosRequestHeaders;
            return: AccessTokenProps;
        };
        revoke: {
            params: {
                tokenId: string;
            };
            return: AccessTokenProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<AccessTokenProps>;
        };
    };
    OAuthApplication: {
        get: {
            params: GetOAuthApplicationParams;
            return: OAuthApplicationProps;
        };
        getManyForUser: {
            params: GetUserParams & QueryParams;
            return: CursorPaginatedCollectionProp<OAuthApplicationProps>;
        };
        create: {
            params: GetUserParams;
            payload: CreateOAuthApplicationProps;
            headers?: RawAxiosRequestHeaders;
            return: OAuthApplicationProps;
        };
        update: {
            params: GetOAuthApplicationParams;
            payload: UpdateOAuthApplicationProps;
            headers?: RawAxiosRequestHeaders;
            return: OAuthApplicationProps;
        };
        delete: {
            params: GetOAuthApplicationParams;
            return: void;
        };
    };
    PreviewApiKey: {
        get: {
            params: GetSpaceParams & {
                previewApiKeyId: string;
            };
            return: PreviewApiKeyProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<PreviewApiKeyProps>;
        };
    };
    Release: {
        archive: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseProps;
        };
        get: {
            params: GetReleaseParams;
            return: ReleaseProps;
        };
        query: {
            params: GetSpaceEnvironmentParams & {
                query?: ReleaseQueryOptions;
            };
            return: CollectionProp<ReleaseProps>;
        };
        create: {
            params: GetSpaceEnvironmentParams;
            payload: ReleasePayload;
            return: ReleaseProps;
        };
        update: {
            params: GetReleaseParams & {
                version: number;
            };
            payload: ReleasePayload;
            return: ReleaseProps;
        };
        delete: {
            params: GetReleaseParams;
            return: void;
        };
        publish: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseActionProps<'publish'>;
        };
        unarchive: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseProps;
        };
        unpublish: {
            params: GetReleaseParams & {
                version: number;
            };
            return: ReleaseActionProps<'unpublish'>;
        };
        validate: {
            params: GetReleaseParams;
            payload?: ReleaseValidatePayload;
            return: ReleaseActionProps<'validate'>;
        };
    };
    ReleaseAction: {
        get: {
            params: GetReleaseParams & {
                actionId: string;
            };
            return: ReleaseAction;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & {
                query?: ReleaseActionQueryOptions;
            };
            return: Collection<ReleaseAction, ReleaseActionProps>;
        };
        queryForRelease: {
            params: GetReleaseParams & {
                query?: ReleaseActionQueryOptions;
            };
            return: Collection<ReleaseAction, ReleaseActionProps>;
        };
    };
    Role: {
        get: {
            params: GetSpaceParams & {
                roleId: string;
            };
            return: RoleProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<RoleProps>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<RoleProps>;
        };
        create: {
            params: GetSpaceParams;
            payload: CreateRoleProps;
            headers?: RawAxiosRequestHeaders;
            return: RoleProps;
        };
        createWithId: {
            params: GetSpaceParams & {
                roleId: string;
            };
            payload: CreateRoleProps;
            headers?: RawAxiosRequestHeaders;
            return: RoleProps;
        };
        update: {
            params: GetSpaceParams & {
                roleId: string;
            };
            payload: RoleProps;
            headers?: RawAxiosRequestHeaders;
            return: RoleProps;
        };
        delete: {
            params: GetSpaceParams & {
                roleId: string;
            };
            return: any;
        };
    };
    ScheduledAction: {
        get: {
            params: GetSpaceParams & {
                scheduledActionId: string;
                environmentId: string;
            };
            return: ScheduledActionProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<ScheduledActionProps>;
        };
        create: {
            params: GetSpaceParams;
            payload: Omit<ScheduledActionProps, 'sys'>;
            return: ScheduledActionProps;
        };
        update: {
            params: GetSpaceParams & {
                scheduledActionId: string;
                version: number;
            };
            payload: Omit<ScheduledActionProps, 'sys'>;
            return: ScheduledActionProps;
        };
        delete: {
            params: GetSpaceEnvironmentParams & {
                scheduledActionId: string;
            };
            return: any;
        };
    };
    Snapshot: {
        getManyForEntry: {
            params: GetSnapshotForEntryParams & QueryParams;
            return: CollectionProp<SnapshotProps<Omit<EntryProps<any>, 'metadata'>>>;
        };
        getForEntry: {
            params: GetSnapshotForEntryParams & {
                snapshotId: string;
            };
            return: SnapshotProps<Omit<EntryProps<any>, 'metadata'>>;
        };
        getManyForContentType: {
            params: GetSnapshotForContentTypeParams & QueryParams;
            return: CollectionProp<SnapshotProps<ContentTypeProps>>;
        };
        getForContentType: {
            params: GetSnapshotForContentTypeParams & {
                snapshotId: string;
            };
            return: SnapshotProps<ContentTypeProps>;
        };
    };
    Space: {
        get: {
            params: GetSpaceParams;
            return: SpaceProps;
        };
        getMany: {
            params: QueryParams;
            return: CollectionProp<SpaceProps>;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<SpaceProps>;
        };
        create: {
            params: {
                organizationId?: string;
            };
            payload: Omit<SpaceProps, 'sys'>;
            headers?: RawAxiosRequestHeaders;
            return: any;
        };
        update: {
            params: GetSpaceParams;
            payload: SpaceProps;
            headers?: RawAxiosRequestHeaders;
            return: SpaceProps;
        };
        delete: {
            params: GetSpaceParams;
            return: void;
        };
    };
    SpaceMember: {
        get: {
            params: GetSpaceParams & {
                spaceMemberId: string;
            };
            return: SpaceMemberProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<SpaceMemberProps>;
        };
    };
    SpaceMembership: {
        get: {
            params: GetSpaceMembershipProps;
            return: SpaceMembershipProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<SpaceMembershipProps>;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                spaceMembershipId: string;
            };
            return: SpaceMembershipProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<SpaceMembershipProps>;
        };
        create: {
            params: GetSpaceParams;
            payload: CreateSpaceMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: SpaceMembershipProps;
        };
        createWithId: {
            params: GetSpaceMembershipProps;
            payload: CreateSpaceMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: SpaceMembershipProps;
        };
        update: {
            params: GetSpaceMembershipProps;
            payload: SpaceMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: SpaceMembershipProps;
        };
        delete: {
            params: GetSpaceMembershipProps;
            return: any;
        };
    };
    Tag: {
        get: {
            params: GetTagParams;
            return: TagProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & QueryParams;
            return: CollectionProp<TagProps>;
        };
        createWithId: {
            params: GetTagParams;
            payload: CreateTagProps;
            return: TagProps;
        };
        update: {
            params: GetTagParams;
            payload: UpdateTagProps;
            headers?: RawAxiosRequestHeaders;
            return: TagProps;
        };
        delete: {
            params: DeleteTagParams;
            return: any;
        };
    };
    Task: {
        get: {
            params: GetTaskParams;
            return: TaskProps;
        };
        getMany: {
            params: GetEntryParams & QueryParams;
            return: CollectionProp<TaskProps>;
        };
        getAll: {
            params: GetEntryParams & QueryParams;
            return: CollectionProp<TaskProps>;
        };
        create: {
            params: CreateTaskParams;
            payload: CreateTaskProps;
            return: TaskProps;
        };
        update: {
            params: UpdateTaskParams;
            payload: UpdateTaskProps;
            headers?: RawAxiosRequestHeaders;
            return: TaskProps;
        };
        delete: {
            params: DeleteTaskParams;
            return: void;
        };
    };
    Team: {
        get: {
            params: GetTeamParams;
            return: TeamProps;
        };
        getMany: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<TeamProps>;
        };
        getManyForSpace: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<TeamProps>;
        };
        create: {
            params: GetOrganizationParams;
            payload: CreateTeamProps;
            headers?: RawAxiosRequestHeaders;
            return: any;
        };
        update: {
            params: GetTeamParams;
            payload: TeamProps;
            headers?: RawAxiosRequestHeaders;
            return: TeamProps;
        };
        delete: {
            params: GetTeamParams;
            return: any;
        };
    };
    TeamMembership: {
        get: {
            params: GetTeamMembershipParams;
            return: TeamMembershipProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<TeamMembershipProps>;
        };
        getManyForTeam: {
            params: GetTeamParams & QueryParams;
            return: CollectionProp<TeamMembershipProps>;
        };
        create: {
            params: GetTeamParams;
            payload: CreateTeamMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: TeamMembershipProps;
        };
        update: {
            params: GetTeamMembershipParams;
            payload: TeamMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: TeamMembershipProps;
        };
        delete: {
            params: GetTeamMembershipParams;
            return: any;
        };
    };
    TeamSpaceMembership: {
        get: {
            params: GetTeamSpaceMembershipParams;
            return: TeamSpaceMembershipProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<TeamSpaceMembershipProps>;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                teamSpaceMembershipId: string;
            };
            return: TeamSpaceMembershipProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams &
                QueryParams & {
                    teamId?: string;
                };
            return: CollectionProp<TeamSpaceMembershipProps>;
        };
        create: {
            params: GetSpaceParams & {
                teamId: string;
            };
            payload: CreateTeamSpaceMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: TeamSpaceMembershipProps;
        };
        update: {
            params: GetTeamSpaceMembershipParams;
            payload: TeamSpaceMembershipProps;
            headers?: RawAxiosRequestHeaders;
            return: TeamSpaceMembershipProps;
        };
        delete: {
            params: GetTeamSpaceMembershipParams;
            return: any;
        };
    };
    UIConfig: {
        get: {
            params: GetUIConfigParams;
            return: UIConfigProps;
        };
        update: {
            params: GetUIConfigParams;
            payload: UIConfigProps;
            return: UIConfigProps;
        };
    };
    Upload: {
        get: {
            params: GetSpaceEnvironmentUploadParams;
            return: any;
        };
        create: {
            params: GetSpaceEnvironmentParams;
            payload: {
                file: string | ArrayBuffer | Stream;
            };
            return: any;
        };
        delete: {
            params: GetSpaceEnvironmentUploadParams;
            return: any;
        };
    };
    UploadCredential: {
        create: {
            params: GetSpaceEnvironmentParams;
            return: any;
        };
    };
    Usage: {
        getManyForSpace: {
            params: {
                organizationId: string;
            } & QueryParams;
            return: CollectionProp<UsageProps>;
        };
        getManyForOrganization: {
            params: {
                organizationId: string;
            } & QueryParams;
            return: CollectionProp<UsageProps>;
        };
    };
    User: {
        getManyForSpace: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<UserProps>;
        };
        getForSpace: {
            params: GetSpaceParams & {
                userId: string;
            };
            return: UserProps;
        };
        getCurrent: {
            params?: QueryParams;
            return: any;
        };
        getForOrganization: {
            params: GetOrganizationParams & {
                userId: string;
            };
            return: UserProps;
        };
        getManyForOrganization: {
            params: GetOrganizationParams & QueryParams;
            return: CollectionProp<UserProps>;
        };
    };
    UserUIConfig: {
        get: {
            params: GetUserUIConfigParams;
            return: UserUIConfigProps;
        };
        update: {
            params: GetUserUIConfigParams;
            payload: UserUIConfigProps;
            return: UserUIConfigProps;
        };
    };
    Webhook: {
        get: {
            params: GetWebhookParams;
            return: WebhookProps;
        };
        getMany: {
            params: GetSpaceParams & QueryParams;
            return: CollectionProp<WebhookProps>;
        };
        getCallDetails: {
            params: GetWebhookCallDetailsUrl;
            return: WebhookCallDetailsProps;
        };
        getHealthStatus: {
            params: GetWebhookParams;
            return: WebhookHealthProps;
        };
        getManyCallDetails: {
            params: GetWebhookParams & QueryParams;
            return: CollectionProp<WebhookCallOverviewProps>;
        };
        getSigningSecret: {
            params: GetSpaceParams;
            return: WebhookSigningSecretProps;
        };
        getRetryPolicy: {
            params: GetSpaceParams;
            return: WebhookRetryPolicyProps;
        };
        create: {
            params: GetSpaceParams;
            payload: CreateWebhooksProps;
            headers?: RawAxiosRequestHeaders;
            return: WebhookProps;
        };
        createWithId: {
            params: GetWebhookParams;
            payload: CreateWebhooksProps;
            headers?: RawAxiosRequestHeaders;
            return: WebhookProps;
        };
        update: {
            params: GetWebhookParams;
            payload: WebhookProps;
            return: WebhookProps;
        };
        upsertSigningSecret: {
            params: GetSpaceParams;
            payload: UpsertWebhookSigningSecretPayload;
            return: WebhookSigningSecretProps;
        };
        upsertRetryPolicy: {
            params: GetSpaceParams;
            payload: WebhookRetryPolicyPayload;
            return: WebhookRetryPolicyProps;
        };
        delete: {
            params: GetWebhookParams;
            return: void;
        };
        deleteSigningSecret: {
            params: GetSpaceParams;
            return: void;
        };
        deleteRetryPolicy: {
            params: GetSpaceParams;
            return: void;
        };
    };
    WorkflowDefinition: {
        get: {
            params: GetWorkflowDefinitionParams;
            headers?: RawAxiosRequestHeaders;
            return: WorkflowDefinitionProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & {
                query?: WorkflowDefinitionQueryOptions;
            };
            headers?: RawAxiosRequestHeaders;
            return: CollectionProp<WorkflowDefinitionProps>;
        };
        create: {
            params: CreateWorkflowDefinitionParams;
            payload: CreateWorkflowDefinitionProps;
            headers?: RawAxiosRequestHeaders;
            return: WorkflowDefinitionProps;
        };
        update: {
            params: GetWorkflowDefinitionParams;
            payload: WorkflowDefinitionProps;
            headers?: RawAxiosRequestHeaders;
            return: WorkflowDefinitionProps;
        };
        delete: {
            params: DeleteWorkflowDefinitionParams;
            headers?: RawAxiosRequestHeaders;
            return: void;
        };
    };
    Workflow: {
        get: {
            params: GetWorkflowParams;
            headers?: RawAxiosRequestHeaders;
            return: WorkflowProps;
        };
        getMany: {
            params: GetSpaceEnvironmentParams & {
                query?: WorkflowQueryOptions;
            };
            headers?: RawAxiosRequestHeaders;
            return: CollectionProp<WorkflowProps>;
        };
        create: {
            params: CreateWorkflowParams;
            payload: CreateWorkflowProps;
            headers?: RawAxiosRequestHeaders;
            return: WorkflowProps;
        };
        update: {
            params: GetWorkflowParams;
            payload: WorkflowProps;
            headers?: RawAxiosRequestHeaders;
            return: WorkflowProps;
        };
        delete: {
            params: DeleteWorkflowParams;
            headers?: RawAxiosRequestHeaders;
            return: void;
        };
        complete: {
            params: CompleteWorkflowParams;
            headers?: RawAxiosRequestHeaders;
            return: void;
        };
    };
    WorkflowsChangelog: {
        getMany: {
            params: GetSpaceEnvironmentParams & {
                query: WorkflowsChangelogQueryOptions;
            };
            headers?: RawAxiosRequestHeaders;
            return: CollectionProp<WorkflowsChangelogEntryProps>;
        };
    };
};

type MROpts

type MROpts<
    ET extends keyof MRActions,
    Action extends keyof MRActions[ET],
    UA extends boolean = false
> = {
    entityType: ET;
    action: Action;
} & (UA extends true
    ? {
          userAgent: string;
      }
    : {}) &
    ('params' extends keyof MRActions[ET][Action]
        ? undefined extends MRActions[ET][Action]['params']
            ? {
                  params?: MRActions[ET][Action]['params'];
              }
            : {
                  params: MRActions[ET][Action]['params'];
              }
        : {}) &
    ('payload' extends keyof MRActions[ET][Action]
        ? undefined extends MRActions[ET][Action]['payload']
            ? {
                  payload?: MRActions[ET][Action]['payload'];
              }
            : {
                  payload: MRActions[ET][Action]['payload'];
              }
        : {}) &
    ('headers' extends keyof MRActions[ET][Action]
        ? undefined extends MRActions[ET][Action]['headers']
            ? {
                  headers?: MRActions[ET][Action]['headers'];
              }
            : {
                  headers: MRActions[ET][Action]['headers'];
              }
        : {});

type MRReturn

type MRReturn<
    ET extends keyof MRActions,
    Action extends keyof MRActions[ET]
> = 'return' extends keyof MRActions[ET][Action]
    ? Promise<MRActions[ET][Action]['return']>
    : never;

type OAuthApplicationProps

type OAuthApplicationProps = {
    name: string;
    description: string;
    clientId: string;
    clientSecret: string;
    redirectUri: string;
    scopes: ScopeValues[];
    confidential: boolean;
    sys: OAuthApplicationSysProps;
};

type Organization

type Organization = DefaultElements<OrganizationProps> &
    OrganizationProps &
    ContentfulOrganizationAPI;

type OrganizationInvitationProps

type OrganizationInvitationProps = {
    sys: MetaSysProps & {
        organizationMembership: {
            sys: MetaLinkProps;
        };
        user: Record<string, any> | null;
        invitationUrl: string;
        status: string;
    };
    firstName: string;
    lastName: string;
    email: string;
    role: string;
};

type OrganizationMembershipProps

type OrganizationMembershipProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        user: {
            sys: MetaLinkProps;
        };
    };
    /**
     * Role
     */
    role: string;
    /**
     * status
     */
    status: boolean;
};

type OrganizationProp

type OrganizationProp = OrganizationProps;

Deprecated
Use OrganizationProps instead.

type OrganizationProps

type OrganizationProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps;
    /**
     * Name
     */
    name: string;
};

type PaginationQueryParams

type PaginationQueryParams = {
    query?: PaginationQueryOptions;
};

type ParameterOption

type ParameterOption =
    | string
    | {
          [key: string]: string;
      };

type ParameterType

type ParameterType = 'Boolean' | 'Symbol' | 'Number' | 'Enum';

type PersonalAccessTokenProp

type PersonalAccessTokenProp = PersonalAccessTokenProps;

Deprecated
Use PersonalAccessTokenProps instead.

type PersonalAccessTokenProps

type PersonalAccessTokenProps = {
    sys: MetaSysProps & {
        expiresAt?: string;
    };
    name: string;
    scopes: 'content_management_manage'[];
    revokedAt: null | string;
    token?: string;
};

type PlainClientAPI

type PlainClientAPI = {
    raw: {
        getDefaultParams(): DefaultParams | undefined;
        get<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
        post<T = unknown>(
            url: string,
            payload?: any,
            config?: RawAxiosRequestConfig
        ): Promise<T>;
        patch<T = unknown>(
            url: string,
            payload?: any,
            config?: RawAxiosRequestConfig
        ): Promise<T>;
        put<T = unknown>(
            url: string,
            payload?: any,
            config?: RawAxiosRequestConfig
        ): Promise<T>;
        delete<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
        http<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
    };
    aiAction: AiActionPlainClientAPI;
    aiActionInvocation: AiActionInvocationPlainClientAPI;
    appAction: AppActionPlainClientAPI;
    appActionCall: AppActionCallPlainClientAPI;
    appBundle: AppBundlePlainClientAPI;
    appDetails: AppDetailsPlainClientAPI;
    appEventSubscription: AppEventSubscriptionPlainClientAPI;
    appKey: AppKeyPlainClientAPI;
    appSignedRequest: AppSignedRequestPlainClientAPI;
    appSigningSecret: AppSigningSecretPlainClientAPI;
    appAccessToken: AppAccessTokenPlainClientAPI;
    function: FunctionPlainClientAPI;
    functionLog: FunctionLogPlainClientAPI;
    editorInterface: EditorInterfacePlainClientAPI;
    space: SpacePlainClientAPI;
    environment: EnvironmentPlainClientAPI;
    environmentAlias: EnvironmentAliasPlainClientAPI;
    environmentTemplate: {
        get(
            params: GetEnvironmentTemplateParams & {
                version?: number;
                query?: {
                    select?: string;
                };
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        getMany(
            params: GetOrganizationParams & {
                query?: BasicCursorPaginationOptions & {
                    select?: string;
                };
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        create(
            params: GetOrganizationParams,
            rawData: CreateEnvironmentTemplateProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        versionUpdate(
            params: GetEnvironmentTemplateParams & {
                version: number;
            },
            rawData: {
                versionName?: string;
                versionDescription?: string;
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        update(
            params: GetEnvironmentTemplateParams,
            rawData: EnvironmentTemplateProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        delete(
            params: GetEnvironmentTemplateParams,
            headers?: RawAxiosRequestHeaders
        ): Promise<void>;
        versions(
            params: GetEnvironmentTemplateParams & {
                query?: BasicCursorPaginationOptions & {
                    select?: string;
                };
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        validate(
            params: EnvironmentTemplateParams & {
                version?: number;
            },
            rawData: ValidateEnvironmentTemplateInstallationProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateValidationProps>;
        install(
            params: EnvironmentTemplateParams,
            rawData: CreateEnvironmentTemplateInstallationProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateInstallationProps>;
        disconnect(
            params: EnvironmentTemplateParams,
            headers?: RawAxiosRequestHeaders
        ): Promise<void>;
    };
    environmentTemplateInstallation: {
        getMany(
            params: BasicCursorPaginationOptions & {
                environmentId?: string;
                environmentTemplateId: string;
                organizationId: string;
                spaceId?: string;
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<
            CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>
        >;
        getForEnvironment(
            params: BasicCursorPaginationOptions &
                EnvironmentTemplateParams & {
                    installationId?: string;
                },
            headers?: RawAxiosRequestHeaders
        ): Promise<
            CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>
        >;
    };
    bulkAction: {
        get<T extends BulkActionPayload = any>(
            params: GetBulkActionParams
        ): Promise<BulkActionProps<T>>;
        publish(
            params: GetSpaceEnvironmentParams,
            payload: BulkActionPublishPayload
        ): Promise<BulkActionProps<BulkActionPublishPayload>>;
        unpublish(
            params: GetSpaceEnvironmentParams,
            payload: BulkActionUnpublishPayload
        ): Promise<BulkActionProps<BulkActionUnpublishPayload>>;
        validate(
            params: GetSpaceEnvironmentParams,
            payload: BulkActionValidatePayload
        ): Promise<BulkActionProps<BulkActionValidatePayload>>;
    };
    comment: CommentPlainClientAPI;
    concept: ConceptPlainClientAPI;
    conceptScheme: ConceptSchemePlainClientAPI;
    contentType: {
        get(
            params: OptionalDefaults<GetContentTypeParams & QueryParams>
        ): Promise<ContentTypeProps>;
        getMany(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>
        ): Promise<CollectionProp<ContentTypeProps>>;
        update(
            params: OptionalDefaults<GetContentTypeParams>,
            rawData: ContentTypeProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ContentTypeProps>;
        delete(params: OptionalDefaults<GetContentTypeParams>): Promise<any>;
        publish(
            params: OptionalDefaults<GetContentTypeParams>,
            rawData: ContentTypeProps
        ): Promise<ContentTypeProps>;
        unpublish(
            params: OptionalDefaults<GetContentTypeParams>
        ): Promise<ContentTypeProps>;
        create(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            rawData: CreateContentTypeProps
        ): Promise<ContentTypeProps>;
        createWithId(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    contentTypeId: string;
                }
            >,
            rawData: CreateContentTypeProps
        ): Promise<ContentTypeProps>;
        omitAndDeleteField(
            params: OptionalDefaults<GetContentTypeParams>,
            contentType: ContentTypeProps,
            fieldId: string
        ): Promise<ContentTypeProps>;
    };
    user: UserPlainClientAPI;
    entry: {
        getPublished<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<EntryProps<T>>>;
        getMany<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<EntryProps<T>>>;
        get<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<EntryProps<T>>;
        update<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >,
            rawData: EntryProps<T>,
            headers?: RawAxiosRequestHeaders
        ): Promise<EntryProps<T>>;
        patch<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    version?: number;
                }
            >,
            rawData: OpPatch[],
            headers?: RawAxiosRequestHeaders
        ): Promise<EntryProps<T>>;
        delete(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >
        ): Promise<any>;
        publish<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    locales?: string[];
                }
            >,
            rawData: EntryProps<T>
        ): Promise<EntryProps<T>>;
        unpublish<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    locales?: string[];
                }
            >,
            rawData?: EntryProps<T>
        ): Promise<EntryProps<T>>;
        archive<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >
        ): Promise<EntryProps<T>>;
        unarchive<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >
        ): Promise<EntryProps<T>>;
        create<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    contentTypeId: string;
                }
            >,
            rawData: CreateEntryProps<T>
        ): Promise<EntryProps<T>>;
        createWithId<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    contentTypeId: string;
                }
            >,
            rawData: CreateEntryProps<T>
        ): Promise<EntryProps<T>>;
        references(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    include?: number;
                }
            >
        ): Promise<EntryReferenceProps>;
    };
    asset: {
        getPublished(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<AssetProps>>;
        getMany(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<AssetProps>>;
        get(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                } & QueryParams
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<AssetProps>;
        update(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >,
            rawData: AssetProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<AssetProps>;
        delete(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >
        ): Promise<any>;
        publish(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    locales?: string[];
                }
            >,
            rawData: AssetProps
        ): Promise<AssetProps>;
        unpublish(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    locales?: string[];
                }
            >,
            rawData?: AssetProps
        ): Promise<AssetProps>;
        archive(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >
        ): Promise<AssetProps>;
        unarchive(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >
        ): Promise<AssetProps>;
        create(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            rawData: CreateAssetProps
        ): Promise<AssetProps>;
        createWithId(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >,
            rawData: CreateAssetProps
        ): Promise<AssetProps>;
        createFromFiles(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            data: Omit<AssetFileProp, 'sys'>
        ): Promise<AssetProps>;
        processForAllLocales(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            asset: AssetProps,
            processingOptions?: AssetProcessingForLocale
        ): Promise<AssetProps>;
        processForLocale(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            asset: AssetProps,
            locale: string,
            processingOptions?: AssetProcessingForLocale
        ): Promise<AssetProps>;
    };
    appUpload: AppUploadPlainClientAPI;
    assetKey: {
        create(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            data: CreateAssetKeyProps
        ): Promise<AssetKeyProps>;
    };
    upload: UploadPlainClientAPI;
    uploadCredential: UploadCredentialAPI;
    locale: LocalePlainClientAPI;
    personalAccessToken: {
        get(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<PersonalAccessTokenProps>;
        getMany(
            params: OptionalDefaults<QueryParams>
        ): Promise<CollectionProp<PersonalAccessTokenProps>>;
        create(
            rawData: CreatePersonalAccessTokenProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<PersonalAccessTokenProps>;
        revoke(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<PersonalAccessTokenProps>;
    };
    accessToken: {
        get(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<AccessTokenProps>;
        getMany(
            params: OptionalDefaults<QueryParams>
        ): Promise<CollectionProp<AccessTokenProps>>;
        createPersonalAccessToken(
            rawData: CreatePATProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<AccessTokenProps>;
        revoke(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<AccessTokenProps>;
        getManyForOrganization(
            params: OptionalDefaults<GetOrganizationParams & QueryParams>
        ): Promise<CollectionProp<AccessTokenProps>>;
    };
    usage: UsagePlainClientAPI;
    release: {
        archive(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseProps>;
        get(params: OptionalDefaults<GetReleaseParams>): Promise<ReleaseProps>;
        query(
            params: OptionalDefaults<GetSpaceEnvironmentParams> & {
                query?: ReleaseQueryOptions;
            }
        ): Promise<CursorPaginatedCollectionProp<ReleaseProps>>;
        create(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            data: ReleasePayload
        ): Promise<ReleaseProps>;
        update(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >,
            data: ReleasePayload
        ): Promise<ReleaseProps>;
        delete(params: OptionalDefaults<GetReleaseParams>): Promise<void>;
        publish(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseActionProps<'publish'>>;
        unarchive(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseProps>;
        unpublish(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseActionProps<'unpublish'>>;
        validate(
            params: OptionalDefaults<GetReleaseParams>,
            data?: ReleaseValidatePayload
        ): Promise<ReleaseActionProps<'validate'>>;
    };
    releaseAction: {
        get(
            params: OptionalDefaults<GetReleaseParams> & {
                actionId: string;
            }
        ): Promise<ReleaseActionProps>;
        getMany(
            params: OptionalDefaults<GetSpaceEnvironmentParams> & {
                query?: ReleaseActionQueryOptions;
            }
        ): Promise<CollectionProp<ReleaseActionProps>>;
        queryForRelease(
            params: OptionalDefaults<GetReleaseParams> & {
                query?: ReleaseActionQueryOptions;
            }
        ): Promise<CollectionProp<ReleaseActionProps>>;
    };
    resource: ResourcePlainAPI;
    resourceProvider: ResourceProviderPlainClientAPI;
    resourceType: ResourceTypePlainClientAPI;
    role: RolePlainClientAPI;
    scheduledActions: {
        get(
            params: OptionalDefaults<GetSpaceParams> & {
                scheduledActionId: string;
                environmentId: string;
            }
        ): Promise<ScheduledActionProps>;
        getMany(
            params: OptionalDefaults<GetSpaceParams & QueryParams>
        ): Promise<CursorPaginatedCollectionProp<ScheduledActionProps>>;
        create(
            params: OptionalDefaults<GetSpaceParams>,
            data: CreateUpdateScheduledActionProps
        ): Promise<ScheduledActionProps>;
        delete(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    scheduledActionId: string;
                }
            >
        ): Promise<ScheduledActionProps>;
        update(
            params: OptionalDefaults<
                GetSpaceParams & {
                    scheduledActionId: string;
                    version: number;
                }
            >,
            data: CreateUpdateScheduledActionProps
        ): Promise<ScheduledActionProps>;
    };
    previewApiKey: {
        get(
            params: OptionalDefaults<
                GetSpaceParams & {
                    previewApiKeyId: string;
                }
            >
        ): Promise<PreviewApiKeyProps>;
        getMany(
            params: OptionalDefaults<GetSpaceParams & QueryParams>
        ): Promise<CollectionProp<PreviewApiKeyProps>>;
    };
    apiKey: {
        get(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >
        ): Promise<ApiKeyProps>;
        getMany(
            params: OptionalDefaults<GetSpaceParams & QueryParams>
        ): Promise<CollectionProp<ApiKeyProps>>;
        create(
            params: OptionalDefaults<GetSpaceParams>,
            data: CreateApiKeyProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ApiKeyProps>;
        createWithId(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >,
            data: CreateApiKeyProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ApiKeyProps>;
        update(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >,
            rawData: ApiKeyProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ApiKeyProps>;
        delete(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >
        ): Promise<any>;
    };
    appDefinition: AppDefinitionPlainClientAPI;
    appInstallation: AppInstallationPlainClientAPI;
    extension: ExtensionPlainClientAPI;
    webhook: WebhookPlainClientAPI;
    snapshot: {
        getManyForEntry<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<GetSnapshotForEntryParams & QueryParams>
        ): Promise<CollectionProp<SnapshotProps<Omit<EntryProps<T>, 'metadata'>>>>;
        getForEntry<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSnapshotForEntryParams & {
                    snapshotId: string;
                }
            >
        ): Promise<SnapshotProps<Omit<EntryProps<T>, 'metadata'>>>;
        getManyForContentType(
            params: OptionalDefaults<GetSnapshotForContentTypeParams & QueryParams>
        ): Promise<CollectionProp<SnapshotProps<ContentTypeProps>>>;
        getForContentType(
            params: OptionalDefaults<
                GetSnapshotForContentTypeParams & {
                    snapshotId: string;
                }
            >
        ): Promise<SnapshotProps<ContentTypeProps>>;
    };
    tag: TagPlainClientAPI;
    organization: OrganizationPlainClientAPI;
    organizationInvitation: {
        get(
            params: OptionalDefaults<{
                organizationId: string;
                invitationId: string;
            }>,
            headers?: RawAxiosRequestHeaders
        ): Promise<OrganizationInvitationProps>;
        create(
            params: OptionalDefaults<{
                organizationId: string;
            }>,
            data: CreateOrganizationInvitationProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<OrganizationInvitationProps>;
    };
    organizationMembership: {
        get(
            params: OptionalDefaults<GetOrganizationMembershipParams>
        ): Promise<OrganizationMembershipProps>;
        getMany(
            params: OptionalDefaults<GetOrganizationParams & QueryParams>
        ): Promise<CollectionProp<OrganizationMembershipProps>>;
        update(
            params: OptionalDefaults<GetOrganizationMembershipParams>,
            rawData: OrganizationMembershipProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<OrganizationMembershipProps>;
        delete(
            params: OptionalDefaults<GetOrganizationMembershipParams>
        ): Promise<any>;
    };
    spaceMember: SpaceMemberPlainClientAPI;
    spaceMembership: SpaceMembershipPlainClientAPI;
    task: TaskPlainClientAPI;
    team: TeamPlainClientAPI;
    teamMembership: TeamMembershipPlainClientAPI;
    teamSpaceMembership: TeamSpaceMembershipPlainClientAPI;
    uiConfig: UIConfigPlainClientAPI;
    userUIConfig: UserUIConfigPlainClientAPI;
    workflowDefinition: WorkflowDefinitionPlainClientAPI;
    workflow: WorkflowPlainClientAPI;
    workflowsChangelog: WorkflowsChangelogPlainClientAPI;
    oauthApplication: OAuthApplicationPlainClientAPI;
};

type PlainClientDefaultParams

type PlainClientDefaultParams = DefaultParams;

type PreviewApiKeyProps

type PreviewApiKeyProps = {
    sys: MetaSysProps;
    name: string;
    description: string;
    accessToken: string;
};

type QueryParams

type QueryParams = {
    query?: QueryOptions;
};

type ReleaseActionSysProps

type ReleaseActionSysProps = {
    id: string;
    type: 'ReleaseAction';
    space: Link<'Space'>;
    environment: Link<'Environment'>;
    release: Link<'Release'>;
    status: ReleaseActionStatuses;
    createdBy: Link<'User'>;
    createdAt: ISO8601Timestamp;
    updatedBy: Link<'User'>;
    updatedAt: ISO8601Timestamp;
};

type ReleaseActionTypes

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

type ReleaseMetadata

type ReleaseMetadata = {
    withReferences: {
        entity: Link<'Entry'>;
        filter: Record<ReleaseReferenceFilters, string[]>;
    }[];
};

type ReleaseReferenceFilters

type ReleaseReferenceFilters = ScheduledActionReferenceFilters;

type ReleaseSysProps

type ReleaseSysProps = {
    id: string;
    type: 'Release';
    version: number;
    status: ReleaseStatus;
    space: Link<'Space'>;
    environment: Link<'Environment'>;
    archivedBy?: Link<'User'>;
    archivedAt?: ISO8601Timestamp;
    createdBy: Link<'User'> | Link<'AppDefinition'>;
    updatedBy: Link<'User'> | Link<'AppDefinition'>;
    createdAt: ISO8601Timestamp;
    updatedAt: ISO8601Timestamp;
    lastAction?: Link<'ReleaseAction'>;
};

type ResourceProps

type ResourceProps = {
    sys: {
        type: 'Resource';
        urn: string;
        resourceType: SysLink;
        resourceProvider: SysLink;
        appDefinition: SysLink;
    };
    fields: {
        title: string;
        subtitle?: string;
        description?: string;
        externalUrl?: string;
        image?: {
            url: string;
            altText?: string;
        };
        badge?: {
            label: string;
            variant: 'primary' | 'negative' | 'positive' | 'warning' | 'secondary';
        };
    };
};

type ResourceProviderProps

type ResourceProviderProps = {
    /**
     * System metadata
     */
    sys: Omit<BasicMetaSysProps, 'version'> & {
        organization: SysLink;
        appDefinition: SysLink;
    };
    /**
     * Resource Provider type, value is 'function'
     */
    type: 'function';
    /**
     * Link to a Contentful function
     */
    function: SysLink;
};

type ResourceQueryOptions

type ResourceQueryOptions = LookupQueryOptions | SearchQueryOptions;

type ResourceTypeProps

type ResourceTypeProps = {
    /**
     * System metadata
     */
    sys: Omit<BasicMetaSysProps, 'version'> & {
        appDefinition: SysLink;
        resourceProvider: SysLink;
        organization: SysLink;
    };
    /**
     * Resource Type name
     */
    name: string;
    /**
     * Resource Type defaultFieldMapping
     */
    defaultFieldMapping: {
        title: string;
        subtitle?: string;
        description?: string;
        externalUrl?: string;
        image?: {
            url: string;
            altText?: string;
        };
        badge?: {
            label: string;
            variant: string;
        };
    };
};

type RestAdapterParams

type RestAdapterParams = CreateHttpClientParams & {
    /**
     * Contentful CMA Access Token
     */
    accessToken: CreateHttpClientParams['accessToken'];
    /**
     * API host
     * @default api.contentful.com
     */
    host?: string;
    /**
     * direct file upload host
     * @default upload.contentful.com
     */
    hostUpload?: string;
    userAgent?: string | undefined;
};

type RichTextCommentProps

type RichTextCommentProps = Omit<CommentProps, 'body'> & RichTextCommentBodyPayload;

type RoleProps

type RoleProps = {
    sys: BasicMetaSysProps & {
        space: SysLink;
    };
    name: string;
    description?: string;
    /**
     * Permissions for application sections
     */
    permissions: {
        ContentDelivery: string[] | string;
        ContentModel: string[];
        EnvironmentAliases: string[] | string;
        Environments: string[] | string;
        Settings: string[] | string;
        Tags: string[] | string;
    };
    policies: {
        effect: string;
        actions: ActionType[] | 'all';
        constraint: ConstraintType;
    }[];
};

type ScheduledActionProps

type ScheduledActionProps = {
    sys: ScheduledActionSysProps;
    action: SchedulableActionType;
    entity: Link<SchedulableEntityType>;
    environment?: {
        sys: MetaLinkProps;
    };
    scheduledFor: {
        datetime: ISO8601Timestamp;
        /**
         * A valid IANA timezone Olson identifier
         *
         * @see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
         * @example 'Asia/Kolkata'
         */
        timezone?: string;
    };
    /**
     * The Contentful-style error that occurred during execution if sys.status is failed
     *
     * @example
     * {
     *   sys: {
     *     type: 'Error',
     *     id: 'InvalidEntry'
     *   },
     *   message: 'Entry is invalid',
     *   details: {
     *     errors: [...]
     *   }
     * }
     */
    error?: ScheduledActionFailedError;
    payload?: ScheduledActionPayloadProps;
};

type ScheduledActionSysProps

type ScheduledActionSysProps = {
    id: string;
    type: 'ScheduledAction';
    version: number;
    space: SysLink;
    status: ScheduledActionStatus;
    createdAt: ISO8601Timestamp;
    createdBy: Link<'User'> | Link<'AppDefinition'>;
    /** an ISO8601 date string representing when an action was moved to canceled */
    canceledAt?: ISO8601Timestamp;
    canceledBy?: Link<'User'> | Link<'AppDefinition'>;
    /** an ISO8601 date string representing when an action was updated */
    updatedAt: ISO8601Timestamp;
    updatedBy: Link<'User'> | Link<'AppDefinition'>;
};

type SnapshotProps

type SnapshotProps<T> = {
    sys: MetaSysProps & {
        snapshotType: string;
        snapshotEntityType: string;
    };
    snapshot: T;
};

type Space

type Space = SpaceProps & DefaultElements<SpaceProps> & ContentfulSpaceAPI;

type SpaceEnvResourceTypeProps

type SpaceEnvResourceTypeProps = Pick<
    ResourceTypeProps,
    (typeof publicResourceTypeFields)[number]
> & {
    sys: Partial<Pick<ResourceTypeProps['sys'], OptionalSysFields>> &
        Omit<ResourceTypeProps['sys'], OptionalSysFields>;
};

type SpaceMemberProps

type SpaceMemberProps = {
    sys: MetaSysProps;
    /**
     * User is an admin
     */
    admin: boolean;
    /**
     * Array of Role Links
     */
    roles: {
        sys: MetaLinkProps;
    }[];
};

type SpaceMembershipProps

type SpaceMembershipProps = {
    sys: MetaSysProps & {
        space: SysLink;
        user: SysLink;
    };
    user: SysLink;
    admin: boolean;
    roles: SysLink[];
};

type SpaceProps

type SpaceProps = {
    sys: BasicMetaSysProps & {
        organization: {
            sys: {
                id: string;
            };
        };
        archivedAt?: string;
    };
    name: string;
};

type SpaceQueryParams

type SpaceQueryParams = {
    query?: SpaceQueryOptions;
};

type TagProps

type TagProps = {
    sys: TagSysProps;
    name: string;
};

type TagVisibility

type TagVisibility = 'private' | 'public';

type TaskProps

type TaskProps = {
    sys: TaskSysProps;
    body: string;
    assignedTo: Link<'User' | 'Team'>;
    status: TaskStatus;
    dueDate?: string;
};

type TeamMembershipProps

type TeamMembershipProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        team: {
            sys: MetaLinkProps;
        };
        organization: {
            sys: MetaLinkProps;
        };
        organizationMembership: {
            sys: MetaLinkProps;
        };
    };
    /**
     * Is admin
     */
    admin: boolean;
    /**
     * Organization membership id
     */
    organizationMembershipId: string;
};

type TeamProps

type TeamProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        memberCount: number;
        organization: {
            sys: MetaLinkProps;
        };
    };
    /**
     * Name of the team
     */
    name: string;
    /**
     * Description of the team
     */
    description: string;
};

type TeamSpaceMembershipProps

type TeamSpaceMembershipProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        team: {
            sys: MetaLinkProps;
        };
        space: {
            sys: MetaLinkProps;
        };
    };
    /**
     * Is admin
     */
    admin: boolean;
    /**
     * Roles
     */
    roles: {
        sys: MetaLinkProps;
    }[];
};

type UIConfigProps

type UIConfigProps = {
    /**
     * System metadata
     */
    sys: UIConfigSysProps;
    assetListViews: ViewFolder[];
    entryListViews: ViewFolder[];
    homeViews: HomeView[];
    livePreview?: {
        previewMode: 'livePreview' | 'legacyPreview';
    };
    publish?: {
        publishMode: 'entryPublishing' | 'localePublishing';
    };
};

type UIExtensionProps

type ExtensionProps = {
    sys: ExtensionSysProps;
    extension: {
        /**
         * Extension name
         */
        name: string;
        /**
         * Field types where an extension can be used
         */
        fieldTypes: FieldType[];
        /**
         * URL where the root HTML document of the extension can be found
         */
        src?: string;
        /**
         * String representation of the extension (e.g. inline HTML code)
         */
        srcdoc?: string;
        /**
         * Parameter definitions
         */
        parameters?: {
            instance?: ParameterDefinition[];
            installation?: ParameterDefinition<InstallationParameterType>[];
        };
        /**
         * Controls the location of the extension. If true it will be rendered on the sidebar instead of replacing the field's editing control
         */
        sidebar?: boolean;
    };
    /**
     * Values for installation parameters
     */
    parameters?: DefinedParameters;
};

type UpdateCommentProps

type UpdateCommentProps = Omit<CommentProps, 'sys'> & {
    sys: Pick<CommentSysProps, 'version'>;
};

type UpdateConceptParams

type UpdateConceptParams = GetOrganizationParams & {
    conceptId: string;
    version: number;
};

type UpdateConceptSchemeParams

type UpdateConceptSchemeParams = GetOrganizationParams & {
    conceptSchemeId: string;
    version: number;
};

type UpdateTaskProps

type UpdateTaskProps = Omit<TaskProps, 'sys'> & {
    sys: Pick<TaskSysProps, 'version'>;
};

type UpdateWebhookProps

type UpdateWebhookProps = SetOptional<
    Except<WebhookProps, 'sys'>,
    'headers' | 'name' | 'topics' | 'url' | 'active'
>;

type UpdateWorkflowDefinitionParams

type UpdateWorkflowDefinitionParams = GetWorkflowDefinitionParams;

type UpdateWorkflowDefinitionProps

type UpdateWorkflowDefinitionProps = Omit<
    WorkflowDefinitionProps,
    'sys' | 'steps'
> & {
    sys: Pick<WorkflowDefinitionSysProps, 'version'>;
    steps: Array<CreateWorkflowStepProps | UpdateWorkflowStepProps>;
};

type UpdateWorkflowProps

type UpdateWorkflowProps = Omit<WorkflowProps, 'sys'> & {
    sys: Pick<WorkflowSysProps, 'version'>;
};

type UpdateWorkflowStepProps

type UpdateWorkflowStepProps = WorkflowStepProps;

type UploadCredentialProps

type UploadCredentialProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        space: SysLink;
        environment?: SysLink;
    };
};

type UploadProps

type UploadProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        space: SysLink;
        environment?: SysLink;
    };
};

type UpsertResourceProviderProps

type UpsertResourceProviderProps = Omit<ResourceProviderProps, 'sys'> & {
    sys: {
        id: string;
    };
};

type UpsertResourceTypeProps

type UpsertResourceTypeProps = Omit<ResourceTypeProps, 'sys'>;

type UpsertWebhookSigningSecretPayload

type UpsertWebhookSigningSecretPayload = {
    value: string;
};

type UsageProps

type UsageProps = {
    /**
     * System metadata
     */
    sys: MetaSysProps & {
        organization?: {
            sys: MetaLinkProps;
        };
    };
    /**
     * Type of usage
     */
    metric: UsageMetricEnum;
    /**
     * Unit of usage metric
     */
    unitOfMeasure: string;
    /**
     * Range of usage
     */
    dateRange: {
        startAt: string;
        endAt: string;
    };
    /**
     * Value of the usage
     */
    usage: number;
    /**
     * Usage per day
     */
    usagePerDay: {
        [key: string]: number;
    };
};

type UserProps

type UserProps = {
    /**
     * System metadata
     */
    sys: BasicMetaSysProps;
    /**
     * First name of the user
     */
    firstName: string;
    /**
     * Last name of the user
     */
    lastName: string;
    /**
     * Url to the users avatar
     */
    avatarUrl: string;
    /**
     * Email address of the user
     */
    email: string;
    /**
     * Activation flag
     */
    activated: boolean;
    /**
     * Number of sign ins
     */
    signInCount: number;
    /**
     * User confirmation flag
     */
    confirmed: boolean;
    '2faEnabled': boolean;
    cookieConsentData: string;
};

type UserUIConfigProps

type UserUIConfigProps = {
    /**
     * System metadata
     */
    sys: UserUIConfigSysProps;
    assetListViews: ViewFolder[];
    entryListViews: ViewFolder[];
};

type ValidateEnvironmentTemplateInstallationProps

type ValidateEnvironmentTemplateInstallationProps = Omit<
    CreateEnvironmentTemplateInstallationProps,
    'version'
>;

type ValidationFinding

type ValidationFinding = {
    message: string;
    details: Record<string, unknown>;
};

type WebhookCallRequest

type WebhookCallRequest = {
    url: string;
    method: string;
    headers: {
        [key: string]: string;
    };
    body: string;
};

type WebhookFilter

type WebhookFilter =
    | EqualityConstraint
    | InConstraint
    | RegexpConstraint
    | NotConstraint;

type WebhookProps

type WebhookProps = {
    /**
     * System metadata
     */
    sys: BasicMetaSysProps & {
        space: SysLink;
    };
    /**
     * Webhook name
     */
    name: string;
    /**
     * Webhook url
     */
    url: string;
    /**
     * Topics the webhook wants to subscribe to
     */
    topics: string[];
    /**
     * Username for basic http auth
     */
    httpBasicUsername?: string;
    /**
     * Password for basic http auth
     */
    httpBasicPassword?: string;
    /**
     * Headers that should be appended to the webhook request
     */
    headers: Array<WebhookHeader>;
    /**
     * Webhook filters
     */
    filters?: WebhookFilter[];
    /**
     * Transformation to apply
     */
    transformation?: WebhookTransformation;
    /**
     * Whether the Webhook is active. If set to false, no calls will be made
     */
    active: boolean;
};

type WebhookSigningSecretProps

type WebhookSigningSecretProps = {
    sys: WebhookSigningSecretSys & {
        space: {
            sys: MetaLinkProps;
        };
    };
    redactedValue: string;
};

type WebhookTransformation

type WebhookTransformation = {
    method?: null | 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
    contentType?:
        | null
        | 'application/vnd.contentful.management.v1+json'
        | 'application/vnd.contentful.management.v1+json; charset=utf-8'
        | 'application/json'
        | 'application/json; charset=utf-8'
        | 'application/x-www-form-urlencoded'
        | 'application/x-www-form-urlencoded; charset=utf-8';
    includeContentLength?: boolean | null;
    body?: JsonValue;
};

type WithResourceName

type WithResourceName<
    T extends {
        sys: unknown;
    }
> = T extends {
    sys: infer Sys;
}
    ? Omit<T, 'sys'> & {
          sys: Sys & {
              urn: string;
          };
      }
    : never;

type WorkflowDefinitionProps

type WorkflowDefinitionProps = {
    sys: WorkflowDefinitionSysProps;
    name: string;
    description?: string;
    appliesTo?: WorkflowDefinitionValidationLink[];
    steps: WorkflowStepProps[];
    startOnEntityCreation?: boolean;
    flowType?: 'no_restriction' | 'strict_neighbor';
};

type WorkflowDefinitionQueryOptions

type WorkflowDefinitionQueryOptions = Omit<PaginationQueryOptions, 'order'>;

type WorkflowDefinitionSysProps

type WorkflowDefinitionSysProps = Pick<
    BasicMetaSysProps,
    'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'
> & {
    type: 'WorkflowDefinition';
    space: SysLink;
    environment: SysLink;
    isLocked: boolean;
};

type WorkflowDefinitionValidationLink

type WorkflowDefinitionValidationLink = {
    type: 'Link';
    validations: Array<{
        linkContentType: string[];
    }>;
    linkType: 'Entry';
};

type WorkflowProps

type WorkflowProps = {
    sys: WorkflowSysProps;
    stepId?: string;
};

type WorkflowQueryOptions

type WorkflowQueryOptions = Omit<PaginationQueryOptions, 'order'> & {
    'stepId[in]'?: string;
    /** Find workflows filtered by the Entity type (Entry) */
    'sys.entity.sys.linkType'?: string;
    /** Find workflows containing the specified, comma-separated entities. Requires `sys.entity.sys.linkType` */
    'sys.entity.sys.id[in]'?: string;
    'sys.workflowDefinition.sys.id'?: string;
    /**
     * Order workflows by
     * @default -sys.createdAt
     * */
    order?: OrderQueryParam;
};

type WorkflowsChangelogEntryProps

type WorkflowsChangelogEntryProps = {
    event: string;
    eventBy: SysLink;
    eventAt: string;
    workflow: VersionedLink<'Workflow'>;
    workflowDefinition: Link<'WorkflowDefinition'>;
    entity: Link<'Entry'>;
    stepId: string;
    stepAnnotations: string[];
    stepName: string;
};

type WorkflowsChangelogQueryOptions

type WorkflowsChangelogQueryOptions = Omit<PaginationQueryOptions, 'order'> & {
    /** Find workflows changelog entries filtered by the Entity type (Entry) */
    'entity.sys.linkType': string;
    /** Find workflows changelog entries containing the specified, comma-separated entities. Requires `sys.entity.sys.linkType` */
    'entity.sys.id': string;
    /** workflow.sys.id is optional so all past workflows can be found */
    'workflow.sys.id'?: string;
    'eventAt[lte]'?: string;
    'eventAt[gte]'?: string;
    'workflowDefinition.sys.id[in]'?: string;
};

type WorkflowStepAction

type WorkflowStepAction =
    | WorkflowStepEmailAction
    | WorkflowStepTaskAction
    | WorkflowStepAppAction;

type WorkflowStepAppAction

type WorkflowStepAppAction = {
    type: 'app';
    appId: string;
    appActionId: string;
    configuration?: {
        body?: Record<string, any>;
        headers?: Record<string, string>;
    };
};

type WorkflowStepEmailAction

type WorkflowStepEmailAction = {
    type: 'email';
    configuration: {
        recipients: WorkflowStepEmailActionRecipient[];
    };
};

type WorkflowStepEmailActionRecipient

type WorkflowStepEmailActionRecipient = string | Link<'User'> | Link<'Team'>;

type WorkflowStepPermissionActors

type WorkflowStepPermissionActors =
    | 'all'
    | NonEmptyArray<Link<'User'> | Link<'Team'>>;

type WorkflowStepProps

type WorkflowStepProps = {
    id: string;
    name: string;
    description?: string;
    actions?: WorkflowStepAction[];
    annotations?: string[];
    permissions?: WorkflowStepPermission[];
};

type WorkflowStepTaskAction

type WorkflowStepTaskAction = {
    type: 'task';
    configuration: {
        assignee: Link<'User'> | Link<'Team'>;
        body: string;
        dueDate?: number;
    };
};

type XOR

type XOR<T, U> = T | U extends object
    ? (Without<T, U> & U) | (Without<U, T> & T)
    : T | U;

Namespaces

namespace editorInterfaceDefaults

module 'dist/typings/constants/editor-interface-defaults/index.d.ts' {}

variable _default

const _default: {
    SidebarEntryConfiguration: {
        widgetId: string;
        widgetNamespace: import('./types').WidgetNamespace;
        name: string;
        description: string;
    }[];
    SidebarAssetConfiguration: {
        widgetId: string;
        widgetNamespace: import('./types').WidgetNamespace;
        name: string;
        description: string;
    }[];
    EntryConfiguration: {
        widgetId: string;
        widgetNamespace: import('./types').WidgetNamespace;
        name: string;
    }[];
    getDefaultControlOfField: typeof getDefaultControlOfField;
};

Package Files (77)

Dependencies (5)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/contentful-management.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/contentful-management)

HTML

<a href="https://www.jsdocs.io/package/contentful-management"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 second ago.
Package analyzed in 12670 ms.
Missing or incorrect documentation? Open an issue for this package.

contentful-management

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ReleaseReferenceFilters

Functions

function asIterator

function createClient

Parameter params

Deprecated

function fetchAll

function isDraft

function isPublished

function isUpdated

function makeRequest

Classes

class RestAdapter

constructor

method makeRequest

Interfaces

interface AcceptsQueryOptions

property 'accepts[all]'

interface AccessToken

method revoke

Example 1

interface Adapter

property makeRequest

interface AiAction

method delete

method invoke

method publish

method unpublish

method update

interface AiActionInvocation

interface ApiKey

method delete

Example 1

method update

Example 1

interface AppAccessToken

interface AppActionCall

interface AppActionCallErrorProps

property details

property message

property statusCode

property sys

interface AppActionCallRawResponseProps

property response

property sys

interface AppBundle

method delete

Example 1

interface AppDetails

method delete

Example 1

interface AppEventSubscription

method delete

Example 1

interface AppIcon

property type

property value

interface AppInstallation

method delete

Example 1

method update

Example 1

interface AppKey

method delete

Example 1

interface AppSignedRequest

interface AppSigningSecret

method delete