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

package/dist/typings/create-ui-config-api.d.ts

@@ -0,0 +1,34 @@
+import type { MakeRequest } from './common-types';
+/**
+ * @private
+ */
+export type ContentfulUIConfigApi = ReturnType<typeof createUIConfigApi>;
+/**
+ * @private
+ */
+export default function createUIConfigApi(makeRequest: MakeRequest): {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```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.getUIConfig())
+     * .then((uiConfig) => {
+     *   uiConfig.entryListViews = [...]
+     *   return uiConfig.update()
+     * })
+     * .then((uiConfig) => console.log(`UIConfig updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update: () => Promise<any & import("./entities/ui-config").UIConfigProps & {
+        toPlainObject(): import("./entities/ui-config").UIConfigProps;
+    }>;
+};

package/dist/typings/create-user-ui-config-api.d.ts

@@ -0,0 +1,34 @@
+import type { MakeRequest } from './common-types';
+/**
+ * @private
+ */
+export type ContentfulUIConfigApi = ReturnType<typeof createUserUIConfigApi>;
+/**
+ * @private
+ */
+export default function createUserUIConfigApi(makeRequest: MakeRequest): {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```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.getUserUIConfig())
+     * .then((uiConfig) => {
+     *   uiConfig.entryListViews = [...]
+     *   return uiConfig.update()
+     * })
+     * .then((uiConfig) => console.log(`UserUIConfig updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update: () => Promise<any & import("./entities/user-ui-config").UserUIConfigProps & {
+        toPlainObject(): import("./entities/user-ui-config").UserUIConfigProps;
+    }>;
+};

package/dist/typings/entities/access-token.d.ts

@@ -0,0 +1,61 @@
+import type { DefaultElements, MakeRequest, BasicMetaSysProps, SysLink } from '../common-types';
+type Application = {
+    id?: string;
+    name?: string;
+    sys: SysLink;
+};
+type AccessTokenSysProps = BasicMetaSysProps & {
+    application: Application | null;
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    redactedValue: string;
+};
+export type AccessTokenProps = {
+    sys: AccessTokenSysProps;
+    name: string;
+    scopes: 'content_management_manage'[];
+    revokedAt: null | string;
+    token?: string;
+};
+/**
+ * @deprecated Use `AccessTokenProps` instead.
+ */
+export type AccessTokenProp = AccessTokenProps;
+export type CreatePersonalAccessTokenProps = Pick<AccessToken, 'name' | 'scopes'> & {
+    expiresIn: number;
+};
+export interface AccessToken extends AccessTokenProps, DefaultElements<AccessTokenProps> {
+    /**
+     * Revokes access token
+     * @return Object the revoked access token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *  accessToken: <content_management_api_key>
+     * })
+     *
+     * client.getAccessToken('<token-id>')
+     *  .then((AccessToken) => {
+     *    return accessToken.revoke()
+     *  })
+     *  .catch(console.error)
+     * ```
+     */
+    revoke(): Promise<AccessToken>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  access token data
+ * @return Wrapped access token
+ */
+export declare function wrapAccessToken(makeRequest: MakeRequest, data: AccessTokenProps): AccessToken;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw access collection data
+ * @return Wrapped access token collection data
+ */
+export declare const wrapAccessTokenCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AccessTokenProps>) => import("../common-types").Collection<AccessToken, AccessTokenProps>;
+export {};

package/dist/typings/entities/ai-action-invocation.d.ts

