contentful-management 11.43.2 → 11.45.0-beta.1

package/dist/es-modules/adapters/REST/endpoints/function-log.js

@@ -0,0 +1,22 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as raw from './raw';
+const FunctionLogAlphaHeaders = {
+  'x-contentful-enable-alpha-feature': 'function-logs'
+};
+const baseURL = params => `/spaces/${params.spaceId}/environments/${params.environmentId}/app_installations/${params.appInstallationId}/functions/${params.functionId}/logs`;
+const getURL = params => `/spaces/${params.spaceId}/environments/${params.environmentId}/app_installations/${params.appInstallationId}/functions/${params.functionId}/logs/${params.logId}`;
+export const get = (http, params) => {
+  return raw.get(http, getURL(params), {
+    headers: _objectSpread({}, FunctionLogAlphaHeaders)
+  });
+};
+export const getMany = (http, params) => {
+  return raw.get(http, baseURL(params), {
+    params: params.query,
+    headers: _objectSpread({}, FunctionLogAlphaHeaders)
+  });
+};

package/dist/es-modules/adapters/REST/endpoints/function.js

@@ -9,8 +9,12 @@ export const get = (http, params) => {
   return raw.get(http, getFunctionUrl(params));
 };
 export const getMany = (http, params) => {
-  return raw.get(http, getManyUrl(params));
+  return raw.get(http, getManyUrl(params), {
+    params: params.query
+  });
 };
 export const getManyForEnvironment = (http, params) => {
-  return raw.get(http, getFunctionsEnvURL(params));
+  return raw.get(http, getFunctionsEnvURL(params), {
+    params: params.query
+  });
 };

package/dist/es-modules/adapters/REST/endpoints/index.js

@@ -27,6 +27,7 @@ import * as EnvironmentTemplate from './environment-template';
 import * as EnvironmentTemplateInstallation from './environment-template-installation';
 import * as Extension from './extension';
 import * as Function from './function';
+import * as FunctionLog from './function-log';
 import * as Http from './http';
 import * as Locale from './locale';
 import * as Organization from './organization';
