contentful-management

contentful-management

Version 12.14.0
Published 2 days ago
6.72 MB
6 dependencies
MIT license

Install

npm i contentful-management

yarn add contentful-management

pnpm add contentful-management

Overview

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

Index

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: {
    (clientOptions: ClientOptions): PlainClientAPI;
    (
        clientOptions: any,
        opts: { type?: 'plain'; defaults?: PlainClientDefaultParams }
    ): PlainClientAPI;
    (clientOptions: any, opts: { type: 'legacy' }): {
        getEnvironmentTemplates: (
            organizationId: string,
            query?: BasicCursorPaginationOptions & {
                select?: string;
                forTemplatedSpaces?: boolean;
            }
        ) => 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 & { cursor?: false } & SpaceIncludeParam,
                organizationId?: string
            ): Promise<Collection<Space, SpaceProps>>;
            (
                query: BasicCursorPaginationOptions & {
                    cursor: true;
                } & SpaceIncludeParam,
                organizationId?: string
            ): Promise<CursorPaginatedCollection<Space, SpaceProps>>;
        };
        getSpace: (
            spaceId: string,
            { include }?: SpaceIncludeParam
        ) => 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>;
    };
};

Create a client instance

Parameter clientOptions

Client initialization parameters

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

Deprecated
The nested (legacy) client is deprecated and will be removed in the next major version. Use the plain client instead.

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 AccessToken

interface AccessToken extends AccessTokenProps, DefaultElements<AccessTokenProps> {}

method revoke

revoke: () => Promise<AccessToken>;

Revokes access token
Returns
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 Agent

interface Agent extends AgentProps, DefaultElements<AgentProps> {}

method generate

generate: (payload: AgentGeneratePayload) => Promise<AgentGenerateResponse>;

interface AgentRun

interface AgentRun extends AgentRunProps, DefaultElements<AgentRunProps> {}

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.
Returns
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
Returns
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 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;
    };
    statusCode?: number;
    body: string;
};

property sys

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

interface AppBundle

interface AppBundle extends AppBundleProps, DefaultElements<AppBundleProps> {}

method delete

delete: () => Promise<void>;

Deletes this object on the server.
Returns
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.
Returns
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.
Returns
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.
Returns
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
Returns
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.
Returns
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.
Returns
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.
Returns
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;

property skip

skip?: never;

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 | BulkActionV2Payload = any>
    extends BulkActionProps<T>,
        BulkActionApiMethods,
        DefaultElements<BulkActionProps<T>> {}

interface BulkActionProps

interface BulkActionProps<
    TPayload extends BulkActionPayload | BulkActionV2Payload = 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

Returns

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

Returns

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 release

release?: Link<'Release'>;

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 EntryReferenceProps

interface EntryReferenceProps extends CollectionProp<EntryProps> {}

property errors

errors?: EntryReferenceError[];

property includes

includes?: {
    Entry?: EntryProps[];
    Asset?: AssetProps[];
};

interface EnvironmentAlias

interface EnvironmentAlias
    extends EnvironmentAliasProps,
        DefaultElements<EnvironmentAliasProps> {}

method delete

delete: () => Promise<void>;

Deletes this object on the server. EnvironmentAlias delete

Returns