@@ -0,0 +1,82 @@
+import type { DefaultElements, MakeRequest, SysLink } from '../common-types';
+import type { Document as RichTextDocument } from '@contentful/rich-text-types';
+export type InvocationStatus = 'SCHEDULED' | 'IN_PROGRESS' | 'FAILED' | 'COMPLETED' | 'CANCELLED';
+export type InvocationResultType = 'text';
+export declare const AiActionOutputFormat: {
+    readonly RichText: "RichText";
+    readonly Markdown: "Markdown";
+    readonly PlainText: "PlainText";
+};
+export type AiActionOutputFormatType = (typeof AiActionOutputFormat)[keyof typeof AiActionOutputFormat];
+export type AiActionInvocationMetadata = {
+    invocationResult?: {
+        modelProvider?: string;
+        modelId?: string;
+        wordCount?: number;
+        outputFormat?: AiActionOutputFormatType;
+    };
+    statusChangedDates?: {
+        status: InvocationStatus;
+        date: string;
+    }[];
+};
+export interface InvocationResult {
+    content: string | RichTextDocument;
+    type: InvocationResultType;
+    metadata: AiActionInvocationMetadata;
+}
+export type AiActionInvocationProps = {
+    sys: {
+        id: string;
+        type: 'AiActionInvocation';
+        space: SysLink;
+        environment: SysLink;
+        aiAction: SysLink;
+        status: InvocationStatus;
+        errorCode?: string;
+    };
+    result?: InvocationResult;
+};
+export type AiActionInvocationType = {
+    outputFormat: 'RichText' | 'Markdown' | 'PlainText';
+    variables?: Array<{
+        value: string;
+        id: string;
+    } | {
+        value: {
+            entityPath: string;
+            entityType: 'Entry' | 'Asset' | 'ResourceLink';
+            entityId: string;
+        };
+        id: string;
+    } | {
+        value: {
+            entityPaths: Array<string>;
+            entityType: 'Entry';
+            entityId: string;
+        };
+        id: string;
+    }>;
+};
+/**
+ * The AI Action Invocation entity.
+ * This entity is read-only and primarily used to inspect the result of an AI action invocation.
+ */
+export interface AiActionInvocation extends AiActionInvocationProps, DefaultElements<AiActionInvocationProps> {
+}
+/**
+ * Wraps raw AI Action Invocation data with SDK helper methods.
+ *
+ * @param makeRequest - Function to make API requests.
+ * @param data - Raw AI Action Invocation data.
+ * @returns The AI Action Invocation entity.
+ */
+export declare function wrapAiActionInvocation(makeRequest: MakeRequest, data: AiActionInvocationProps): AiActionInvocation;
+/**
+ * Wraps a collection of raw AI Action Invocation data.
+ *
+ * @param makeRequest - Function to make API requests.
+ * @param data - Raw collection data.
+ * @returns A collection of AI Action Invocation entities.
+ */
+export declare const wrapAiActionInvocationCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AiActionInvocationProps>) => import("../common-types").Collection<AiActionInvocation, AiActionInvocationProps>;

package/dist/typings/entities/ai-action.d.ts

@@ -0,0 +1,75 @@
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types';
+import { type AiActionInvocationType, type AiActionInvocation } from './ai-action-invocation';
+export type VariableType = 'ResourceLink' | 'Text' | 'StandardInput' | 'Locale' | 'MediaReference' | 'Reference' | 'SmartContext';
+export type ReferenceVariableConfiguration = {
+    allowedEntities: Array<'Entry'>;
+};
+export type VariableConfiguration = {
+    strict: boolean;
+    in: Array<string>;
+} | ReferenceVariableConfiguration;
+export type Variable = {
+    configuration?: VariableConfiguration;
+    description?: string;
+    name?: string;
+    type: VariableType;
+    id: string;
+};
+export type Instruction = {
+    variables: Array<Variable>;
+    template: string;
+};
+export type Configuration = {
+    modelType: string;
+    modelTemperature: number;
+};
+export type AiActionTestCase = {
+    type?: 'Text';
+    value?: string;
+} | {
+    type?: 'Reference';
+    value?: {
+        entityPath?: string;
+        entityType?: 'Entry';
+        entityId?: string;
+    };
+};
+export interface AiActionQueryOptions {
+    limit?: number;
+    skip?: number;
+    status?: 'all' | 'published';
+}
+export 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>;
+};
+export type CreateAiActionProps = Pick<Omit<AiActionProps, 'sys'>, 'name' | 'description' | 'configuration' | 'instruction' | 'testCases'>;
+export interface AiAction extends AiActionProps, DefaultElements<AiActionProps> {
+    update(): Promise<AiAction>;
+    delete(): Promise<void>;
+    publish(): Promise<AiAction>;
+    unpublish(): Promise<AiAction>;
+    invoke(environmentId: string, payload: AiActionInvocationType): Promise<AiActionInvocation>;
+}
+export declare function wrapAiAction(makeRequest: MakeRequest, data: AiActionProps): AiAction;
+export declare const wrapAiActionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AiActionProps>) => import("../common-types").Collection<AiAction, AiActionProps>;

package/dist/typings/entities/api-key.d.ts