@@ -89,6 +90,7 @@ export default {
   EnvironmentTemplateInstallation,
   Extension,
   Function,
+  FunctionLog,
   Http,
   Locale,
   Organization,

package/dist/es-modules/common-types.js

@@ -10,6 +10,10 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+// Base interface for shared fields
+
+// Interfaces for each “exclusive” shape
+
 /**
  * @private
  */

package/dist/es-modules/contentful-management.js

@@ -46,7 +46,7 @@ function createClient(params, opts = {}) {
   const sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
   const userAgent = getUserAgentHeader(
   // @ts-expect-error
-  `${sdkMain}/${"11.43.2"}`, params.application, params.integration, params.feature);
+  `${sdkMain}/${"11.45.0-beta.1"}`, params.application, params.integration, params.feature);
   const adapter = createAdapter(_objectSpread(_objectSpread({}, params), {}, {
     userAgent
   }));

package/dist/es-modules/create-environment-api.js

@@ -14,6 +14,8 @@ import { wrapTag, wrapTagCollection } from './entities/tag';
 import { wrapUIConfig } from './entities/ui-config';
 import { wrapUserUIConfig } from './entities/user-ui-config';
 import { wrapEnvironmentTemplateInstallationCollection } from './entities/environment-template-installation';
+import { wrapFunctionCollection } from './entities/function';
+import { wrapFunctionLog, wrapFunctionLogCollection } from './entities/function-log';
 
 /**
  * @private
@@ -1658,6 +1660,123 @@ export default function createEnvironmentApi(makeRequest) {
         payload: data
       }).then(payload => wrapAppAccessToken(makeRequest, payload));
     },
+    /**
+     * Gets a collection of Functions for a given environment
+     * @param appInstallationId
+     * @param {import('../common-types').AcceptsQueryOptions} query  - optional query parameter for filtering functions by action
+     * @return Promise containing wrapped collection of Functions in an environment
+     * @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.getFunctionsForEnvironment('<app-installation-id>',  { 'accepts[all]': '<action>' }))
+     *    .then((functions) => console.log(functions.items))
+     *    .catch(console.error)
+     * ```
+     */
+    getFunctionsForEnvironment(appInstallationId, query) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'getManyForEnvironment',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          appInstallationId,
+          query
+        }
+      }).then(data => wrapFunctionCollection(makeRequest, data));
+    },
+    /**
+     * Gets a collection of FunctionLogs for a given app installation id and FunctionId
+     * @param appInstallationId
+     * @param functionId
+     * @param {import('../common-types').CursorBasedParams} query  - optional query parameter for pagination (limit, nextPage, prevPage)
+     * @return Promise containing wrapped collection of FunctionLogs
+     * * @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.getFunctionLogs(
+     *          '<app-installation-id>',
+     *          '<function-id>',
+     *          { limit: 10 },
+     *       )
+     *     )
+     *     .then((functionLogs) => console.log(functionLog.items))
+     *     .catch(console.error)
+     * ```
+     */
+    getFunctionLogs(appInstallationId, functionId, query) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'FunctionLog',
+        action: 'getMany',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          appInstallationId,
+          functionId,
+          query: query ? createRequestConfig({
+            query
+          }).params : undefined
+        }
+      }).then(data => wrapFunctionLogCollection(makeRequest, data));
+    },
+    /**
+     * Gets a FunctionLog by appInstallationId, functionId and logId
+     * @param appInstallationId
+     * @param functionId
+     * @param logId
+     * @return Promise containing a wrapped FunctionLog
+     * @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.getFunctionLog(
+     *          '<app-installation-id>',
+     *          '<function-id>',
+     *          '<log-id>'
+     *       )
+     *     )
+     *     .then((functionLog) => console.log(functionLog))
+     *     .catch(console.error)
+     * ```
+     */
+    getFunctionLog(appInstallationId, functionId, logId) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'FunctionLog',
+        action: 'get',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          appInstallationId,
+          functionId,
+          logId
+        }
+      }).then(data => wrapFunctionLog(makeRequest, data));
+    },
     /**
      * Gets all snapshots of an entry
      * @func getEntrySnapshots

package/dist/es-modules/create-organization-api.js

@@ -68,6 +68,10 @@ export default function createOrganizationApi(makeRequest) {
     wrapAppAction,
     wrapAppActionCollection
   } = entities.appAction;
+  const {
+    wrapFunction,
+    wrapFunctionCollection
+  } = entities.func;
   const {
     wrapRoleCollection
   } = entities.role;
@@ -1247,6 +1251,56 @@ export default function createOrganizationApi(makeRequest) {
           appDefinitionId
         }
       }).then(payload => wrapAppActionCollection(makeRequest, payload));
+    },
+    /**
+     * Gets an app function
+     * @param appDefinitionId
+     * @param functionId
+     * @returns Promise for a Function
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * const org = await client.getOrganization('<org_id>')
+     * const functions = await org.getFunction('<app_definition_id>', '<function_id>')
+     */
+    getFunction(appDefinitionId, functionId) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'get',
+        params: {
+          organizationId: raw.sys.id,
+          appDefinitionId,
+          functionId
+        }
+      }).then(payload => wrapFunction(makeRequest, payload));
+    },
+    /**
+     * Gets a collection of app functions.
+     * @param appDefinitionId
+     * @param {import('../common-types').AcceptsQueryOptions} query  - optional query parameter for filtering functions by action
+     * @returns Promise for a Function
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * const org = await client.getOrganization('<org_id>')
+     * const functions = await org.getFunctions('<app_definition_id>', { 'accepts[all]': '<action>' })
+     */
+    getFunctions(appDefinitionId, query) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'getMany',
+        params: {
+          organizationId: raw.sys.id,
+          appDefinitionId,
+          query
+        }
+      }).then(payload => wrapFunctionCollection(makeRequest, payload));
     }
   };
 }

