contentful-management 12.0.0-beta.1 → 12.0.0-beta.11

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

@@ -1,4 +1,4 @@
-import type { MakeRequest } from './common-types';
+import type { MakeRequest } from './common-types.js';
 /**
  * @private
  */
@@ -28,7 +28,7 @@ export default function createUIConfigApi(makeRequest: MakeRequest): {
      * .catch(console.error)
      * ```
      */
-    update: () => Promise</*elided*/ any & import("./entities/ui-config").UIConfigProps & {
-        toPlainObject(): import("./entities/ui-config").UIConfigProps;
+    update: () => Promise</*elided*/ any & import("./entities/ui-config.js").UIConfigProps & {
+        toPlainObject(): import("./entities/ui-config.js").UIConfigProps;
     }>;
 };

package/dist/types/create-ui-config-api.js

@@ -0,0 +1,52 @@
+import { wrapUIConfig } from './entities/ui-config.js';
+
+/**
+ * @private
+ */
+function createUIConfigApi(makeRequest) {
+    const getParams = (self) => {
+        const uiConfig = self.toPlainObject();
+        return {
+            params: {
+                spaceId: uiConfig.sys.space.sys.id,
+                environmentId: uiConfig.sys.environment.sys.id,
+            },
+            raw: uiConfig,
+        };
+    };
+    return {
+        /**
+         * 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: async function update() {
+            const { raw, params } = getParams(this);
+            const data = await makeRequest({
+                entityType: 'UIConfig',
+                action: 'update',
+                params,
+                payload: raw,
+            });
+            return wrapUIConfig(makeRequest, data);
+        },
+    };
+}
+
+export { createUIConfigApi as default };

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

@@ -1,4 +1,4 @@
-import type { MakeRequest } from './common-types';
+import type { MakeRequest } from './common-types.js';
 /**
  * @private
  */
@@ -28,7 +28,7 @@ export default function createUserUIConfigApi(makeRequest: MakeRequest): {
      * .catch(console.error)
      * ```
      */
-    update: () => Promise</*elided*/ any & import("./entities/user-ui-config").UserUIConfigProps & {
-        toPlainObject(): import("./entities/user-ui-config").UserUIConfigProps;
+    update: () => Promise</*elided*/ any & import("./entities/user-ui-config.js").UserUIConfigProps & {
+        toPlainObject(): import("./entities/user-ui-config.js").UserUIConfigProps;
     }>;
 };

package/dist/types/create-user-ui-config-api.js

@@ -0,0 +1,52 @@
+import { wrapUserUIConfig } from './entities/user-ui-config.js';
+
+/**
+ * @private
+ */
+function createUserUIConfigApi(makeRequest) {
+    const getParams = (self) => {
+        const userUIConfig = self.toPlainObject();
+        return {
+            params: {
+                spaceId: userUIConfig.sys.space.sys.id,
+                environmentId: userUIConfig.sys.environment.sys.id,
+            },
+            raw: userUIConfig,
+        };
+    };
+    return {
+        /**
+         * 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: async function update() {
+            const { raw, params } = getParams(this);
+            const data = await makeRequest({
+                entityType: 'UserUIConfig',
+                action: 'update',
+                params,
+                payload: raw,
+            });
+            return wrapUserUIConfig(makeRequest, data);
+        },
+    };
+}
+
+export { createUserUIConfigApi as default };

package/dist/types/enhance-with-methods.js

@@ -0,0 +1,24 @@
+/**
+ * This method enhances a base object which would normally contain data, with
+ * methods from another object that might work on manipulating that data.
+ * All the added methods are set as non enumerable, non configurable, and non
+ * writable properties. This ensures that if we try to clone or stringify the
+ * base object, we don't have to worry about these additional methods.
+ * @private
+ * @param {object} baseObject - Base object with data
+ * @param {object} methodsObject - Object with methods as properties. The key
+ * values used here will be the same that will be defined on the baseObject.
+ */
+function enhanceWithMethods(baseObject, methodsObject) {
+    return Object.keys(methodsObject).reduce((enhancedObject, methodName) => {
+        Object.defineProperty(enhancedObject, methodName, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: methodsObject[methodName],
+        });
+        return enhancedObject;
+    }, baseObject);
+}
+
+export { enhanceWithMethods as default };

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

@@ -1,10 +1,10 @@
-import type { DefaultElements, MakeRequest, BasicMetaSysProps, Link } from '../common-types';
+import type { DefaultElements, MakeRequest, BasicMetaSysProps, Link } from '../common-types.js';
 type Application = {
     id?: string;
     name?: string;
     sys: Link<'Application'>;
 };
-type AccessTokenSysProps = BasicMetaSysProps<'PersonalAccessToken', 'User'> & {
+type AccessTokenSysProps = BasicMetaSysProps & {
     application: Application | null;
     expiresAt: string | null;
     lastUsedAt: string | null;
@@ -57,5 +57,5 @@ export declare function wrapAccessToken(makeRequest: MakeRequest, data: AccessTo
  * @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 declare const wrapAccessTokenCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AccessTokenProps>) => import("../common-types.js").Collection<AccessToken, AccessTokenProps>;
 export {};

package/dist/types/entities/access-token.js

@@ -0,0 +1,33 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  access token data
+ * @return Wrapped access token
+ */
+function wrapAccessToken(makeRequest, data) {
+    const AccessToken = toPlainObject(copy(data));
+    const accessTokenWithMethods = enhanceWithMethods(AccessToken, {
+        revoke: function () {
+            return makeRequest({
+                entityType: 'AccessToken',
+                action: 'revoke',
+                params: { tokenId: data.sys.id },
+            }).then((data) => wrapAccessToken(makeRequest, data));
+        },
+    });
+    return freezeSys(accessTokenWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw access collection data
+ * @return Wrapped access token collection data
+ */
+const wrapAccessTokenCollection = wrapCollection(wrapAccessToken);
+
+export { wrapAccessToken, wrapAccessTokenCollection };

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

@@ -1,15 +1,7 @@
-import type { DefaultElements, Link, MakeRequest } from '../common-types';
+import type { DefaultElements, Link, MakeRequest } from '../common-types.js';
 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 type InvocationStatus = 'SCHEDULED' | 'IN_PROGRESS' | 'FAILED' | 'COMPLETED' | 'CANCELLED';
+export type InvocationResultType = 'text';
 export declare const AiActionOutputFormat: {
     readonly RichText: "RichText";
     readonly Markdown: "Markdown";
@@ -87,4 +79,4 @@ export declare function wrapAiActionInvocation(makeRequest: MakeRequest, data: A
  * @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>;
+export declare const wrapAiActionInvocationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AiActionInvocationProps>) => import("../common-types.js").Collection<AiActionInvocation, AiActionInvocationProps>;

package/dist/types/entities/ai-action-invocation.js

@@ -0,0 +1,16 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+
+/**
+ * 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.
+ */
+function wrapAiActionInvocation(makeRequest, data) {
+    const invocation = toPlainObject(copy(data));
+    return freezeSys(invocation);
+}
+
+export { wrapAiActionInvocation };

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

@@ -1,23 +1,8 @@
-import type { DefaultElements, Link, 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"
-}
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types.js';
+import { type AiActionInvocationType, type AiActionInvocation } from './ai-action-invocation.js';
+export type VariableType = 'ResourceLink' | 'Text' | 'StandardInput' | 'Locale' | 'MediaReference' | 'Reference' | 'SmartContext';
 export type ReferenceVariableConfiguration = {
-    allowedEntities: Array<EntityTypeEntry>;
+    allowedEntities: Array<'Entry'>;
 };
 export type VariableConfiguration = {
     strict: boolean;
@@ -52,13 +37,20 @@ export type AiActionTestCase = {
 export interface AiActionQueryOptions {
     limit?: number;
     skip?: number;
-    status?: StatusFilter;
+    status?: 'all' | 'published';
 }
 export type AiActionProps = {
-    sys: MetaSysProps<'AiAction', 'User' | 'AppDefinition'> & {
+    sys: MetaSysProps & {
         type: 'AiAction';
-        space: Link<'Space'>;
+        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;
     };
@@ -77,4 +69,4 @@ export interface AiAction extends AiActionProps, DefaultElements<AiActionProps>
     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>;
+export declare const wrapAiActionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AiActionProps>) => import("../common-types.js").Collection<AiAction, AiActionProps>;

package/dist/types/entities/ai-action.js

@@ -0,0 +1,72 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapAiActionInvocation } from './ai-action-invocation.js';
+
+function createAiActionApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        aiActionId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AiAction',
+                action: 'update',
+                params: getParams(self),
+                payload: self,
+            }).then((data) => wrapAiAction(makeRequest, data));
+        },
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AiAction',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+        publish: function publish() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AiAction',
+                action: 'publish',
+                params: {
+                    aiActionId: self.sys.id,
+                    spaceId: self.sys.space.sys.id,
+                    version: self.sys.version,
+                },
+            }).then((data) => wrapAiAction(makeRequest, data));
+        },
+        unpublish: function unpublish() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AiAction',
+                action: 'unpublish',
+                params: getParams(self),
+            }).then((data) => wrapAiAction(makeRequest, data));
+        },
+        invoke: function invoke(environmentId, payload) {
+            const self = this;
+            return makeRequest({
+                entityType: 'AiAction',
+                action: 'invoke',
+                params: {
+                    spaceId: self.sys.space.sys.id,
+                    environmentId,
+                    aiActionId: self.sys.id,
+                },
+                payload,
+            }).then((data) => wrapAiActionInvocation(makeRequest, data));
+        },
+    };
+}
+function wrapAiAction(makeRequest, data) {
+    const aiAction = toPlainObject(copy(data));
+    const aiActionWithMethods = enhanceWithMethods(aiAction, createAiActionApi(makeRequest));
+    return freezeSys(aiActionWithMethods);
+}
+const wrapAiActionCollection = wrapCollection(wrapAiAction);
+
+export { wrapAiAction, wrapAiActionCollection };

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