{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

Returns

{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 ExoCursorPaginatedCollectionProp

interface ExoCursorPaginatedCollectionProp<TObj>
    extends CursorPaginatedCollectionProp<TObj> {}

property pages

pages: {
    next?: string;
    prev?: string;
};

property total

total?: number;

interface ExoMetadataProps

interface ExoMetadataProps {}

Base metadata shape for ExO entities (ComponentType, Template). Mirrors upstream MetadataSchema: tags and concepts only. - tags: optional (upstream MetadataSchema.tags is z.optional as of SPA-3821) - concepts: optional taxonomy concept links

property concepts

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

property tags

tags?: Link<'Tag'>[];

interface ExoQueryFilters

interface ExoQueryFilters {}

Shared query filter fields for ExO list endpoints (ComponentType, Experience, Fragment, Template). Mirrors the four shared filter schemas in experiences-management-api-contract: SysFiltersSchema + TagFiltersSchema + TaxonomyConceptsFiltersSchema + TextFiltersSchema

property 'metadata.concepts.descendants[in]'

'metadata.concepts.descendants[in]'?: string;

property 'metadata.concepts.sys.id[all]'

'metadata.concepts.sys.id[all]'?: string;

property 'metadata.concepts.sys.id[in]'

'metadata.concepts.sys.id[in]'?: string;

property 'metadata.concepts.sys.id[nin]'

'metadata.concepts.sys.id[nin]'?: string;

property 'metadata.tags.sys.id[all]'

'metadata.tags.sys.id[all]'?: string;

property 'metadata.tags.sys.id[in]'

'metadata.tags.sys.id[in]'?: string;

property 'metadata.tags.sys.id[nin]'

'metadata.tags.sys.id[nin]'?: string;

property 'name[match]'

'name[match]'?: string;

property 'sys.archivedAt[exists]'

'sys.archivedAt[exists]'?: boolean;

property 'sys.createdAt[gt]'

'sys.createdAt[gt]'?: string;

property 'sys.createdAt[gte]'

'sys.createdAt[gte]'?: string;

property 'sys.createdAt[lt]'

'sys.createdAt[lt]'?: string;

property 'sys.createdAt[lte]'

'sys.createdAt[lte]'?: string;

property 'sys.createdBy.sys.id'

'sys.createdBy.sys.id'?: string;

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

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

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

'sys.createdBy.sys.id[nin]'?: string;

property 'sys.firstPublishedAt[gt]'

'sys.firstPublishedAt[gt]'?: string;

property 'sys.firstPublishedAt[gte]'

'sys.firstPublishedAt[gte]'?: string;

property 'sys.firstPublishedAt[lt]'

'sys.firstPublishedAt[lt]'?: string;

property 'sys.firstPublishedAt[lte]'

'sys.firstPublishedAt[lte]'?: string;

property 'sys.id'

'sys.id'?: string;

property 'sys.id[in]'

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

property 'sys.id[nin]'

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

property 'sys.publishedAt[gt]'

'sys.publishedAt[gt]'?: string;

property 'sys.publishedAt[gte]'

'sys.publishedAt[gte]'?: string;

property 'sys.publishedAt[lt]'

'sys.publishedAt[lt]'?: string;

property 'sys.publishedAt[lte]'

'sys.publishedAt[lte]'?: string;

property 'sys.publishedBy.sys.id'

'sys.publishedBy.sys.id'?: string;

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

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

property 'sys.publishedBy.sys.id[nin]'

'sys.publishedBy.sys.id[nin]'?: string;

property 'sys.publishedVersion'

'sys.publishedVersion'?: number;

property 'sys.updatedAt[gt]'

'sys.updatedAt[gt]'?: string;

property 'sys.updatedAt[gte]'

'sys.updatedAt[gte]'?: string;

property 'sys.updatedAt[lt]'

'sys.updatedAt[lt]'?: string;

property 'sys.updatedAt[lte]'

'sys.updatedAt[lte]'?: string;

property 'sys.updatedBy.sys.id'

'sys.updatedBy.sys.id'?: string;

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

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

property 'sys.updatedBy.sys.id[nin]'

'sys.updatedBy.sys.id[nin]'?: string;

property 'sys.version'

'sys.version'?: number;

property name

name?: string;

interface ExperienceMetadataProps

interface ExperienceMetadataProps extends ExoMetadataProps {}

Extended metadata shape for Experience entities only. Adds name? for variant labeling (SPA-3939), mirroring upstream ExperienceMetadata.

property name

name?: string;

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.
Returns
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
Returns
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
Returns
Promise for the deleted OAuth application

method update

update: () => Promise<OAuthApplicationProps>;

Updates an OAuth application
Returns
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
Returns
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
Returns
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 PublishBulkActionV2Payload

interface PublishBulkActionV2Payload<
    PublishActionType extends 'add' | 'remove' = 'add'
> {}

property action

action: 'publish';

property entities

entities: PublishActionType extends 'remove'
    ? RemoveFieldsEntity<VersionedLink<Entity>>[]
    : AddFieldsEntity<VersionedLink<Entity>>[];

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 sys

sys?: {
    type: 'Release';
    schemaVersion?: 'Release.v1' | undefined;
};

property title

title: string;

interface ReleasePayloadV2

interface ReleasePayloadV2 extends MakeRequestPayload {}

property entities

entities: BaseCollection<
    {
        entity: Link<Entity>;
    } & ReleaseValidatePayload
>;

property sys

sys?: {
    type: 'Release';
    schemaVersion: 'Release.v2';
};

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 'metadata.annotations.Contentful:Timeline.type[in]'

'metadata.annotations.Contentful:Timeline.type[in]'?: string;

Comma-separated filter (inclusion) by annotation type (e.g. 'Hidden', 'Ideation')

property 'metadata.annotations.Contentful:Timeline.type[nin]'

'metadata.annotations.Contentful:Timeline.type[nin]'?: string;

Comma-separated filter (exclusion) by annotation type (e.g. 'Hidden', 'Ideation')

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.schemaVersion'

'sys.schemaVersion'?: 'Release.v1' | 'Release.v2';

Determines the Release API version to use. 'Release.v1' refers to Launch, 'Release.v2' refers to Releases.

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
Returns
{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
Returns
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 SemanticDuplicates

interface SemanticDuplicates
    extends SemanticDuplicatesProps,
        DefaultElements<SemanticDuplicatesProps> {}

interface SemanticRecommendations

interface SemanticRecommendations
    extends SemanticRecommendationsProps,
        DefaultElements<SemanticRecommendationsProps> {}

interface SemanticReferenceSuggestions

interface SemanticReferenceSuggestions
    extends SemanticReferenceSuggestionsProps,
        DefaultElements<SemanticReferenceSuggestionsProps> {}

interface SemanticSearch

interface SemanticSearch
    extends SemanticSearchProps,
        DefaultElements<SemanticSearchProps> {}

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 SpaceAddOn

interface SpaceAddOn extends SpaceAddOnProps, DefaultElements<SpaceAddOnProps> {}

interface SpaceAddOnOrganization

interface SpaceAddOnOrganization
    extends SpaceAddOnOrganizationProps,
        DefaultElements<SpaceAddOnOrganizationProps> {}

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.
Returns
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
Returns
Object returned from the server with updated changes.
Example 1
```javascript const contentful = require('contentful-management')
const client = contentful.createClient({ accessToken: '<content_management_api_key>' })
client.getSpace('<space_id>') .then((space) => space.getSpaceMembership('<spaceMembership_id>')) .then((spaceMembership) => { spaceMembership.name = 'new space membership name' }) .then((spaceMembership) => console.log(spaceMembership ${spaceMembership.sys.id} updated.)) .catch(console.error) ```

interface SysLink

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.
Returns
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
Returns
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.
Returns
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
Returns
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.
Returns
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
Returns
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.
Returns
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
Returns
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 UnpublishBulkActionV2Payload

interface UnpublishBulkActionV2Payload {}

property action

action: 'unpublish';

property entities

entities: BulkActionEntity<Link<Entity>>[];

interface Upload

interface Upload extends UploadProps, DefaultElements<UploadProps> {}

method delete

delete: () => Promise<void>;

Deletes this object on the server.
Returns
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.
Returns
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 ValidateBulkActionV2Payload

interface ValidateBulkActionV2Payload<
    PublishActionType extends 'add' | 'remove' = 'add'
> {}

property action

action: 'validate';

property entities

entities: PublishActionType extends 'remove'
    ? RemoveFieldsEntity<Link<Entity>>[]
    : AddFieldsEntity<Link<Entity>>[];

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.

Returns

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

Returns

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.

Returns

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.

Returns

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

Returns

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 ScheduledActionStatus

enum ScheduledActionStatus {
    scheduled = 'scheduled',
    inProgress = 'inProgress',
    succeeded = 'succeeded',
    failed = 'failed',
    canceled = 'canceled',
}

Represents that state of the scheduled action

member canceled

canceled = 'canceled'

action was canceled by a user (terminal state)

member failed

failed = 'failed'

action failed to complete (terminal state)

member inProgress

inProgress = 'inProgress'

action has been started and pending completion

member scheduled

scheduled = 'scheduled'

action is pending execution

member succeeded

succeeded = 'succeeded'

action was completed successfully (terminal state)

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 AccessTokenProp

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

type ActionType

type ActionType =
    | 'read'
    | 'create'
    | 'update'
    | 'delete'
    | 'publish'
    | 'unpublish'
    | 'archive'
    | 'unarchive';

type AgentGeneratePayload

type AgentGeneratePayload<TMetadata = Record<string, unknown>> = {
    messages: Array<{
        parts: Array<{
            type: 'text';
            text: string;
        }>;
        id?: string;
        role: AgentMessageRole;
    }>;
    threadId?: string;
    metadata?: TMetadata;
};

type AgentGenerateResponse

type AgentGenerateResponse = {
    sys: {
        id: string;
        type: 'AgentRun';
        status: AgentRunStatus;
    };
};

type AgentProps

type AgentProps = {
    sys: MetaSysProps & {
        type: 'Agent';
        space: {
            sys: {
                id: string;
            };
        };
        environment: {
            sys: {
                id: string;
            };
        };
        createdAt: string;
        id: string;
    };
    name: string;
    description: string;
    tools?: Array<AgentToolLink>;
    provider?: string;
    modelId?: string;
};

type AgentResumeRunPayload

type AgentResumeRunPayload<TResumePayload = Record<string, unknown>> = {
    resumePayload: TResumePayload;
};

type AgentRunMessage

type AgentRunMessage = {
    id: string;
    createdAt: string;
    role: AgentRunMessageRole;
    content: {
        parts: Array<AgentRunMessagePart>;
    };
};

type AgentRunMessagePart

type AgentRunMessagePart = AgentRunMessageTextPart | AgentRunMessageToolCallPart;

type AgentRunMessageRole

type AgentRunMessageRole = 'system' | 'user' | 'assistant' | 'tool';

type AgentRunMessageTextPart

type AgentRunMessageTextPart = {
    type: 'text';
    text: string;
};

type AgentRunMessageToolCallPart

type AgentRunMessageToolCallPart = {
    type: 'tool-call';
    toolCallId: string;
    toolName: string;
    args: unknown;
};

type AgentRunProps

type AgentRunProps = {
    sys: MetaSysProps & {
        type: 'AgentRun';
        createdAt: string;
        updatedAt?: string;
        status: AgentRunStatus;
        id: string;
    };
    agent: {
        sys: Link<'Agent'>;
    };
    space: {
        sys: Link<'Space'>;
    };
    title: string;
    messages: Array<AgentRunMessage>;
};

type AgentRunQueryOptions

type AgentRunQueryOptions = {
    agentIn?: string[];
    statusIn?: AgentRunStatus[];
};

type AgentRunStatus

type AgentRunStatus =
    | 'IN_PROGRESS'
    | 'FAILED'
    | 'COMPLETED'
    | 'PENDING_REVIEW'
    | 'DRAFT';

type AgentToolLink

type AgentToolLink = {
    sys: {
        type: 'Link';
        linkType: 'AgentTool';
        id: string;
    };
};

type AiActionInvocationProps

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

type AiActionInvocationVariable

type AiActionInvocationVariable =
    | AiActionTextVariable
    | AiActionEntityLinkVariable
    | AiActionLegacyEntityPathVariable
    | AiActionLegacyEntityPathsVariable;

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.
         * @returns 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 AppActionCall

type AppActionCall = AppActionCallProps & DefaultElements<AppActionCallProps>;

type AppActionCallProps

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

type AppActionCallResponse

type AppActionCallResponse = WebhookCallDetailsProps;

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;
    /**
     * This property is currently restricted to internal Contentful apps only.
     * If you are interested in building agents using the App Framework,
     * please reach out to Contentful Support (https://www.contentful.com/support/).
     */
    agent?: AppDefinitionAgent;
    /**
     * 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 ArrayDataTypeDefinition

type ArrayDataTypeDefinition = BaseDataTypeDefinition & {
    type: 'Array';
    items: DataTypeDefinition;
};

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<S = {}> = {
    sys: EntityMetaSysProps & S;
    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 BaseDataTypeDefinition

type BaseDataTypeDefinition = {
    name?: string;
    required?: boolean;
};

type BulkActionPayload

type BulkActionPayload =
    | BulkActionPublishPayload
    | BulkActionUnpublishPayload
    | BulkActionValidatePayload;

type BulkActionType

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

type BulkActionV2Payload

type BulkActionV2Payload =
    | PublishBulkActionV2Payload<'add'>
    | PublishBulkActionV2Payload<'remove'>
    | UnpublishBulkActionV2Payload
    | ValidateBulkActionV2Payload<'add'>
    | ValidateBulkActionV2Payload<'remove'>;

type ClientAPI

type ClientAPI = ReturnType<typeof createClientApi>;

Deprecated
The nested (legacy) client is deprecated and will be removed in the next major version. Use the plain client instead.

type ClientOptions

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

type CommentProps

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

type CommentStatus

type CommentStatus = 'active' | 'resolved';

type ComponentCollection

type ComponentCollection = ExoCursorPaginatedCollectionProp<ComponentProps>;

type ComponentNode

type ComponentNode = {
    id: string;
    name?: string;
    nodeType: 'Component';
    componentType: ResourceLink<'Contentful:ComponentType'>;
    contentProperties:
        | Record<string, ContentPropertyPointerValue | unknown>
        | string;
    designProperties: Record<string, ComponentTreeDesignPropertyValue>;
    slots: Record<string, TreeNode[]>;
};

Deprecated
Use ComponentNodeV2 instead. ComponentNodeV2 uses the renamed component link (Contentful:Component) in place of componentType.

type ComponentNodeV2

type ComponentNodeV2 = {
    id: string;
    name?: string;
    nodeType: 'Component';
    component: ResourceLink<'Contentful:Component'>;
    contentProperties:
        | Record<string, ContentPropertyPointerValue | unknown>
        | string;
    designProperties: Record<string, ComponentTreeDesignPropertyValue>;
    slots: Record<string, TreeNodeV2[]>;
};

type ComponentProps

type ComponentProps = {
    sys: ComponentSys;
    name: string;
    description: string;
    viewports: ComponentTypeViewport[];
    contentProperties: ComponentTypeContentProperty[];
    designProperties: ComponentTypeDesignProperty[];
    componentTree?: TreeNodeV2[];
    slots?: ComponentSlotDefinition[];
    metadata?: ExoMetadataProps;
    dataAssemblies?: DataAssemblyLink[];
};

type ComponentSlotDefinition

type ComponentSlotDefinition = {
    id: string;
    name: string;
    required: boolean;
    validations: Array<{
        size?: {
            min?: number;
            max?: number;
        };
    }>;
    allowedResources?: Array<{
        type: 'Contentful:Component';
        source: typeof COMPONENT_TYPE_ALLOWED_RESOURCE_SOURCE;
        allowedTypes: string[];
    }>;
};

type ComponentTypeCollection

type ComponentTypeCollection = ExoCursorPaginatedCollectionProp<ComponentTypeProps>;

Deprecated
Use ComponentCollection (see ./component) instead. The ComponentType entity is superseded by the Component entity.

type ComponentTypeContentProperty

type ComponentTypeContentProperty = DataTypeDefinition & {
    id: string;
    name: string;
    required: boolean;
    defaultValue?: unknown;
};

type ComponentTypeDesignProperty

type ComponentTypeDesignProperty =
    | StringDesignProperty
    | BooleanDesignProperty
    | TokenBackedDesignProperty;

type ComponentTypeProps

type ComponentTypeProps = {
    sys: ComponentTypeSys;
    name: string;
    description: string;
    viewports: ComponentTypeViewport[];
    contentProperties: ComponentTypeContentProperty[];
    designProperties: ComponentTypeDesignProperty[];
    componentTree?: TreeNode[];
    slots?: ComponentTypeSlotDefinition[];
    metadata?: ExoMetadataProps;
    dataAssemblies?: DataAssemblyLink[];
    source?: ResourceLink<'Contentful:DesignSystemSource'>;
};

Deprecated
Use ComponentProps (see ./component) instead. The ComponentType entity is superseded by the Component entity.

type ComponentTypeSlotDefinition

type ComponentTypeSlotDefinition = {
    id: string;
    name: string;
    required: boolean;
    validations: Array<{
        size?: {
            min?: number;
            max?: number;
        };
    }>;
    allowedResources?: Array<{
        type: 'Contentful:ComponentType';
        source: typeof COMPONENT_TYPE_ALLOWED_RESOURCE_SOURCE;
        allowedTypes: string[];
    }>;
};

Deprecated
Use ComponentSlotDefinition instead. ComponentSlotDefinition uses the renamed allowedResources[].type value (Contentful:Component).

type ComponentTypeViewport

type ComponentTypeViewport = {
    id: string;
    query: string;
    displayName: string;
    previewSize: string;
};

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 ConstraintType

type ConstraintType = {
    [key in ConditionType]?: ConstraintType[] | any;
};

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 CreateComponentProps

type CreateComponentProps = Except<ComponentProps, 'sys'>;

type CreateComponentTypeProps

type CreateComponentTypeProps = Except<ComponentTypeProps, 'sys' | 'source'> & {
    source?: ResourceLink<'Contentful:DesignSystemSource'> | null;
};

Deprecated
Use CreateComponentProps (see ./component) instead. The ComponentType entity is superseded by the Component entity.

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 CreateDataAssemblyProps

type CreateDataAssemblyProps = DataAssemblyCommonProps & {
    sys: {
        type: 'DataAssembly';
        variant?: string;
        dataType: DataAssemblyDataTypeField[];
    };
};

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'>;
    deleteDeletedFields?: boolean;
};

type CreateEnvironmentTemplateProps

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

type CreateExperienceFragmentProps

type CreateExperienceFragmentProps = Except<ExperienceFragmentProps, 'sys'> & {
    component: ResourceLink<'Contentful:Component'>;
};

type CreateExperienceProps

type CreateExperienceProps = ExperienceCommonProps & {
    experienceTemplate: ResourceLink<'Contentful:ExperienceTemplate'>;
};

type CreateExperienceTemplateProps

type CreateExperienceTemplateProps = Except<ExperienceTemplateProps, 'sys'>;

type CreateFragmentProps

type CreateFragmentProps = Except<FragmentProps, 'sys'> & {
    componentType: ResourceLink<'Contentful:ComponentType'>;
};

Deprecated
Use CreateExperienceFragmentProps (see ./experience-fragment) instead. The Fragment entity is superseded by the ExperienceFragment entity.

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 CreateTemplateProps

type CreateTemplateProps = Except<TemplateProps, 'sys'>;

Deprecated
Use CreateExperienceTemplateProps (see ./experience-template) instead. The Template entity is superseded by the ExperienceTemplate entity.

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 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 CursorPaginationParams

type CursorPaginationParams =
    | CursorPaginationPageNext
    | CursorPaginationPagePrev
    | CursorPaginationNone;

type DataAssemblyCollection

type DataAssemblyCollection = ExoCursorPaginatedCollectionProp<DataAssemblyProps> & {
    errors?: {
        notFoundIds: string[];
    };
};

type DataAssemblyProps

type DataAssemblyProps = DataAssemblyCommonProps & {
    sys: DataAssemblySys;
};

type DataAssemblyResourceLinkParameter

type DataAssemblyResourceLinkParameter = {
    name?: string;
    description?: string;
    type: 'ResourceLink';
    linkType: 'Contentful:Entry';
    allowedResources: Array<{
        type: 'Contentful:Entry';
        source: typeof SAME_SPACE_CONTENT_SOURCE;
        allowedTypes: string[];
    }>;
};

type DataTypeDefinition

type DataTypeDefinition =
    | PrimitiveDataTypeDefinition
    | RichTextDataTypeDefinition
    | ArrayDataTypeDefinition
    | RecordDataTypeDefinition
    | TypeRefDataTypeDefinition
    | LiteralDataTypeDefinition
    | DiscriminatedUnionDataTypeDefinition;

type DefinedParameters

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

type DeleteCommentParams

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

type DeleteWorkflowDefinitionParams

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

type DeleteWorkflowParams

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

type DesignTokenCollection

type DesignTokenCollection = ExoCursorPaginatedCollectionProp<DesignTokenProps>;

type DesignTokenProps

type DesignTokenProps = {
    sys: DesignTokenSys;
    name: string;
    type: DesignTokenType;
    metadata?: ExoMetadataProps;
};

type DiscriminatedUnionDataTypeDefinition

type DiscriminatedUnionDataTypeDefinition = BaseDataTypeDefinition & {
    type: 'DiscriminatedUnion';
    discriminator: string;
    members: DataTypeDefinition[];
};

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, S = unknown> = {
    sys: EntryMetaSysProps & S;
    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 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 ExperienceCollection

type ExperienceCollection = ExoCursorPaginatedCollectionProp<ExperienceProps>;

type ExperienceContentBindings

type ExperienceContentBindings = {
    sys: ResourceLink<'Contentful:DataAssembly'>['sys'];
    parameters: Record<string, ResourceLink<string>>;
};

type ExperienceFragmentCollection

type ExperienceFragmentCollection =
    ExoCursorPaginatedCollectionProp<ExperienceFragmentProps>;

type ExperienceFragmentNode

type ExperienceFragmentNode = {
    id: string;
    name?: string;
    nodeType: 'ExperienceFragment';
    experienceFragment: ResourceLink<'Contentful:ExperienceFragment'>;
};

type ExperienceFragmentProps

type ExperienceFragmentProps = {
    sys: ExperienceFragmentSys;
    name: string;
    description: string;
    viewports: ComponentTypeViewport[];
    designProperties: Record<string, DimensionedDesignPropertyValue>;
    contentBindings?: ExperienceContentBindings;
    metadata?: ExperienceMetadataProps;
    slots?: Record<
        string,
        Array<ExperienceFragmentNode | InlineExperienceFragmentNode>
    >;
};

type ExperienceProps

type ExperienceProps = ExperienceCommonProps & {
    sys: ExperienceSys;
};

type ExperienceTemplateCollection

type ExperienceTemplateCollection =
    ExoCursorPaginatedCollectionProp<ExperienceTemplateProps>;

type ExperienceTemplateProps

type ExperienceTemplateProps = {
    sys: ExperienceTemplateSys;
    name: string;
    description: string;
    viewports: ComponentTypeViewport[];
    contentProperties: ComponentTypeContentProperty[];
    designProperties: ComponentTypeDesignProperty[];
    componentTree?: TreeNodeV2[];
    slots?: ComponentSlotDefinition[];
    metadata?: ExoMetadataProps;
    dataAssemblies?: DataAssemblyLink[];
};

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 FragmentCollection

type FragmentCollection = ExoCursorPaginatedCollectionProp<FragmentProps>;

Deprecated
Use ExperienceFragmentCollection (see ./experience-fragment) instead. The Fragment entity is superseded by the ExperienceFragment entity.

type FragmentNode

type FragmentNode = {
    id: string;
    name?: string;
    nodeType: 'Fragment';
    fragment: ResourceLink<'Contentful:Fragment'>;
};

Deprecated
Use ExperienceFragmentNode instead. ExperienceFragmentNode uses the renamed experienceFragment link (Contentful:ExperienceFragment).

type FragmentProps

type FragmentProps = {
    sys: FragmentSys;
    name: string;
    description: string;
    viewports: ComponentTypeViewport[];
    designProperties: Record<string, DimensionedDesignPropertyValue>;
    contentBindings?: ExperienceContentBindings;
    metadata?: ExperienceMetadataProps;
    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
};

Deprecated
Use ExperienceFragmentProps (see ./experience-fragment) instead. The Fragment entity is superseded by the ExperienceFragment entity.

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 GetCommentParentEntityParams

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

type GetContentSemanticsIndexParams

type GetContentSemanticsIndexParams = GetOrganizationParams & {
    indexId: string;
};

type GetManyCommentsParams

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

type GetManyContentSemanticsIndexForEnvironmentParams

type GetManyContentSemanticsIndexForEnvironmentParams = GetSpaceEnvironmentParams & {
    status?: string;
};

type GetManyContentSemanticsIndexParams

type GetManyContentSemanticsIndexParams = GetOrganizationParams & {
    status?: string;
};

type Hint

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

type IconType

type IconType = 'base64';

type InlineExperienceFragmentNode

type InlineExperienceFragmentNode = {
    id: string;
    nodeType: 'InlineExperienceFragment';
    component: ResourceLink<'Contentful:Component'>;
    designProperties: Record<string, DimensionedDesignPropertyValue>;
    contentBindings?: ExperienceContentBindings;
    slots?: Record<
        string,
        Array<ExperienceFragmentNode | InlineExperienceFragmentNode>
    >;
};

type InlineFragmentNode

type InlineFragmentNode = {
    id: string;
    nodeType: 'InlineFragment';
    componentType: ResourceLink<'Contentful:ComponentType'>;
    designProperties: Record<string, DimensionedDesignPropertyValue>;
    contentBindings?: ExperienceContentBindings;
    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
};

Deprecated
Use InlineExperienceFragmentNode (see ./experience) instead. The Fragment entity is superseded by the ExperienceFragment entity.

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 JsonValue

type JsonValue =
    | string
    | number
    | boolean
    | null
    | JsonValue[]
    | {
          [key: string]: JsonValue;
      };

type KeyValueMap

type KeyValueMap = Record<string, any>;

type LiteralDataTypeDefinition

type LiteralDataTypeDefinition = BaseDataTypeDefinition & {
    type: 'Literal';
    value: JsonValue;
    valueType: DataTypeDefinition;
};

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 OAuthApplicationProps

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

type OpPatch

type OpPatch =
    | AddPatch
    | RemovePatch
    | ReplacePatch
    | MovePatch
    | CopyPatch
    | TestPatch;

type OptionalDefaults

type OptionalDefaults<T> = UnionOmit<T, keyof PlainClientDefaultParams> &
    Partial<Pick<T, Extract<keyof T, keyof PlainClientDefaultParams>>>;

Makes PlainClientDefaultParams fields optional in API method parameter types. When default params (spaceId, environmentId, etc.) are set on the plain client, those fields become optional in individual method calls.

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;
    /**
     * Default language used in the interface and email communications.
     * Users can override this setting in their profile settings.
     * If not set, the default value is `en-US`.
     */
    defaultUserLanguage: string;
};

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(): PlainClientDefaultParams | 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;
    agent: AgentPlainClientAPI;
    agentRun: AgentRunPlainClientAPI;
    automationDefinition: AutomationDefinitionPlainClientAPI;
    automationExecution: AutomationExecutionPlainClientAPI;
    appAction: AppActionPlainClientAPI;
    appActionCall: AppActionCallPlainClientAPI;
    appBundle: AppBundlePlainClientAPI;
    appDetails: AppDetailsPlainClientAPI;
    appEventSubscription: AppEventSubscriptionPlainClientAPI;
    appKey: AppKeyPlainClientAPI;
    appSignedRequest: AppSignedRequestPlainClientAPI;
    appSigningSecret: AppSigningSecretPlainClientAPI;
    appAccessToken: AppAccessTokenPlainClientAPI;
    function: FunctionPlainClientAPI;
    functionLog: FunctionLogPlainClientAPI;
    editorInterface: EditorInterfacePlainClientAPI;
    space: SpacePlainClientAPI;
    environment: EnvironmentPlainClientAPI;
    environmentAlias: EnvironmentAliasPlainClientAPI;
    environmentTemplate: {
        get(
            params: GetEnvironmentTemplateParams & {
                version?: number;
                query?: {
                    select?: string;
                };
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        getMany(
            params: GetOrganizationParams & {
                query?: BasicCursorPaginationOptions & {
                    select?: string;
                    forTemplatedSpaces?: boolean;
                };
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        create(
            params: GetOrganizationParams,
            rawData: CreateEnvironmentTemplateProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        versionUpdate(
            params: GetEnvironmentTemplateParams & {
                version: number;
            },
            rawData: {
                versionName?: string;
                versionDescription?: string;
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        update(
            params: GetEnvironmentTemplateParams,
            rawData: EnvironmentTemplateProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateProps>;
        delete(
            params: GetEnvironmentTemplateParams,
            headers?: RawAxiosRequestHeaders
        ): Promise<void>;
        versions(
            params: GetEnvironmentTemplateParams & {
                query?: BasicCursorPaginationOptions & {
                    select?: string;
                    installable?: boolean;
                };
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<EnvironmentTemplateProps>>;
        validate(
            params: EnvironmentTemplateParams & {
                version?: number;
            },
            rawData: ValidateEnvironmentTemplateInstallationProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateValidationProps>;
        install(
            params: EnvironmentTemplateParams,
            rawData: CreateEnvironmentTemplateInstallationProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<EnvironmentTemplateInstallationProps>;
        disconnect(
            params: EnvironmentTemplateParams,
            headers?: RawAxiosRequestHeaders
        ): Promise<void>;
    };
    environmentTemplateInstallation: {
        getMany(
            params: BasicCursorPaginationOptions & {
                environmentId?: string;
                environmentTemplateId: string;
                organizationId: string;
                spaceId?: string;
                latestOnly?: boolean;
            },
            headers?: RawAxiosRequestHeaders
        ): Promise<
            CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>
        >;
        getForEnvironment(
            params: BasicCursorPaginationOptions &
                EnvironmentTemplateParams & {
                    installationId?: string;
                },
            headers?: RawAxiosRequestHeaders
        ): Promise<
            CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>
        >;
    };
    bulkAction: {
        get<T extends BulkActionPayload = any>(
            params: GetBulkActionParams
        ): Promise<BulkActionProps<T>>;
        publish(
            params: GetSpaceEnvironmentParams,
            payload: BulkActionPublishPayload
        ): Promise<BulkActionProps<BulkActionPublishPayload>>;
        unpublish(
            params: GetSpaceEnvironmentParams,
            payload: BulkActionUnpublishPayload
        ): Promise<BulkActionProps<BulkActionUnpublishPayload>>;
        validate(
            params: GetSpaceEnvironmentParams,
            payload: BulkActionValidatePayload
        ): Promise<BulkActionProps<BulkActionValidatePayload>>;
        getV2(
            params: GetBulkActionParams
        ): Promise<BulkActionProps<BulkActionV2Payload>>;
        publishV2(
            params: GetSpaceEnvironmentParams,
            payload: PublishBulkActionV2Payload<'add'>
        ): Promise<BulkActionProps<PublishBulkActionV2Payload<'add'>>>;
        unpublishV2(
            params: GetSpaceEnvironmentParams,
            payload:
                | PublishBulkActionV2Payload<'remove'>
                | UnpublishBulkActionV2Payload
        ): Promise<
            BulkActionProps<
                PublishBulkActionV2Payload<'remove'> | UnpublishBulkActionV2Payload
            >
        >;
        validateV2(
            params: GetSpaceEnvironmentParams,
            payload:
                | ValidateBulkActionV2Payload<'add'>
                | ValidateBulkActionV2Payload<'remove'>
        ): Promise<
            BulkActionProps<
                | ValidateBulkActionV2Payload<'add'>
                | ValidateBulkActionV2Payload<'remove'>
            >
        >;
    };
    comment: CommentPlainClientAPI;
    /** @deprecated Use `component` instead. The `componentType` endpoint is superseded by `component`. */
    componentType: ComponentTypePlainClientAPI;
    component: ComponentPlainClientAPI;
    dataAssembly: DataAssemblyPlainClientAPI;
    designToken: DesignTokenPlainClientAPI;
    concept: ConceptPlainClientAPI;
    conceptScheme: ConceptSchemePlainClientAPI;
    contentType: {
        get(
            params: OptionalDefaults<GetContentTypeParams & QueryParams>
        ): Promise<ContentTypeProps>;
        getMany(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>
        ): Promise<CollectionProp<ContentTypeProps>>;
        getManyWithCursor(
            params: OptionalDefaults<GetSpaceEnvironmentParams & CursorBasedParams>
        ): Promise<CursorPaginatedCollectionProp<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>>>;
        getPublishedWithCursor<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<GetSpaceEnvironmentParams & CursorBasedParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<EntryProps<T>>>;
        getMany<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams &
                    QueryParams & {
                        releaseId?: string;
                    }
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<EntryProps<T>>>;
        getManyWithCursor<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams &
                    CursorBasedParams & {
                        releaseId?: string;
                    }
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<EntryProps<T>>>;
        get<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    releaseId?: string;
                }
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<EntryProps<T>>;
        update<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    releaseId?: string;
                }
            >,
            rawData: EntryProps<T>,
            headers?: RawAxiosRequestHeaders
        ): Promise<EntryProps<T>>;
        patch<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    version: number;
                    releaseId?: string;
                }
            >,
            rawData: OpPatch[],
            headers?: RawAxiosRequestHeaders
        ): Promise<EntryProps<T>>;
        delete(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >
        ): Promise<any>;
        publish<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    locales?: string[];
                }
            >,
            rawData: EntryProps<T>
        ): Promise<EntryProps<T>>;
        unpublish<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    locales?: string[];
                }
            >,
            rawData?: EntryProps<T>
        ): Promise<EntryProps<T>>;
        archive<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >
        ): Promise<EntryProps<T>>;
        unarchive<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                }
            >
        ): Promise<EntryProps<T>>;
        create<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    contentTypeId: string;
                    releaseId?: string;
                }
            >,
            rawData: CreateEntryProps<T>
        ): Promise<EntryProps<T>>;
        createWithId<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    contentTypeId: string;
                    releaseId?: string;
                }
            >,
            rawData: CreateEntryProps<T>
        ): Promise<EntryProps<T>>;
        references(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    entryId: string;
                    include?: number;
                }
            >
        ): Promise<EntryReferenceProps>;
    };
    asset: {
        getPublished(
            params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<AssetProps>>;
        getPublishedWithCursor(
            params: OptionalDefaults<GetSpaceEnvironmentParams & CursorBasedParams>,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<AssetProps>>;
        getMany(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams &
                    QueryParams & {
                        releaseId?: string;
                    }
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CollectionProp<AssetProps>>;
        getManyWithCursor(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams &
                    CursorBasedParams & {
                        releaseId?: string;
                    }
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<CursorPaginatedCollectionProp<AssetProps>>;
        get(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    releaseId?: string;
                } & QueryParams
            >,
            rawData?: unknown,
            headers?: RawAxiosRequestHeaders
        ): Promise<AssetProps>;
        update(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    releaseId?: string;
                }
            >,
            rawData: AssetProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<AssetProps>;
        delete(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >
        ): Promise<any>;
        publish(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    locales?: string[];
                }
            >,
            rawData: AssetProps
        ): Promise<AssetProps>;
        unpublish(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    locales?: string[];
                }
            >,
            rawData?: AssetProps
        ): Promise<AssetProps>;
        archive(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >
        ): Promise<AssetProps>;
        unarchive(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                }
            >
        ): Promise<AssetProps>;
        create(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    releaseId?: string;
                }
            >,
            rawData: CreateAssetProps
        ): Promise<AssetProps>;
        createWithId(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    assetId: string;
                    releaseId?: string;
                }
            >,
            rawData: CreateAssetProps
        ): Promise<AssetProps>;
        createFromFiles(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    releaseId?: string;
                }
            >,
            data: Omit<AssetFileProp, 'sys'>
        ): Promise<AssetProps>;
        processForAllLocales(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    releaseId?: string;
                }
            >,
            asset: AssetProps,
            processingOptions?: AssetProcessingForLocale
        ): Promise<AssetProps>;
        processForLocale(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    releaseId?: string;
                }
            >,
            asset: AssetProps,
            locale: string,
            processingOptions?: AssetProcessingForLocale
        ): Promise<AssetProps>;
    };
    appUpload: AppUploadPlainClientAPI;
    assetKey: {
        create(
            params: OptionalDefaults<GetSpaceEnvironmentParams>,
            data: CreateAssetKeyProps
        ): Promise<AssetKeyProps>;
    };
    upload: UploadPlainClientAPI;
    uploadCredential: UploadCredentialAPI;
    locale: LocalePlainClientAPI;
    personalAccessToken: {
        get(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<PersonalAccessTokenProps>;
        getMany(
            params: OptionalDefaults<QueryParams>
        ): Promise<CollectionProp<PersonalAccessTokenProps>>;
        create(
            rawData: CreatePersonalAccessTokenProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<PersonalAccessTokenProps>;
        revoke(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<PersonalAccessTokenProps>;
    };
    accessToken: {
        get(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<AccessTokenProps>;
        getMany(
            params: OptionalDefaults<QueryParams>
        ): Promise<CollectionProp<AccessTokenProps>>;
        createPersonalAccessToken(
            rawData: CreatePATProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<AccessTokenProps>;
        revoke(
            params: OptionalDefaults<{
                tokenId: string;
            }>
        ): Promise<AccessTokenProps>;
        getManyForOrganization(
            params: OptionalDefaults<GetOrganizationParams & QueryParams>
        ): Promise<CollectionProp<AccessTokenProps>>;
    };
    usage: UsagePlainClientAPI;
    release: {
        asset: {
            get(
                params: OptionalDefaults<GetReleaseAssetParams & QueryParams>,
                rawData?: unknown,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
            getMany(
                params: OptionalDefaults<GetManyReleaseAssetParams & QueryParams>,
                rawData?: unknown,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                CollectionProp<
                    AssetProps<{
                        release: Link<'Release'>;
                    }>
                >
            >;
            update(
                params: OptionalDefaults<UpdateReleaseAssetParams & QueryParams>,
                rawData: AssetProps,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
            create(
                params: OptionalDefaults<CreateReleaseAssetParams & QueryParams>,
                rawData: CreateAssetProps,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
            createWithId(
                params: OptionalDefaults<
                    CreateWithIdReleaseAssetParams & QueryParams
                >,
                rawData: CreateAssetProps,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
            createFromFiles(
                params: OptionalDefaults<
                    CreateWithFilesReleaseAssetParams & QueryParams
                >,
                data: Omit<AssetFileProp, 'sys'>,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
            processForLocale(
                params: OptionalDefaults<GetSpaceEnvironmentParams>,
                asset: AssetProps<{
                    release: Link<'Release'>;
                }>,
                locale: string,
                processingOptions?: AssetProcessingForLocale
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
            processForAllLocales(
                params: OptionalDefaults<GetSpaceEnvironmentParams>,
                asset: AssetProps<{
                    release: Link<'Release'>;
                }>,
                processingOptions?: AssetProcessingForLocale
            ): Promise<
                AssetProps<{
                    release: Link<'Release'>;
                }>
            >;
        };
        entry: {
            get<T extends KeyValueMap = KeyValueMap>(
                params: OptionalDefaults<GetReleaseEntryParams & QueryParams>,
                rawData?: unknown,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                EntryProps<
                    T,
                    {
                        release: Link<'Release'>;
                    }
                >
            >;
            getMany<T extends KeyValueMap = KeyValueMap>(
                params: OptionalDefaults<GetManyReleaseEntryParams & QueryParams>,
                rawData?: unknown,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                CollectionProp<
                    EntryProps<
                        T,
                        {
                            release: Link<'Release'>;
                        }
                    >
                >
            >;
            update<T extends KeyValueMap = KeyValueMap>(
                params: OptionalDefaults<UpdateReleaseEntryParams & QueryParams>,
                rawData: EntryProps<T>,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                EntryProps<
                    T,
                    {
                        release: Link<'Release'>;
                    }
                >
            >;
            patch<T extends KeyValueMap = KeyValueMap>(
                params: OptionalDefaults<PatchReleaseEntryParams & QueryParams>,
                rawData: OpPatch[],
                headers?: RawAxiosRequestHeaders
            ): Promise<
                EntryProps<
                    T,
                    {
                        release: Link<'Release'>;
                    }
                >
            >;
            create<T extends KeyValueMap = KeyValueMap>(
                params: OptionalDefaults<CreateReleaseEntryParams & QueryParams>,
                rawData: CreateEntryProps<T>,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                EntryProps<
                    T,
                    {
                        release: Link<'Release'>;
                    }
                >
            >;
            createWithId<T extends KeyValueMap = KeyValueMap>(
                params: OptionalDefaults<
                    CreateWithIdReleaseEntryParams & QueryParams
                >,
                rawData: CreateEntryProps<T>,
                headers?: RawAxiosRequestHeaders
            ): Promise<
                EntryProps<
                    T,
                    {
                        release: Link<'Release'>;
                    }
                >
            >;
        };
        archive(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseProps>;
        get(params: OptionalDefaults<GetReleaseParams>): Promise<ReleaseProps>;
        query(
            params: OptionalDefaults<ReleaseEnvironmentParams> & {
                query?: ReleaseQueryOptions;
            }
        ): Promise<CursorPaginatedCollectionProp<ReleaseProps>>;
        create(
            params: OptionalDefaults<ReleaseEnvironmentParams>,
            data: ReleasePayload | ReleasePayloadV2
        ): Promise<ReleaseProps>;
        update(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >,
            data: ReleasePayload | ReleasePayloadV2
        ): Promise<ReleaseProps>;
        delete(params: OptionalDefaults<GetReleaseParams>): Promise<void>;
        publish(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseActionProps<'publish'>>;
        unarchive(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseProps>;
        unpublish(
            params: OptionalDefaults<
                GetReleaseParams & {
                    version: number;
                }
            >
        ): Promise<ReleaseActionProps<'unpublish'>>;
        validate(
            params: OptionalDefaults<GetReleaseParams>,
            data?: ReleaseValidatePayload
        ): Promise<ReleaseActionProps<'validate'>>;
    };
    releaseAction: {
        get(
            params: OptionalDefaults<GetReleaseParams> & {
                actionId: string;
            }
        ): Promise<ReleaseActionProps>;
        getMany(
            params: OptionalDefaults<GetSpaceEnvironmentParams> & {
                query?: ReleaseActionQueryOptions;
            }
        ): Promise<CollectionProp<ReleaseActionProps>>;
        queryForRelease(
            params: OptionalDefaults<GetReleaseParams> & {
                query?: ReleaseActionQueryOptions;
            }
        ): Promise<CollectionProp<ReleaseActionProps>>;
    };
    resource: ResourcePlainAPI;
    resourceProvider: ResourceProviderPlainClientAPI;
    resourceType: ResourceTypePlainClientAPI;
    role: RolePlainClientAPI;
    scheduledActions: {
        get(
            params: OptionalDefaults<GetSpaceParams> & {
                scheduledActionId: string;
                environmentId: string;
            }
        ): Promise<ScheduledActionProps>;
        getMany(
            params: OptionalDefaults<GetSpaceParams & QueryParams>
        ): Promise<CursorPaginatedCollectionProp<ScheduledActionProps>>;
        create(
            params: OptionalDefaults<GetSpaceParams>,
            data: CreateUpdateScheduledActionProps
        ): Promise<ScheduledActionProps>;
        delete(
            params: OptionalDefaults<
                GetSpaceEnvironmentParams & {
                    scheduledActionId: string;
                }
            >
        ): Promise<ScheduledActionProps>;
        update(
            params: OptionalDefaults<
                GetSpaceParams & {
                    scheduledActionId: string;
                    version: number;
                }
            >,
            data: CreateUpdateScheduledActionProps
        ): Promise<ScheduledActionProps>;
    };
    previewApiKey: {
        get(
            params: OptionalDefaults<
                GetSpaceParams & {
                    previewApiKeyId: string;
                }
            >
        ): Promise<PreviewApiKeyProps>;
        getMany(
            params: OptionalDefaults<GetSpaceParams & QueryParams>
        ): Promise<CollectionProp<PreviewApiKeyProps>>;
    };
    apiKey: {
        get(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >
        ): Promise<ApiKeyProps>;
        getMany(
            params: OptionalDefaults<GetSpaceParams & QueryParams>
        ): Promise<CollectionProp<ApiKeyProps>>;
        create(
            params: OptionalDefaults<GetSpaceParams>,
            data: CreateApiKeyProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ApiKeyProps>;
        createWithId(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >,
            data: CreateApiKeyProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ApiKeyProps>;
        update(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >,
            rawData: ApiKeyProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<ApiKeyProps>;
        delete(
            params: OptionalDefaults<
                GetSpaceParams & {
                    apiKeyId: string;
                }
            >
        ): Promise<any>;
    };
    appDefinition: AppDefinitionPlainClientAPI;
    appInstallation: AppInstallationPlainClientAPI;
    extension: ExtensionPlainClientAPI;
    webhook: WebhookPlainClientAPI;
    snapshot: {
        getManyForEntry<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<GetSnapshotForEntryParams & QueryParams>
        ): Promise<CollectionProp<SnapshotProps<Omit<EntryProps<T>, 'metadata'>>>>;
        getForEntry<T extends KeyValueMap = KeyValueMap>(
            params: OptionalDefaults<
                GetSnapshotForEntryParams & {
                    snapshotId: string;
                }
            >
        ): Promise<SnapshotProps<Omit<EntryProps<T>, 'metadata'>>>;
        getManyForContentType(
            params: OptionalDefaults<GetSnapshotForContentTypeParams & QueryParams>
        ): Promise<CollectionProp<SnapshotProps<ContentTypeProps>>>;
        getForContentType(
            params: OptionalDefaults<
                GetSnapshotForContentTypeParams & {
                    snapshotId: string;
                }
            >
        ): Promise<SnapshotProps<ContentTypeProps>>;
    };
    tag: TagPlainClientAPI;
    organization: OrganizationPlainClientAPI;
    organizationInvitation: {
        get(
            params: OptionalDefaults<{
                organizationId: string;
                invitationId: string;
            }>,
            headers?: RawAxiosRequestHeaders
        ): Promise<OrganizationInvitationProps>;
        create(
            params: OptionalDefaults<{
                organizationId: string;
            }>,
            data: CreateOrganizationInvitationProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<OrganizationInvitationProps>;
    };
    organizationMembership: {
        get(
            params: OptionalDefaults<GetOrganizationMembershipParams>
        ): Promise<OrganizationMembershipProps>;
        getMany(
            params: OptionalDefaults<GetOrganizationParams & QueryParams>
        ): Promise<CollectionProp<OrganizationMembershipProps>>;
        update(
            params: OptionalDefaults<GetOrganizationMembershipParams>,
            rawData: OrganizationMembershipProps,
            headers?: RawAxiosRequestHeaders
        ): Promise<OrganizationMembershipProps>;
        delete(
            params: OptionalDefaults<GetOrganizationMembershipParams>
        ): Promise<any>;
    };
    spaceMember: SpaceMemberPlainClientAPI;
    spaceMembership: SpaceMembershipPlainClientAPI;
    task: TaskPlainClientAPI;
    team: TeamPlainClientAPI;
    teamMembership: TeamMembershipPlainClientAPI;
    teamSpaceMembership: TeamSpaceMembershipPlainClientAPI;
    /** @deprecated Use `experienceFragment` instead. The `fragment` endpoint is superseded by `experienceFragment`. */
    fragment: FragmentPlainClientAPI;
    /** @deprecated Use `experienceTemplate` instead. The `template` endpoint is superseded by `experienceTemplate`. */
    template: TemplatePlainClientAPI;
    uiConfig: UIConfigPlainClientAPI;
    userUIConfig: UserUIConfigPlainClientAPI;
    workflowDefinition: WorkflowDefinitionPlainClientAPI;
    workflow: WorkflowPlainClientAPI;
    workflowsChangelog: WorkflowsChangelogPlainClientAPI;
    oauthApplication: OAuthApplicationPlainClientAPI;
    experience: ExperiencePlainClientAPI;
    experienceFragment: ExperienceFragmentPlainClientAPI;
    experienceTemplate: ExperienceTemplatePlainClientAPI;
    semanticSearch: SemanticSearchPlainClientAPI;
    semanticDuplicates: SemanticDuplicatesPlainClientAPI;
    semanticRecommendations: SemanticRecommendationsPlainClientAPI;
    semanticReferenceSuggestions: SemanticReferenceSuggestionsPlainClientAPI;
    semanticSettings: SemanticSettingsPlainClientAPI;
    contentSemanticsIndex: ContentSemanticsIndexPlainClientAPI;
};

type PlainClientDefaultParams

type PlainClientDefaultParams = {
    spaceId?: string;
    environmentId?: string;
    organizationId?: string;
    releaseSchemaVersion?: 'Release.v1' | 'Release.v2';
    releaseId?: string;
};

type PointerExpressionValue

type PointerExpressionValue =
    | string
    | {
          $from:
              | string
              | {
                    source: string;
                    select?: PointerExpressionValue;
                };
      }
    | {
          $literal: JsonValue;
      }
    | {
          $object: Record<string, PointerExpressionValue>;
      }
    | {
          $on: {
              type: Record<string, PointerExpressionValue>;
              default?: PointerExpressionValue;
          };
      }
    | {
          [key: string]: PointerExpressionValue;
      };

type PreviewApiKeyProps

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

type PrimitiveDataTypeDefinition

type PrimitiveDataTypeDefinition = BaseDataTypeDefinition & {
    type: PrimitiveDataTypeName;
};

type PrimitiveDataTypeName

type PrimitiveDataTypeName = 'String' | 'Number' | 'Integer' | 'Boolean';

type RecordDataTypeDefinition

type RecordDataTypeDefinition = BaseDataTypeDefinition & {
    type: 'Record';
    fields: Record<string, DataTypeDefinition>;
};

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 ReleaseExperience

type ReleaseExperience = Omit<ExperienceProps, 'sys'> & {
    sys: ReleaseExperienceSys;
};

type ReleaseExperienceCollection

type ReleaseExperienceCollection =
    ExoCursorPaginatedCollectionProp<ReleaseExperience>;

type ReleaseExperienceSys

type ReleaseExperienceSys = Omit<
    ExperienceSys,
    'variant' | 'variantType' | 'variantDimension'
> & {
    release: Link<'Release'>;
};

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'>;
    schemaVersion?: 'Release.v2';
};

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 RichTextDataTypeDefinition

type RichTextDataTypeDefinition = BaseDataTypeDefinition & {
    type: 'RichText';
};

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 SemanticDuplicatesProps

type SemanticDuplicatesProps = {
    sys: {
        type: 'Array';
        correlationId?: string;
    };
    items: SemanticDuplicatesResult[];
};

type SemanticRecommendationsProps

type SemanticRecommendationsProps = {
    sys: {
        type: 'Array';
        correlationId?: string;
    };
    items: SemanticRecommendationsResult[];
};

type SemanticReferenceSuggestionsProps

type SemanticReferenceSuggestionsProps = {
    sys: {
        type: 'Array';
        correlationId?: string;
    };
    items: SemanticReferenceSuggestionsResult[];
};

type SemanticSearchProps

type SemanticSearchProps = {
    sys: {
        type: 'Array';
        correlationId?: string;
    };
    items: SemanticSearchResult[];
};

type SlotNode

type SlotNode = {
    id: string;
    nodeType: 'Slot';
    slotId: string;
};

type SnapshotProps

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

type Space

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

type SpaceAddOnOrganizationProps

type SpaceAddOnOrganizationProps = {
    sys: BasicMetaSysProps & {
        organization: SysLink;
    };
    name: string;
    used: number;
    allocated: number;
};

type SpaceAddOnProps

type SpaceAddOnProps = {
    sys: BasicMetaSysProps & {
        organization: SysLink;
        space: SysLink;
    };
    name: string;
    used: number;
    allocated: number;
};

type SpaceAddOnType

type SpaceAddOnType = 'contentTypes' | 'environments' | 'records';

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: SysLink;
        relatedMemberships: SysLink[];
    };
    /**
     * User is an admin
     */
    admin: boolean;
    /**
     * Array of Role Links
     */
    roles: SysLink[];
};

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;
        license?: {
            sys: {
                type: 'Link';
                linkType: 'SpaceLicense';
                id: string;
            };
        };
    };
    name: string;
};

type TagProps

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

type TagSysProps

type TagSysProps = Pick<
    MetaSysProps,
    'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'
> & {
    type: 'Tag';
    visibility: TagVisibility;
    space: SysLink;
    environment: SysLink;
};

type TagVisibility

type TagVisibility = 'private' | 'public';

type TaskParentEntityPath

type TaskParentEntityPath =
    | 'entries'
    | 'experiences'
    | 'experience_fragments'
    | 'experience_templates'
    | 'components';

type TaskParentEntityType

type TaskParentEntityType =
    | 'Entry'
    | 'Experience'
    | 'ExperienceFragment'
    | 'ExperienceTemplate'
    | 'Component';

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 TemplateCollection

type TemplateCollection = ExoCursorPaginatedCollectionProp<TemplateProps>;

Deprecated
Use ExperienceTemplateCollection (see ./experience-template) instead. The Template entity is superseded by the ExperienceTemplate entity.

type TemplateProps

type TemplateProps = {
    sys: TemplateSys;
    name: string;
    description: string;
    viewports: ComponentTypeViewport[];
    contentProperties: ComponentTypeContentProperty[];
    designProperties: ComponentTypeDesignProperty[];
    componentTree?: TreeNode[];
    slots?: ComponentTypeSlotDefinition[];
    metadata?: ExoMetadataProps;
    dataAssemblies?: DataAssemblyLink[];
};

Deprecated
Use ExperienceTemplateProps (see ./experience-template) instead. The Template entity is superseded by the ExperienceTemplate entity.

type TreeNode

type TreeNode = ComponentNode | FragmentNode | SlotNode;

Deprecated
Use TreeNodeV2 instead.

type TreeNodeV2

type TreeNodeV2 = ComponentNodeV2 | ExperienceFragmentNode | SlotNode;

Renamed form of TreeNode used in ExperienceTemplate component trees (post-migration).
This will be renamed to TreeNode in the future, but during the migration, we need to support both.

type TypeRefDataTypeDefinition

type TypeRefDataTypeDefinition = BaseDataTypeDefinition & {
    type: 'TypeRef';
    ref: ResourceLink<string>;
};

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 UpdateDataAssemblyProps

type UpdateDataAssemblyProps = DataAssemblyCommonProps & {
    sys: {
        id: string;
        type: 'DataAssembly';
        variant?: string;
        version: number;
        dataType: DataAssemblyDataTypeField[];
    };
};

type UpdateSpaceAddOnAllocationProps

type UpdateSpaceAddOnAllocationProps = {
    add_on: SpaceAddOnType;
    allocation: 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 UpsertComponentProps

type UpsertComponentProps = Except<ComponentProps, 'sys'> & {
    sys: {
        id: string;
        type: 'Component';
        version?: number;
    };
};

type UpsertComponentTypeProps

type UpsertComponentTypeProps = Except<ComponentTypeProps, 'sys' | 'source'> & {
    sys: {
        id: string;
        type: 'ComponentType';
        version?: number;
    };
    source?: ResourceLink<'Contentful:DesignSystemSource'> | null;
};

Deprecated
Use UpsertComponentProps (see ./component) instead. The ComponentType entity is superseded by the Component entity.

type UpsertDesignTokenProps

type UpsertDesignTokenProps = Except<DesignTokenProps, 'sys'> & {
    sys: {
        id: string;
        type: 'DesignToken';
        version?: number;
    };
};

type UpsertExperienceFragmentProps

type UpsertExperienceFragmentProps = Omit<ExperienceFragmentProps, 'sys'> & {
    sys: {
        id: string;
        type: 'ExperienceFragment';
        version?: number;
    };
    component?: ResourceLink<'Contentful:Component'>;
};

type UpsertExperienceProps

type UpsertExperienceProps = ExperienceCommonProps & {
    sys: {
        id: string;
        type: 'Experience';
        version?: number;
    };
    experienceTemplate?: ResourceLink<'Contentful:ExperienceTemplate'>;
};

type UpsertExperienceTemplateProps

type UpsertExperienceTemplateProps = Except<ExperienceTemplateProps, 'sys'> & {
    sys: {
        id: string;
        type: 'ExperienceTemplate';
        version?: number;
    };
};

type UpsertFragmentProps

type UpsertFragmentProps = Omit<FragmentProps, 'sys'> & {
    sys: {
        id: string;
        type: 'Fragment';
        version?: number;
    };
    componentType?: ResourceLink<'Contentful:ComponentType'>;
};

Deprecated
Use UpsertExperienceFragmentProps (see ./experience-fragment) instead. The Fragment entity is superseded by the ExperienceFragment entity.

type UpsertResourceProviderProps

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

type UpsertResourceTypeProps

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

type UpsertTemplateProps

type UpsertTemplateProps = Except<TemplateProps, 'sys'> & {
    sys: {
        id: string;
        type: 'Template';
        version?: number;
    };
};

Deprecated
Use UpsertExperienceTemplateProps (see ./experience-template) instead. The Template entity is superseded by the ExperienceTemplate entity.

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;
    /**
     * Language used in the interface and email communications.
     * Overrides the organization default language.
     */
    preferredLanguage: string | null;
};

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 WebhookCallDetailsProps

type WebhookCallDetailsProps = {
    /**
     * System metadata
     */
    sys: WebhookCallDetailsSys;
    /**
     * Request object
     */
    request: WebhookCallRequest;
    /**
     * Request object
     */
    response: WebhookCallResponse;
    /**
     * Status code of the request
     */
    statusCode: number;
    /**
     * Errors
     */
    errors: any[];
    /**
     * Type of the webhook
     */
    eventType: string;
    /**
     * Url of the request
     */
    url: string;
    /**
     * Timestamp of the request
     */
    requestAt: string;
    /**
     * Timestamp of the response
     */
    responseAt: string;
};

type WebhookCallOverviewProps

type WebhookCallOverviewProps = Except<
    WebhookCallDetailsProps,
    'request' | 'response'
>;

type WebhookCallRequest

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

type WebhookFilter

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

type WebhookHealthProps

type WebhookHealthProps = {
    /**
     * System metadata
     */
    sys: WebhookHealthSys & {
        space: {
            sys: MetaLinkProps;
        };
    };
    /**
     * Webhook call statistics
     */
    calls: WebhookCalls;
};

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;
    };
};

Namespaces

namespace editorInterfaceDefaults

module 'dist/types/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 (94)

Dependencies (6)

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 10084 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 clientOptions

Deprecated

function fetchAll

function isDraft

function isPublished

function isUpdated

function makeRequest

Classes

class RestAdapter

constructor

method makeRequest

Interfaces

interface AccessToken

method revoke

Returns

Example 1

interface Adapter

property makeRequest

interface Agent

method generate

interface AgentRun

interface AiAction

method delete

method invoke

method publish

method unpublish

method update

interface AiActionInvocation

interface ApiKey

method delete

Returns

Example 1

method update

Returns

Example 1

interface AppAccessToken

interface AppActionCallErrorProps

property details

property message

property statusCode

property sys

interface AppActionCallRawResponseProps

property response

property sys

interface AppBundle

method delete

Returns

Example 1

interface AppDetails

method delete

Returns

Example 1

interface AppEventSubscription

method delete

Returns

Example 1

interface AppIcon

property type

property value

interface AppInstallation

method delete

Returns

Example 1

method update