@@ -0,0 +1,70 @@
+import type { DefaultElements, MakeRequest, MetaLinkProps, MetaSysProps } from '../common-types';
+export type ApiKeyProps = {
+    sys: MetaSysProps;
+    name: string;
+    accessToken: string;
+    environments: {
+        sys: MetaLinkProps;
+    }[];
+    preview_api_key: {
+        sys: MetaLinkProps;
+    };
+    description?: string;
+    policies?: {
+        effect: string;
+        action: string;
+    }[];
+};
+export type CreateApiKeyProps = Pick<ApiKeyProps, 'name' | 'environments' | 'description'>;
+export interface ApiKey extends ApiKeyProps, DefaultElements<ApiKeyProps> {
+    /**
+     * Deletes this object on the server.
+     * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getApiKey(<api-key-id>))
+     * .then((apiKey) => apiKey.delete())
+     * .then(() => console.log('apikey deleted'))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getApiKey(<api-key-id>))
+     * .then((apiKey) => {
+     *  apiKey.name = 'New name'
+     *  return apiKey.update()
+     * })
+     * .then(apiKey => console.log(apiKey.name))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<ApiKey>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key data
+ */
+export declare function wrapApiKey(makeRequest: MakeRequest, data: ApiKeyProps): ApiKey;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key collection data
+ * @return Wrapped api key collection data
+ */
+export declare const wrapApiKeyCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<ApiKeyProps>) => import("../common-types").Collection<ApiKey, ApiKeyProps>;

package/dist/typings/entities/app-action.d.ts

@@ -0,0 +1,161 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest, SysLink } from '../common-types';
+import type { ParameterDefinition } from './widget-parameters';
+type AppActionSys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: SysLink;
+    organization: SysLink;
+};
+export type AppActionParameterDefinition = Omit<ParameterDefinition, 'labels'>;
+export type AppActionCategoryProps = {
+    sys: {
+        id: AppActionCategoryType;
+        type: 'AppActionCategory';
+        version: string;
+    };
+    name: string;
+    description: string;
+    parameters?: AppActionParameterDefinition[];
+};
+type BuiltInCategoriesProps = {
+    /**
+     * Category identifying the shape of the action.
+     */
+    category: 'Entries.v1.0' | 'Notification.v1.0';
+};
+type CustomAppActionProps = {
+    /**
+     * "Custom" category requires "parameters"
+     */
+    category: 'Custom';
+    parameters: AppActionParameterDefinition[];
+};
+type AppActionCategory = BuiltInCategoriesProps | CustomAppActionProps;
+export type AppActionCategoryType = AppActionCategory['category'];
+/**
+ * 'function' is deprecated, use 'function-invocation' instead
+ */
+export type AppActionType = 'endpoint' | 'function' | 'function-invocation';
+type BaseAppActionProps = AppActionCategory & {
+    /**
+     * System metadata
+     */
+    sys: AppActionSys;
+    /**
+     * Human readable name for the action
+     */
+    name: string;
+    /**
+     * Human readable description of the action
+     */
+    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>;
+};
+type CreateEndpointAppActionProps = {
+    /**
+     * Type of the action, defaults to endpoint if not provided
+     * endpoint: action is sent to specified URL
+     */
+    type?: 'endpoint';
+    /**
+     * Url that will be called when the action is invoked
+     */
+    url: string;
+};
+type EndpointAppActionProps = {
+    /**
+     * Type of the action
+     * endpoint: action is sent to specified URL
+     */
+    type: 'endpoint';
+    /**
+     * Url that will be called when the action is invoked
+     */
+    url: string;
+};
+type CreateFunctionAppActionProps = {
+    /**
+     * Type of the action
+     * function-invocation: action invokes a contentful function
+     */
+    type: 'function-invocation';
+    /**
+     * Link to a Function
+     */
+    function: Link<'Function'>;
+    /**
+     * ID of the action
+     */
+    id?: string;
+};
+type FunctionAppActionProps = {
+    /**
+     * Type of the action
+     * function-invocation: action invokes a contentful function
+     */
+    type: 'function-invocation';
+    /**
+     * Link to a Function
+     */
+    function: Link<'Function'>;
+};
+/**
+ * @deprecated Use FunctionAppActionProps instead
+ */
+type LegacyFunctionAppActionProps = Record<string, unknown> & {
+    type: 'function';
+};
+export 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);
+export type AppActionProps = BaseAppActionProps & (EndpointAppActionProps | FunctionAppActionProps | LegacyFunctionAppActionProps);
+export type AppAction = AppActionProps & DefaultElements<AppActionProps> & {
+    /**
+     * Deletes this object on the server.
+     * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('<org_id>')
+     * .then((org) => org.getAppDefinition('<app_def_id>'))
+     * .then((appDefinition) => appDefinition.getAppAction('<app-action-id>'))
+     * .then((appAction) => appAction.delete())
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+};
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle data
+ * @return Wrapped App Bundle data
+ */
+export declare function wrapAppAction(makeRequest: MakeRequest, data: AppActionProps): AppAction;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle collection data
+ * @return Wrapped App Bundle collection data
+ */
+export declare const wrapAppActionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppActionProps>) => import("../common-types").Collection<AppAction, AppActionProps>;
+export {};

package/dist/typings/entities/app-bundle.d.ts