@@ -1,6 +1,6 @@
-import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types';
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types.js';
 export type ApiKeyProps = {
-    sys: MetaSysProps<'User'>;
+    sys: MetaSysProps;
     name: string;
     accessToken: string;
     environments: Link<'Environment'>[];
@@ -63,4 +63,4 @@ export declare function wrapApiKey(makeRequest: MakeRequest, data: ApiKeyProps):
  * @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>;
+export declare const wrapApiKeyCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<ApiKeyProps>) => import("../common-types.js").Collection<ApiKey, ApiKeyProps>;

package/dist/types/entities/api-key.js

@@ -0,0 +1,53 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createApiKeyApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space?.sys.id ?? '',
+        apiKeyId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const self = this;
+            return makeRequest({
+                entityType: 'ApiKey',
+                action: 'update',
+                params: getParams(self),
+                payload: self,
+                headers: {},
+            }).then((data) => wrapApiKey(makeRequest, data));
+        },
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'ApiKey',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key data
+ */
+function wrapApiKey(makeRequest, data) {
+    const apiKey = toPlainObject(copy(data));
+    const apiKeyWithMethods = enhanceWithMethods(apiKey, createApiKeyApi(makeRequest));
+    return freezeSys(apiKeyWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key collection data
+ * @return Wrapped api key collection data
+ */
+const wrapApiKeyCollection = wrapCollection(wrapApiKey);
+
+export { wrapApiKey, wrapApiKeyCollection };

package/dist/types/entities/app-access-token.d.ts

@@ -1,6 +1,6 @@
 import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types';
-type AppAccessTokenSys = Except<BasicMetaSysProps<'AppAccessToken', 'User'>, 'version' | 'id'> & {
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
+type AppAccessTokenSys = Except<BasicMetaSysProps, 'version' | 'id'> & {
     space: Link<'Space'>;
     environment: Link<'Environment'>;
     appDefinition: Link<'AppDefinition'>;

package/dist/types/entities/app-access-token.js

@@ -0,0 +1,15 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw app access token data
+ * @return {AppAccessToken} Wrapped AppAccessToken data
+ */
+function wrapAppAccessToken(_makeRequest, data) {
+    const appAccessToken = toPlainObject(copy(data));
+    return freezeSys(appAccessToken);
+}
+
+export { wrapAppAccessToken };

package/dist/types/entities/app-action-call.d.ts

@@ -1,13 +1,35 @@
-import type { Except } from 'type-fest';
-import type { BasicMetaSysProps, CreateWithResponseParams, DefaultElements, Link, MakeRequest } from '../common-types';
-import type { WebhookCallDetailsProps } from './webhook';
-type AppActionCallSys = Except<BasicMetaSysProps<'AppActionCall', 'User'>, 'version'> & {
-    appDefinition: Link<'AppDefinition'>;
-    space: Link<'Space'>;
-    environment: Link<'Environment'>;
-    action: Link<'AppAction'>;
+import type { Except, JsonValue } from 'type-fest';
+import type { BasicMetaSysProps, AppActionCallRetryOptions, DefaultElements, MakeRequest, SysLink, CreateWithResponseParams, CreateWithResultParams, GetAppActionCallDetailsParams, GetAppActionCallParamsWithId } from '../common-types.js';
+import type { WebhookCallDetailsProps } from './webhook.js';
+type AppActionCallSys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: SysLink;
+    space: SysLink;
+    environment: SysLink;
+    action: SysLink;
+    appActionCallResponse?: SysLink;
+} & (AppActionCallSucceeded | AppActionCallProcessing | AppActionCallFailed);
+type RetryOptions = AppActionCallRetryOptions;
+export type AppActionCallStatus = 'processing' | 'succeeded' | 'failed';
+export interface AppActionCallErrorProps {
+    sys: {
+        type: 'Error';
+        id: string;
+    };
+    message: string;
+    details?: Record<string, unknown>;
+    statusCode?: number;
+}
+export type AppActionCallSucceeded = {
+    status: 'succeeded';
+    result: JsonValue;
+};
+export type AppActionCallProcessing = {
+    status: 'processing';
+};
+export type AppActionCallFailed = {
+    status: 'failed';
+    error: AppActionCallErrorProps;
 };
-type RetryOptions = Pick<CreateWithResponseParams, 'retries' | 'retryInterval'>;
 export type AppActionCallProps = {
     /**
      * System metadata
@@ -17,22 +39,38 @@ export type AppActionCallProps = {
 export type CreateAppActionCallProps = {
     /** The body for the call */
     parameters: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
 };
 type AppActionCallApi = {
-    createWithResponse(): Promise<AppActionCallResponse>;
-    getCallDetails(): Promise<AppActionCallResponse>;
+    createWithResponse(params: CreateWithResponseParams, payload: CreateAppActionCallProps): Promise<AppActionCallResponse>;
+    getCallDetails(params: GetAppActionCallDetailsParams): Promise<AppActionCallResponse>;
+    get(params: GetAppActionCallParamsWithId): Promise<AppActionCallProps>;
+    createWithResult(params: CreateWithResultParams, payload: CreateAppActionCallProps): Promise<AppActionCallProps>;
 };
 export type AppActionCallResponse = WebhookCallDetailsProps;
-export interface AppActionCallResponseData extends AppActionCallResponse, DefaultElements<AppActionCallResponse>, AppActionCallApi {
+export interface AppActionCallRawResponseProps {
+    sys: {
+        id: string;
+        type: 'AppActionCallResponse';
+        space: SysLink;
+        environment: SysLink;
+        appInstallation: SysLink;
+        appAction: SysLink;
+        createdAt: string;
+        createdBy: SysLink;
+    };
+    response: {
+        headers?: {
+            contentType?: string;
+        };
+        statusCode?: number;
+        body: string;
+    };
 }
-export interface AppActionCall extends AppActionCallProps, DefaultElements<AppActionCallProps> {
+export interface AppActionCallResponseData extends AppActionCallResponse, DefaultElements<AppActionCallResponse>, AppActionCallApi {
 }
-/**
- * @private
- */
-export default function createAppActionCallApi(makeRequest: MakeRequest, retryOptions?: RetryOptions): AppActionCallApi;
+export type AppActionCall = AppActionCallProps & DefaultElements<AppActionCallProps>;
 /**
  * @private
  * @param http - HTTP client instance

package/dist/types/entities/app-action-call.js

@@ -0,0 +1,65 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createAppActionCallApi(makeRequest, retryOptions) {
+    return {
+        createWithResponse: function (params, payload) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'createWithResponse',
+                params: { ...params, ...retryOptions },
+                payload: payload,
+            }).then((data) => wrapAppActionCallResponse(makeRequest, data));
+        },
+        getCallDetails: function getCallDetails(params) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'getCallDetails',
+                params,
+            }).then((data) => wrapAppActionCallResponse(makeRequest, data));
+        },
+        get: function get(params) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'get',
+                params,
+            }).then((data) => wrapAppActionCall(makeRequest, data));
+        },
+        createWithResult: function (params, payload) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'createWithResult',
+                params: { ...params, ...retryOptions },
+                payload: payload,
+            }).then((data) => wrapAppActionCall(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+function wrapAppActionCall(makeRequest, data) {
+    const signedRequest = toPlainObject(copy(data));
+    const signedRequestWithMethods = enhanceWithMethods(signedRequest, createAppActionCallApi(makeRequest));
+    return signedRequestWithMethods;
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+function wrapAppActionCallResponse(makeRequest, data, retryOptions) {
+    const appActionCallResponse = toPlainObject(copy(data));
+    const appActionCallResponseWithMethods = enhanceWithMethods(appActionCallResponse, createAppActionCallApi(makeRequest, retryOptions));
+    return appActionCallResponseWithMethods;
+}
+
+export { wrapAppActionCall, wrapAppActionCallResponse };