contentful-management 11.49.0-beta.1 → 11.49.0

package/dist/typings/common-types.d.ts

@@ -62,6 +62,8 @@ import type { CreateWorkflowDefinitionParams, CreateWorkflowDefinitionProps, Del
 import type { WorkflowsChangelogEntryProps, WorkflowsChangelogQueryOptions } from './entities/workflows-changelog-entry';
 import type { CreateOAuthApplicationProps, OAuthApplicationProps, UpdateOAuthApplicationProps } from './entities/oauth-application';
 import type { FunctionLogProps } from './entities/function-log';
+import type { AiActionProps, CreateAiActionProps } from './entities/ai-action';
+import type { AiActionInvocationProps, AiActionInvocationType } from './entities/ai-action-invocation';
 export interface DefaultElements<TPlainObject extends object = object> {
     toPlainObject(): TPlainObject;
 }
@@ -249,6 +251,15 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'Http', 'put', UA>): MRReturn<'Http', 'put'>;
     (opts: MROpts<'Http', 'delete', UA>): MRReturn<'Http', 'delete'>;
     (opts: MROpts<'Http', 'request', UA>): MRReturn<'Http', 'request'>;
+    (opts: MROpts<'AiAction', 'get', UA>): MRReturn<'AiAction', 'get'>;
+    (opts: MROpts<'AiAction', 'getMany', UA>): MRReturn<'AiAction', 'getMany'>;
+    (opts: MROpts<'AiAction', 'create', UA>): MRReturn<'AiAction', 'create'>;
+    (opts: MROpts<'AiAction', 'update', UA>): MRReturn<'AiAction', 'update'>;
+    (opts: MROpts<'AiAction', 'delete', UA>): MRReturn<'AiAction', 'delete'>;
+    (opts: MROpts<'AiAction', 'publish', UA>): MRReturn<'AiAction', 'publish'>;
+    (opts: MROpts<'AiAction', 'unpublish', UA>): MRReturn<'AiAction', 'unpublish'>;
+    (opts: MROpts<'AiAction', 'invoke', UA>): MRReturn<'AiAction', 'invoke'>;
+    (opts: MROpts<'AiActionInvocation', 'get', UA>): MRReturn<'AiActionInvocation', 'get'>;
     (opts: MROpts<'AppAction', 'get', UA>): MRReturn<'AppAction', 'get'>;
     (opts: MROpts<'AppAction', 'getMany', UA>): MRReturn<'AppAction', 'getMany'>;
     (opts: MROpts<'AppAction', 'delete', UA>): MRReturn<'AppAction', 'delete'>;
@@ -677,6 +688,70 @@ export type MRActions = {
             return: any;
         };
     };