package/dist/es-modules/entities/function-log.js

@@ -0,0 +1,21 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+export function wrapFunctionLog(makeRequest, data) {
+  const functionLog = toPlainObject(copy(data));
+  return freezeSys(functionLog);
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-function data
+ * @return Wrapped App Function collection data
+ */
+export const wrapFunctionLogCollection = wrapCollection(wrapFunctionLog);

package/dist/es-modules/entities/function.js

@@ -2,7 +2,48 @@ import { freezeSys, toPlainObject } from 'contentful-sdk-core';
 import copy from 'fast-copy';
 import { wrapCollection } from '../common-utils';
 import enhanceWithMethods from '../enhance-with-methods';
-import createFunctionApi from '../create-function-api';
+/**
+ * @private
+ */
+function createFunctionApi(makeRequest) {
+  return {
+    getFunction: function getFunction() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'get',
+        params: {
+          organizationId: raw.sys.organization.sys.id,
+          appDefinitionId: raw.sys.appDefinition.sys.id,
+          functionId: raw.sys.id
+        }
+      }).then(data => wrapFunction(makeRequest, data));
+    },
+    getManyFunctions: function getManyFunctions() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'getMany',
+        params: {
+          appDefinitionId: raw.sys.appDefinition.sys.id,
+          organizationId: raw.sys.organization.sys.id
+        }
+      }).then(data => wrapFunctionCollection(makeRequest, data));
+    },
+    getManyFunctionsForEnvironment(spaceId, environmentId, appInstallationId) {
+      return makeRequest({
+        entityType: 'Function',
+        action: 'getManyForEnvironment',
+        params: {
+          spaceId: spaceId,
+          environmentId: environmentId,
+          appInstallationId: appInstallationId
+        }
+      }).then(data => wrapFunctionCollection(makeRequest, data));
+    }
+  };
+}
+
 /**
  * @private
  * @param makeRequest - (real) function to make requests via an adapter
@@ -10,15 +51,11 @@ import createFunctionApi from '../create-function-api';
  * @return Wrapped Function data
  */
 export function wrapFunction(makeRequest, data) {
-  const appAction = toPlainObject(copy(data));
-  const appActionWithMethods = enhanceWithMethods(appAction, createFunctionApi(makeRequest));
-  return freezeSys(appActionWithMethods);
+  const func = toPlainObject(copy(data));
+  const funcWithMethods = enhanceWithMethods(func, createFunctionApi(makeRequest));
+  return freezeSys(funcWithMethods);
 }
-
 /**
  * @private
- * @param makeRequest - real) function to make requests via an adapter
- * @param data - raw contentful-function data
- * @return Wrapped App Function collection data
  */
 export const wrapFunctionCollection = wrapCollection(wrapFunction);

package/dist/es-modules/entities/index.js

@@ -24,6 +24,7 @@ import * as environmentTemplate from './environment-template';
 import * as environmentTemplateInstallation from './environment-template-installation';
 import * as extension from './extension';
 import * as func from './function';
+import * as functionLog from './function-log';
 import * as locale from './locale';
 import * as organization from './organization';
 import * as organizationInvitation from './organization-invitation';