@@ -0,0 +1,86 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest, SysLink } from '../common-types';
+type AppBundleSys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: SysLink;
+    organization: SysLink;
+};
+interface ActionManifestProps {
+    id?: string;
+    name: string;
+    description: string;
+    category: string;
+    path: string;
+    allowNetworks?: string[];
+}
+interface FunctionManifestProps {
+    id: string;
+    name: string;
+    description: string;
+    path: string;
+    accepts?: string[];
+    allowNetworks?: string[];
+}
+export type AppBundleFile = {
+    name: string;
+    size: number;
+    md5: string;
+};
+export type CreateAppBundleProps = {
+    appUploadId: string;
+    comment?: string;
+    actions?: ActionManifestProps[];
+    functions?: FunctionManifestProps[];
+};
+export 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[];
+};
+export interface AppBundle extends AppBundleProps, DefaultElements<AppBundleProps> {
+    /**
+     * Deletes this object on the server.
+     * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('<org_id>')
+     * .then((org) => org.getAppDefinition('<app_def_id>'))
+     * .then((appDefinition) => appDefinition.getAppBundle('<app-bundle-id>'))
+     * .then((appBundle) => appBundle.delete())
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle data
+ * @return Wrapped App Bundle data
+ */
+export declare function wrapAppBundle(makeRequest: MakeRequest, data: AppBundleProps): AppBundle;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle collection data
+ * @return Wrapped App Bundle collection data
+ */
+export declare const wrapAppBundleCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppBundleProps>) => import("../common-types").Collection<AppBundle, AppBundleProps>;
+export {};

package/dist/typings/entities/app-definition.d.ts

@@ -0,0 +1,88 @@
+import type { DefaultElements, BasicMetaSysProps, SysLink, MakeRequest, Link } from '../common-types';
+import type { ContentfulAppDefinitionAPI } from '../create-app-definition-api';
+import type { SetOptional, Except } from 'type-fest';
+import type { FieldType } from './field-type';
+import type { InstallationParameterType, ParameterDefinition } from './widget-parameters';
+import type { AppInstallationProps } from './app-installation';
+import type { EnvironmentProps } from './environment';
+export interface NavigationItem {
+    name: string;
+    path: string;
+}
+/**
+ * These locations are currently restricted to internal Contentful apps only.
+ * If you are interested in using these locations for your app,
+ * please reach out to Contentful Support (https://www.contentful.com/support/).
+ */
+type InternalLocationType = 'agent';
+type LocationType = 'app-config' | 'entry-sidebar' | 'entry-editor' | 'dialog' | 'page' | 'home' | InternalLocationType;
+export interface SimpleLocation {
+    location: LocationType;
+}
+export interface EntryFieldLocation {
+    location: 'entry-field';
+    fieldTypes: FieldType[];
+}
+export interface PageLocation {
+    location: 'page';
+    navigationItem?: NavigationItem;
+}
+export type AppLocation = SimpleLocation | EntryFieldLocation | PageLocation;
+export type AppDefinitionProps = {
+    /**
+     * System metadata
+     */
+    sys: BasicMetaSysProps & {
+        organization: SysLink;
+        shared: boolean;
+    };
+    /**
+     * App name
+     */
+    name: string;
+    /**
+     * URL where the root HTML document of the app can be found
+     */
+    src?: string;
+    /**
+     * Link to an AppBundle
+     */
+    bundle?: Link<'AppBundle'>;
+    /**
+     * Locations where the app can be installed
+     */
+    locations?: AppLocation[];
+    /**
+     * Instance parameter definitions
+     */
+    parameters?: {
+        instance?: ParameterDefinition[];
+        installation?: ParameterDefinition<InstallationParameterType>[];
+    };
+};
+export type CreateAppDefinitionProps = SetOptional<Except<AppDefinitionProps, 'sys' | 'bundle'>, 'src' | 'locations'>;
+export type AppDefinition = ContentfulAppDefinitionAPI & AppDefinitionProps & DefaultElements<AppDefinitionProps>;
+export type AppInstallationsForOrganizationProps = {
+    sys: {
+        type: 'Array';
+    };
+    items: AppInstallationProps[];
+    includes: {
+        Environment: EnvironmentProps[];
+    };
+};
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition data
+ * @return Wrapped App Definition data
+ */
+export declare function wrapAppDefinition(makeRequest: MakeRequest, data: AppDefinitionProps): AppDefinition;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition collection data
+ * @return Wrapped App Definition collection data
+ */
+export declare const wrapAppDefinitionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppDefinitionProps>) => import("../common-types").Collection<AppDefinition, AppDefinitionProps>;
+export {};