+    AiAction: {
+        get: {
+            params: GetSpaceParams & {
+                aiActionId: string;
+            };
+            return: AiActionProps;
+        };
+        getMany: {
+            params: GetSpaceParams & QueryParams;
+            return: CollectionProp<AiActionProps>;
+        };
+        create: {
+            params: GetSpaceParams;
+            payload: CreateAiActionProps;
+            headers?: RawAxiosRequestHeaders;
+            return: AiActionProps;
+        };
+        update: {
+            params: GetSpaceParams & {
+                aiActionId: string;
+            };
+            payload: AiActionProps;
+            headers?: RawAxiosRequestHeaders;
+            return: AiActionProps;
+        };
+        delete: {
+            params: GetSpaceParams & {
+                aiActionId: string;
+            };
+            return: any;
+        };
+        publish: {
+            params: GetSpaceParams & {
+                aiActionId: string;
+            };
+            payload: AiActionProps;
+            headers?: RawAxiosRequestHeaders;
+            return: AiActionProps;
+        };
+        unpublish: {
+            params: GetSpaceParams & {
+                aiActionId: string;
+            };
+            headers?: RawAxiosRequestHeaders;
+            return: AiActionProps;
+        };
+        invoke: {
+            params: GetSpaceEnvironmentParams & {
+                aiActionId: string;
+            };
+            payload: AiActionInvocationType;
+            headers?: RawAxiosRequestHeaders;
+            return: AiActionInvocationProps;
+        };
+    };
+    AiActionInvocation: {
+        get: {
+            params: GetSpaceEnvironmentParams & {
+                aiActionId: string;
+                invocationId: string;
+            };
+            return: AiActionInvocationProps;
+        };
+    };
     AppAction: {
         get: {
             params: GetAppActionParams;

package/dist/typings/constants/editor-interface-defaults/controls-defaults.d.ts

@@ -91,7 +91,7 @@ export declare const FIELD_TYPES: Array<keyof typeof INTERNAL_TO_API>;
  * - Assets
  * - File
  */
-export declare function toInternalFieldType(api: Partial<ContentFields>): "Asset" | "Entry" | "Boolean" | "Symbol" | "Number" | "Resource" | "Text" | "RichText" | "Integer" | "Date" | "Object" | "Location" | "File" | "Symbols" | "Entries" | "Assets" | "Resources" | undefined;
+export declare function toInternalFieldType(api: Partial<ContentFields>): "Asset" | "Entry" | "Boolean" | "Symbol" | "Number" | "Resource" | "RichText" | "Text" | "Integer" | "Date" | "Object" | "Location" | "File" | "Symbols" | "Entries" | "Assets" | "Resources" | undefined;
 export declare const DEFAULTS_WIDGET: {
     Text: {
         widgetId: string;

package/dist/typings/create-environment-api.d.ts

@@ -16,6 +16,7 @@ import type { CreateLocaleProps } from './entities/locale';
 import type { TagVisibility } from './entities/tag';
 import type { CreateAppAccessTokenProps } from './entities/app-access-token';
 import type { ResourceQueryOptions } from './entities/resource';
+import type { AiActionInvocationType } from './entities/ai-action-invocation';
 /**
  * @private
  */
@@ -1626,4 +1627,40 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
      * ```
      */
     getResourcesForResourceType(resourceTypeId: string, query?: ResourceQueryOptions): Promise<import("./common-types").CursorPaginatedCollectionProp<import("./entities/resource").ResourceProps>>;
+    /**
+     * Invokes an AI Action.
+     * @param aiActionId - The ID of the AI Action to invoke.
+     * @param payload - The invocation payload.
+     * @returns Promise for an AI Action Invocation.
+     * @example ```javascript
+     * client.getSpace('<space_id>')
+     *   .then(space => space.getEnvironment('<environment_id>'))
+     *   .then(environment => environment.invokeAiAction('<ai_action_id>', {
+     *     variables: [  ...  ],
+     *     outputFormat: 'RichText'
+     *   }))
+     *   .then(invocation => console.log(invocation))
+     *   .catch(console.error)
+     * ```
+     */
+    invokeAiAction(aiActionId: string, payload: AiActionInvocationType): Promise<import("./entities/ai-action-invocation").AiActionInvocation>;
+    /**
+     * Retrieves an AI Action Invocation.
+     * @param params - Object containing the AI Action ID and the Invocation ID.
+     * @returns Promise for an AI Action Invocation.
+     * @example ```javascript
+     * client.getSpace('<space_id>')
+     *   .then(space => space.getEnvironment('<environment_id>'))
+     *   .then(environment => environment.getAiActionInvocation({
+     *      aiActionId: '<ai_action_id>',
+     *      invocationId: '<invocation_id>'
+     *   }))
+     *   .then(invocation => console.log(invocation))
+     *   .catch(console.error)
+     * ```
+     */
+    getAiActionInvocation({ aiActionId, invocationId, }: {
+        aiActionId: string;
+        invocationId: string;
+    }): Promise<import("./entities/ai-action-invocation").AiActionInvocation>;
 };

package/dist/typings/create-space-api.d.ts

@@ -11,6 +11,7 @@ import type { ScheduledActionProps, ScheduledActionQueryOptions } from './entiti
 import type { CreateSpaceMembershipProps } from './entities/space-membership';
 import type { CreateTeamSpaceMembershipProps } from './entities/team-space-membership';
 import type { CreateWebhooksProps, UpsertWebhookSigningSecretPayload, WebhookRetryPolicyPayload } from './entities/webhook';
+import type { AiActionProps, AiActionQueryOptions, CreateAiActionProps } from './entities/ai-action';
 /**
  * @private
  */
@@ -1045,4 +1046,103 @@ export default function createSpaceApi(makeRequest: MakeRequest): {
         scheduledActionId: string;
         environmentId: string;
     }): Promise<import("./entities/scheduled-action").ScheduledAction>;
+    /**
+     * Gets a single AI Action.
+     * @param aiActionId - AI Action ID
+     * @return Promise for an AI Action
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getAiAction('<ai_action_id>'))
+     *   .then((aiAction) => console.log(aiAction))
+     *   .catch(console.error)
+     * ```
+     */
+    getAiAction(aiActionId: string): Promise<import("./entities/ai-action").AiAction>;
+    /**
+     * Gets a collection of AI Actions.
+     * @param query - Object with search parameters.
+     * @return Promise for a collection of AI Actions
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getAiActions({ limit: 10 }))
+     *   .then((response) => console.log(response.items))
+     *   .catch(console.error)
+     * ```
+     */
+    getAiActions(query?: AiActionQueryOptions): Promise<import("./common-types").Collection<import("./entities/ai-action").AiAction, AiActionProps>>;
+    /**
+     * Creates an AI Action.
+     * @param data - Object representation of the AI Action to be created
+     * @return Promise for the newly created AI Action
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.createAiAction({
+     *     name: 'My AI Action',
+     *     description: 'Description here',
+     *     configuration: { modelType: 'model-x', modelTemperature: 0.7 },
+     *     instruction: { template: 'Do something: {{var.input}}', variables: [], conditions: [] },
+     *     testCases: []
+     *   }))
+     *   .then((aiAction) => console.log(aiAction))
+     *   .catch(console.error)
+     * ```
+     */
+    createAiAction(data: CreateAiActionProps): Promise<import("./entities/ai-action").AiAction>;
+    /**
+     * Updates an AI Action.
+     * @param aiActionId - AI Action ID
+     * @param data - Object representation of the AI Action update
+     * @return Promise for the updated AI Action
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.updateAiAction('<ai_action_id>', { name: 'New Name', ... }))
+     *   .then((aiAction) => console.log(aiAction))
+     *   .catch(console.error)
+     * ```
+     */
+    updateAiAction(aiActionId: string, data: AiActionProps): Promise<import("./entities/ai-action").AiAction>;
+    /**
+     * Publishes an AI Action.
+     * @param aiActionId - AI Action ID
+     * @param data - Object representation of the AI Action to be published
+     * @return Promise for the published AI Action
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.publishAiAction('<ai_action_id>', { ... }))
+     *   .then((aiAction) => console.log(aiAction))
+     *   .catch(console.error)
+     * ```
+     */
+    publishAiAction(aiActionId: string, data: AiActionProps): Promise<import("./entities/ai-action").AiAction>;
+    /**
+     * Unpublishes an AI Action.
+     * @param aiActionId - AI Action ID
+     * @return Promise for the unpublished AI Action
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.unpublishAiAction('<ai_action_id>'))
+     *   .then((aiAction) => console.log(aiAction))
+     *   .catch(console.error)
+     * ```
+     */
+    unpublishAiAction(aiActionId: string): Promise<import("./entities/ai-action").AiAction>;
+    /**
+     * Deletes an AI Action.
+     * @param aiActionId - AI Action ID
+     * @return Promise for deletion (void)
+     * @example
+     * ```javascript
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.deleteAiAction('<ai_action_id>'))
+     *   .then(() => console.log('AI Action deleted'))
+     *   .catch(console.error)
+     * ```
+     */
+    deleteAiAction(aiActionId: string): Promise<any>;
 };

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

@@ -0,0 +1,90 @@
+import type { DefaultElements, MakeRequest, SysLink } from '../common-types';
+import type { Document as RichTextDocument } from '@contentful/rich-text-types';
+export declare enum InvocationStatus {
+    Scheduled = "SCHEDULED",
+    InProgress = "IN_PROGRESS",
+    Failed = "FAILED",
+    Completed = "COMPLETED",
+    Cancelled = "CANCELLED"
+}
+export declare enum InvocationResultType {
+    Text = "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,97 @@
+import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types';
+import { type AiActionInvocationType, type AiActionInvocation } from './ai-action-invocation';
+export declare enum StatusFilter {
+    ALL = "all",
+    PUBLISHED = "published"
+}
+export declare enum VariableType {
+    RESOURCE_LINK = "ResourceLink",
+    TEXT = "Text",
+    STANDARD_INPUT = "StandardInput",
+    LOCALE = "Locale",
+    MEDIA_REFERENCE = "MediaReference",
+    REFERENCE = "Reference",
+    SMART_CONTEXT = "SmartContext"
+}
+export declare enum EntityTypeEntry {
+    ENTRY = "Entry"
+}
+export type ReferenceVariableConfiguration = {
+    allowedEntities: Array<EntityTypeEntry>;
+};
+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 type SysLinkUserOrApp = {
+    sys: {
+        id: string;
+        linkType: 'User' | 'App';
+        type: 'Link';
+    };
+};
+export interface AiActionQueryOptions {
+    limit?: number;
+    skip?: number;
+    status?: StatusFilter;
+}
+export type AiActionProps = {
+    sys: MetaSysProps & {
+        type: 'AiAction';
+        space: {
+            sys: {
+                id: string;
+            };
+        };
+        publishedBy?: SysLinkUserOrApp;
+        updatedBy: SysLinkUserOrApp;
+        createdBy: SysLinkUserOrApp;
+        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/app-event-subscription.d.ts

@@ -1,5 +1,5 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, MakeRequest, SysLink } from '../common-types';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest, SysLink } from '../common-types';
 type AppEventSubscriptionSys = Except<BasicMetaSysProps, 'version' | 'id'> & {
     appDefinition: SysLink;
     organization: SysLink;
@@ -10,9 +10,15 @@ export type AppEventSubscriptionProps = {
      */
     sys: AppEventSubscriptionSys;
     /** Subscription url that will receive events */
-    targetUrl: string;
+    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'>;
+    };
 };
 export type CreateAppEventSubscriptionProps = Except<AppEventSubscriptionProps, 'sys'>;
 export interface AppEventSubscription extends AppEventSubscriptionProps, DefaultElements<AppEventSubscriptionProps> {

package/dist/typings/entities/index.d.ts

@@ -1,3 +1,5 @@
+import * as aiAction from './ai-action';
+import * as aiActionInvocation from './ai-action-invocation';
 import * as apiKey from './api-key';
 import * as appAction from './app-action';
 import * as appActionCall from './app-action-call';
@@ -59,6 +61,8 @@ import * as resourceProvider from './resource-provider';
 import * as resourceType from './resource-type';
 import * as resource from './resource';
 declare const _default: {
+    aiAction: typeof aiAction;
+    aiActionInvocation: typeof aiActionInvocation;
     accessToken: typeof accessToken;
     appAction: typeof appAction;
     appActionCall: typeof appActionCall;

package/dist/typings/export-types.d.ts

@@ -2,6 +2,8 @@ export * from './common-types';
 export type { AccessToken, AccessTokenProps as AccessTokenProp, CreatePersonalAccessTokenProps as CreatePATProps, } from './entities/access-token';
 export type { ApiKey, ApiKeyProps, CreateApiKeyProps } from './entities/api-key';
 export type { AppAccessToken, AppAccessTokenProps, CreateAppAccessTokenProps, } from './entities/app-access-token';
+export type { AiAction, AiActionProps, CreateAiActionProps } from './entities/ai-action';
+export type { AiActionInvocation, AiActionInvocationProps } from './entities/ai-action-invocation';
 export type { AppAction, AppActionCategoryProps, AppActionCategoryType, AppActionParameterDefinition, AppActionProps, AppActionType, CreateAppActionProps, } from './entities/app-action';
 export type { AppActionCall, AppActionCallProps, CreateAppActionCallProps, } from './entities/app-action-call';
 export type { AppBundle, AppBundleFile, AppBundleProps, CreateAppBundleProps, } from './entities/app-bundle';

package/dist/typings/plain/common-types.d.ts

@@ -65,6 +65,8 @@ import type { WorkflowsChangelogPlainClientAPI } from './entities/workflows-chan
 import type { DefaultParams, OptionalDefaults } from './wrappers/wrap';
 import type { OAuthApplicationPlainClientAPI } from './entities/oauth-application';
 import type { FunctionLogPlainClientAPI } from './entities/function-log';
+import type { AiActionPlainClientAPI } from './entities/ai-action';
+import type { AiActionInvocationPlainClientAPI } from './entities/ai-action-invocation';
 export type PlainClientAPI = {
     raw: {
         getDefaultParams(): DefaultParams | undefined;
@@ -75,6 +77,8 @@ export type PlainClientAPI = {
         delete<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
         http<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
     };
+    aiAction: AiActionPlainClientAPI;
+    aiActionInvocation: AiActionInvocationPlainClientAPI;
     appAction: AppActionPlainClientAPI;
     appActionCall: AppActionCallPlainClientAPI;
     appBundle: AppBundlePlainClientAPI;
@@ -167,6 +171,7 @@ export type PlainClientAPI = {
         }>, rawData: EntryProps<T>, headers?: RawAxiosRequestHeaders): Promise<EntryProps<T>>;
         patch<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
             entryId: string;
+            version: number;
         }>, rawData: OpPatch[], headers?: RawAxiosRequestHeaders): Promise<EntryProps<T>>;
         delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
             entryId: string;

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

@@ -0,0 +1,18 @@
+import type { GetSpaceEnvironmentParams } from '../../common-types';
+import type { AiActionInvocationProps } from '../../entities/ai-action-invocation';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type AiActionInvocationPlainClientAPI = {
+    /**
+     * Fetches an AI Action Invocation.
+     * @param params Entity IDs to identify the AI Action Invocation.
+     *               Must include spaceId, environmentId, aiActionId, and invocationId.
+     * @param headers Optional headers for the request.
+     * @returns A promise resolving with the AI Action Invocation.
+     * @throws if the request fails or the AI Action Invocation is not found.
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        aiActionId: string;
+        invocationId: string;
+    }>, headers?: Partial<RawAxiosRequestHeaders>): Promise<AiActionInvocationProps>;
+};

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

@@ -0,0 +1,84 @@
+import type { CollectionProp, GetSpaceEnvironmentParams, GetSpaceParams, QueryParams } from '../../common-types';
+import type { AiActionProps, CreateAiActionProps } from '../../entities/ai-action';
+import type { AiActionInvocationProps, AiActionInvocationType } from '../../entities/ai-action-invocation';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type AiActionPlainClientAPI = {
+    /**
+     * Fetches the AI Action.
+     * @param params Entity IDs to identify the AI Action.
+     * @returns The AI Action.
+     * @throws if the request fails or the AI Action is not found.
+     */
+    get(params: OptionalDefaults<GetSpaceParams & {
+        aiActionId: string;
+    }>): Promise<AiActionProps>;
+    /**
+     * Fetches all AI Actions for the given space and environment.
+     * @param params Entity IDs and query options.
+     * @returns A collection containing an array of AI Actions.
+     * @throws if the request fails or the entities are not found.
+     */
+    getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<AiActionProps>>;
+    /**
+     * Deletes the AI Action.
+     * @param params Entity IDs to identify the AI Action to delete.
+     * @returns void.
+     * @throws if the request fails or the AI Action is not found.
+     */
+    delete(params: OptionalDefaults<GetSpaceParams & {
+        aiActionId: string;
+    }>): Promise<void>;
+    /**
+     * Creates an AI Action.
+     * @param params Entity IDs to scope where to create the AI Action.
+     * @param payload The AI Action details.
+     * @param headers Optional headers for the request.
+     * @returns The created AI Action and its metadata.
+     * @throws if the request fails or the payload is malformed.
+     */
+    create(params: OptionalDefaults<GetSpaceParams>, payload: CreateAiActionProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<AiActionProps>;
+    /**
+     * Updates an AI Action.
+     * @param params Entity IDs to identify the AI Action.
+     * @param payload The AI Action update.
+     * @param headers Optional headers for the request.
+     * @returns The updated AI Action and its metadata.
+     * @throws if the request fails, the AI Action is not found, or the payload is malformed.
+     */
+    update(params: OptionalDefaults<GetSpaceParams & {
+        aiActionId: string;
+    }>, payload: AiActionProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<AiActionProps>;
+    /**
+     * Publishes the AI Action.
+     * @param params Entity IDs to identify the AI Action.
+     * @param payload The AI Action details.
+     * @param headers Optional headers for the request.
+     * @returns The published AI Action and its metadata.
+     * @throws if the request fails or the payload is malformed.
+     */
+    publish(params: OptionalDefaults<GetSpaceParams & {
+        aiActionId: string;
+    }>, payload: AiActionProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<AiActionProps>;
+    /**
+     * Unpublishes the AI Action.
+     * @param params Entity IDs to identify the AI Action.
+     * @returns The unpublished AI Action and its metadata.
+     * @throws if the request fails or the AI Action is not found.
+     */
+    unpublish(params: OptionalDefaults<GetSpaceParams & {
+        aiActionId: string;
+    }>): Promise<AiActionProps>;
+    /**
+     * Invokes an AI Action.
+     * @param params Entity IDs to scope where to invoke the AI Action.
+     *               Must include spaceId, environmentId, and aiActionId.
+     * @param payload The invocation payload.
+     * @param headers Optional headers for the request.
+     * @returns A promise resolving with the AI Action Invocation and its metadata.
+     * @throws if the request fails or the payload is malformed.
+     */
+    invoke(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        aiActionId: string;
+    }>, payload: AiActionInvocationType, headers?: Partial<RawAxiosRequestHeaders>): Promise<AiActionInvocationProps>;
+};

package/dist/typings/plain/entities/app-event-subscription.d.ts

@@ -10,6 +10,7 @@ export type AppEventSubscriptionPlainClientAPI = {
      * @throws if the request fails, the App or Event Subscription is not found, or the payload is malformed
      * @example
      * ```javascript
+     * // app event subscription that targets an endpoint url
      * const eventSubscription = await client.appEventSubscription.upsert({
      *   organizationId: '<organization_id>',
      *   appDefinitionId: '<app_definition_id>',
@@ -17,6 +18,30 @@ export type AppEventSubscriptionPlainClientAPI = {
      *   targetUrl: `<target_url>`,
      *   topics: ['<Topic>'],
      * })
+     *
+     * // app event subscription that targets a function and have a filter function
+     * const eventSubscription = await client.appEventSubscription.upsert({
+     *   organizationId: '<organization_id>',
+     *   appDefinitionId: '<app_definition_id>',
+     * }, {
+     *   functions: {
+     *     handler: {
+     *       sys: {
+     *         type: 'Link',
+     *         linkType: 'Function',
+     *         id: '<function_id>',
+     *       },
+     *     },
+     *     filter: {
+     *       sys: {
+     *         type: 'Link',
+     *         linkType: 'Function',
+     *         id: '<function_id>',
+     *       },
+     *     },
+     *   },
+     *   topics: ['<Topic>'],
+     * })
      * ```
      */
     upsert(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppEventSubscriptionProps): Promise<AppEventSubscriptionProps>;