@@ -86,6 +87,7 @@ export default {
   environmentTemplateInstallation,
   extension,
   func,
+  functionLog,
   locale,
   organization,
   organizationInvitation,

package/dist/es-modules/plain/entities/function-log.js

@@ -0,0 +1 @@
+export {};

package/dist/es-modules/plain/plain-client.js

@@ -143,6 +143,10 @@ export const createPlainClient = (makeRequest, defaults) => {
       getMany: wrap(wrapParams, 'Function', 'getMany'),
       getManyForEnvironment: wrap(wrapParams, 'Function', 'getManyForEnvironment')
     },
+    functionLog: {
+      get: wrap(wrapParams, 'FunctionLog', 'get'),
+      getMany: wrap(wrapParams, 'FunctionLog', 'getMany')
+    },
     editorInterface: {
       get: wrap(wrapParams, 'EditorInterface', 'get'),
       getMany: wrap(wrapParams, 'EditorInterface', 'getMany'),

package/dist/typings/adapters/REST/endpoints/function-log.d.ts

@@ -0,0 +1,3 @@
+import type { RestEndpoint } from '../types';
+export declare const get: RestEndpoint<'FunctionLog', 'get'>;
+export declare const getMany: RestEndpoint<'FunctionLog', 'getMany'>;

package/dist/typings/adapters/REST/endpoints/index.d.ts

@@ -27,6 +27,7 @@ import * as EnvironmentTemplate from './environment-template';
 import * as EnvironmentTemplateInstallation from './environment-template-installation';
 import * as Extension from './extension';
 import * as Function from './function';
+import * as FunctionLog from './function-log';
 import * as Http from './http';
 import * as Locale from './locale';
 import * as Organization from './organization';
@@ -89,6 +90,7 @@ declare const _default: {
     EnvironmentTemplateInstallation: typeof EnvironmentTemplateInstallation;
     Extension: typeof Extension;
     Function: typeof Function;
+    FunctionLog: typeof FunctionLog;
     Http: typeof Http;
     Locale: typeof Locale;
     Organization: typeof Organization;

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

@@ -60,6 +60,7 @@ import type { UserUIConfigProps } from './entities/user-ui-config';
 import type { CompleteWorkflowParams, CreateWorkflowParams, CreateWorkflowProps, DeleteWorkflowParams, WorkflowProps, WorkflowQueryOptions } from './entities/workflow';
 import type { CreateWorkflowDefinitionParams, CreateWorkflowDefinitionProps, DeleteWorkflowDefinitionParams, WorkflowDefinitionProps, WorkflowDefinitionQueryOptions } from './entities/workflow-definition';
 import type { WorkflowsChangelogEntryProps, WorkflowsChangelogQueryOptions } from './entities/workflows-changelog-entry';
+import type { FunctionLogProps } from './entities/function-log';
 export interface DefaultElements<TPlainObject extends object = object> {
     toPlainObject(): TPlainObject;
 }
@@ -205,6 +206,24 @@ export interface BasicCursorPaginationOptions extends Omit<BasicQueryOptions, 's
     pageNext?: string;
     pagePrev?: string;
 }
+interface CursorPaginationBase {
+    limit?: number;
+}
+interface CursorPaginationPageNext extends CursorPaginationBase {
+    pageNext: string;
+    pagePrev?: never;
+}
+interface CursorPaginationPagePrev extends CursorPaginationBase {
+    pageNext?: never;
+    pagePrev: string;
+}
+interface CursorPaginationNone extends CursorPaginationBase {
+    pageNext?: never;
+    pagePrev?: never;
+}
+export interface AcceptsQueryOptions {
+    'accepts[all]'?: string;
+}
 export type KeyValueMap = Record<string, any>;
 /**
  * @private
@@ -363,6 +382,8 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'Function', 'get', UA>): MRReturn<'Function', 'get'>;
     (opts: MROpts<'Function', 'getMany', UA>): MRReturn<'Function', 'getMany'>;
     (opts: MROpts<'Function', 'getManyForEnvironment', UA>): MRReturn<'Function', 'getManyForEnvironment'>;
+    (opts: MROpts<'FunctionLog', 'get', UA>): MRReturn<'FunctionLog', 'get'>;
+    (opts: MROpts<'FunctionLog', 'getMany', UA>): MRReturn<'FunctionLog', 'getMany'>;
     (opts: MROpts<'Locale', 'get', UA>): MRReturn<'Locale', 'get'>;
     (opts: MROpts<'Locale', 'getMany', UA>): MRReturn<'Locale', 'getMany'>;
     (opts: MROpts<'Locale', 'delete', UA>): MRReturn<'Locale', 'delete'>;
@@ -1497,6 +1518,18 @@ export type MRActions = {
             return: CollectionProp<FunctionProps>;
         };
     };
+    FunctionLog: {
+        get: {
+            params: GetFunctionLogParams;
+            return: FunctionLogProps;
+            headers?: RawAxiosRequestHeaders;
+        };
+        getMany: {
+            params: GetManyFunctionLogParams;
+            return: CollectionProp<FunctionLogProps>;
+            headers?: RawAxiosRequestHeaders;
+        };
+    };
     Locale: {
         get: {
             params: GetSpaceEnvironmentParams & {
@@ -2381,10 +2414,16 @@ export type GetEnvironmentTemplateParams = GetOrganizationParams & {
 export type GetFunctionParams = GetAppDefinitionParams & {
     functionId: string;
 };
-export type GetManyFunctionParams = GetAppDefinitionParams;
-export type GetFunctionForEnvParams = GetSpaceEnvironmentParams & {
+export type GetManyFunctionParams = AcceptsQueryParams & GetAppDefinitionParams;
+export type GetFunctionForEnvParams = AcceptsQueryParams & GetSpaceEnvironmentParams & {
     appInstallationId: string;
 };
+export type GetManyFunctionLogParams = CursorBasedParams & GetFunctionForEnvParams & {
+    functionId: string;
+};
+export type GetFunctionLogParams = GetManyFunctionLogParams & {
+    logId: string;
+};
 export type GetOrganizationParams = {
     organizationId: string;
 };
@@ -2515,6 +2554,15 @@ export type SpaceQueryParams = {
 export type PaginationQueryParams = {
     query?: PaginationQueryOptions;
 };
+export type CursorPaginationXORParams = {
+    query?: (CursorPaginationPageNext | CursorPaginationPagePrev | CursorPaginationNone) & {
+        limit?: number;
+    };
+};
+export type CursorBasedParams = CursorPaginationXORParams;
+export type AcceptsQueryParams = {
+    query?: AcceptsQueryOptions;
+};
 export declare enum ScheduledActionReferenceFilters {
     contentTypeAnnotationNotIn = "sys.contentType.metadata.annotations.ContentType[nin]"
 }

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

@@ -1,5 +1,5 @@
 import type { Stream } from 'stream';
-import type { BasicCursorPaginationOptions, QueryOptions } from './common-types';
+import type { AcceptsQueryOptions, BasicCursorPaginationOptions, CursorBasedParams, QueryOptions } from './common-types';
 import type { BasicQueryOptions, MakeRequest } from './common-types';
 import type { CreateAppInstallationProps } from './entities/app-installation';
 import type { CreateAppSignedRequestProps } from './entities/app-signed-request';
@@ -1123,6 +1123,83 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
      *  ```
      */
     createAppAccessToken(appDefinitionId: string, data: CreateAppAccessTokenProps): Promise<import("./entities/app-access-token").AppAccessToken>;
+    /**
+     * Gets a collection of Functions for a given environment
+     * @param appInstallationId
+     * @param {import('../common-types').AcceptsQueryOptions} query  - optional query parameter for filtering functions by action
+     * @return Promise containing wrapped collection of Functions in an environment
+     * @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.getFunctionsForEnvironment('<app-installation-id>',  { 'accepts[all]': '<action>' }))
+     *    .then((functions) => console.log(functions.items))
+     *    .catch(console.error)
+     * ```
+     */
+    getFunctionsForEnvironment(appInstallationId: string, query?: AcceptsQueryOptions): Promise<import("./common-types").Collection<import("./entities/function").FunctionProps, import("./entities/function").FunctionProps>>;
+    /**
+     * Gets a collection of FunctionLogs for a given app installation id and FunctionId
+     * @param appInstallationId
+     * @param functionId
+     * @param {import('../common-types').CursorBasedParams} query  - optional query parameter for pagination (limit, nextPage, prevPage)
+     * @return Promise containing wrapped collection of FunctionLogs
+     * * @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.getFunctionLogs(
+     *          '<app-installation-id>',
+     *          '<function-id>',
+     *          { limit: 10 },
+     *       )
+     *     )
+     *     .then((functionLogs) => console.log(functionLog.items))
+     *     .catch(console.error)
+     * ```
+     */
+    getFunctionLogs(appInstallationId: string, functionId: string, query?: CursorBasedParams): Promise<import("./common-types").Collection<import("./entities/function-log").FunctionLogProps, import("./entities/function-log").FunctionLogProps>>;
+    /**
+     * Gets a FunctionLog by appInstallationId, functionId and logId
+     * @param appInstallationId
+     * @param functionId
+     * @param logId
+     * @return Promise containing a wrapped FunctionLog
+     * @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.getFunctionLog(
+     *          '<app-installation-id>',
+     *          '<function-id>',
+     *          '<log-id>'
+     *       )
+     *     )
+     *     .then((functionLog) => console.log(functionLog))
+     *     .catch(console.error)
+     * ```
+     */
+    getFunctionLog(appInstallationId: string, functionId: string, logId: string): Promise<import("./entities/function-log").FunctionLogProps>;
     /**
      * Gets all snapshots of an entry
      * @func getEntrySnapshots

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

@@ -2,7 +2,7 @@ import type { Stream } from 'stream';
 import type { CreateTeamMembershipProps } from './entities/team-membership';
 import type { CreateTeamProps } from './entities/team';
 import type { CreateOrganizationInvitationProps } from './entities/organization-invitation';
-import type { BasicQueryOptions, MakeRequest, QueryOptions, QueryParams } from './common-types';
+import type { AcceptsQueryOptions, BasicQueryOptions, MakeRequest, QueryOptions, QueryParams } from './common-types';
 import type { CreateAppDefinitionProps } from './entities/app-definition';
 import type { CreateAppActionProps } from './entities/app-action';
 import type { CreateAppSigningSecretProps } from './entities/app-signing-secret';
@@ -855,4 +855,32 @@ export default function createOrganizationApi(makeRequest: MakeRequest): {
      * ```
      */
     getAppActions(appDefinitionId: string): Promise<import("./common-types").Collection<import("./entities/app-action").AppAction, import("./entities/app-action").AppActionProps>>;
+    /**
+     * Gets an app function
+     * @param appDefinitionId
+     * @param functionId
+     * @returns Promise for a Function
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * const org = await client.getOrganization('<org_id>')
+     * const functions = await org.getFunction('<app_definition_id>', '<function_id>')
+     */
+    getFunction(appDefinitionId: string, functionId: string): Promise<import("./export-types").FunctionProps>;
+    /**
+     * Gets a collection of app functions.
+     * @param appDefinitionId
+     * @param {import('../common-types').AcceptsQueryOptions} query  - optional query parameter for filtering functions by action
+     * @returns Promise for a Function
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * const org = await client.getOrganization('<org_id>')
+     * const functions = await org.getFunctions('<app_definition_id>', { 'accepts[all]': '<action>' })
+     */
+    getFunctions(appDefinitionId: string, query?: AcceptsQueryOptions): Promise<import("./common-types").Collection<import("./export-types").FunctionProps, import("./export-types").FunctionProps>>;
 };

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

@@ -6,6 +6,7 @@ export type AppInstallationProps = {
         appDefinition: SysLink;
         environment: SysLink;
         space: SysLink;
+        organization: SysLink;
     };
     /**
      * Free-form installation parameters (API limits stringified length to 32KB)