contentful-management 11.44.0 → 11.45.0-beta.2

package/dist/types/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 → types}/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 → types}/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 → types}/create-contentful-api.d.ts

@@ -15,6 +15,7 @@ type CreateSpaceProps = Omit<SpaceProps, 'sys'> & {
  * @private
  */
 export default function createClientApi(makeRequest: MakeRequest): {
+    version: string;
     /**
      * Gets all environment templates for a given organization with the lasted version
      * @param organizationId - Organization ID

package/dist/{typings → types}/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
@@ -1455,14 +1532,14 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
         query?: ReleaseActionQueryOptions;
     }): Promise<import("./common-types").Collection<import("./entities/release-action").ReleaseAction<any>, import("./entities/release-action").ReleaseActionProps<any>>>;
     getUIConfig(): Promise<{
-        update: () => Promise<any & import("./entities/ui-config").UIConfigProps & {
+        update: () => Promise</*elided*/ any & import("./entities/ui-config").UIConfigProps & {
             toPlainObject(): import("./entities/ui-config").UIConfigProps;
         }>;
     } & import("./entities/ui-config").UIConfigProps & {
         toPlainObject(): import("./entities/ui-config").UIConfigProps;
     }>;
     getUserUIConfig(): Promise<{
-        update: () => Promise<any & import("./entities/user-ui-config").UserUIConfigProps & {
+        update: () => Promise</*elided*/ any & import("./entities/user-ui-config").UserUIConfigProps & {
             toPlainObject(): import("./entities/user-ui-config").UserUIConfigProps;
         }>;
     } & import("./entities/user-ui-config").UserUIConfigProps & {

package/dist/{typings → types}/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 → types}/create-ui-config-api.d.ts

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

package/dist/{typings → types}/create-user-ui-config-api.d.ts

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

package/dist/types/entities/function-log.d.ts

@@ -0,0 +1,46 @@
+import type { Link, DefaultElements } from '../common-types';
+import type { MakeRequest } from '../common-types';
+export type FunctionLogProps = {
+    sys: {
+        id: string;
+        type: 'FunctionLog';
+        createdBy: Link<'User'>;
+        createdAt: string;
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+        appDefinition: Link<'AppDefinition'>;
+    };
+    severity: {
+        info: number;
+        warn: number;
+        error: number;
+    };
+    requestId: string;
+    event: {
+        type: string;
+        query: string;
+        isIntrospectionQuery: boolean;
+        variables: Record<string, any>;
+    };
+    messages: Array<{
+        timestamp: number;
+        type: 'INFO' | 'ERROR' | 'WARN';
+        message: string;
+    }>;
+};
+export interface FunctionLog extends FunctionLogProps, DefaultElements<FunctionLogProps> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+export declare function wrapFunctionLog(makeRequest: MakeRequest, data: FunctionLogProps): FunctionLogProps;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-function data
+ * @return Wrapped App Function collection data
+ */
+export declare const wrapFunctionLogCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<FunctionLogProps>) => import("../common-types").Collection<FunctionLogProps, FunctionLogProps>;

package/dist/{typings → types}/entities/function.d.ts

@@ -1,6 +1,5 @@
 import type { Link, DefaultElements } from '../common-types';
 import type { MakeRequest } from '../common-types';
-import createFunctionApi from '../create-function-api';
 export type FunctionProps = {
     sys: {
         id: string;
@@ -26,15 +25,8 @@ export interface Function extends FunctionProps, DefaultElements<FunctionProps>
  * @param data - raw contentful-Function data
  * @return Wrapped Function data
  */
-export declare function wrapFunction(makeRequest: MakeRequest, data: FunctionProps): FunctionProps & ReturnType<typeof createFunctionApi>;
+export declare function wrapFunction(makeRequest: MakeRequest, data: FunctionProps): FunctionProps;
 /**
  * @private
- * @param makeRequest - real) function to make requests via an adapter
- * @param data - raw contentful-function data
- * @return Wrapped App Function collection data
  */
-export declare const wrapFunctionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<FunctionProps>) => import("../common-types").Collection<FunctionProps & {
-    getManyFunctions(): Promise<import("../common-types").Collection<FunctionProps & any, FunctionProps>>;
-    getFunction(functionId: string): Promise<FunctionProps & any>;
-    getManyFunctionsForEnvironment(spaceId: string, environmentId: string, appInstallationId: string): Promise<import("../common-types").Collection<FunctionProps & any, FunctionProps>>;
-}, FunctionProps>;
+export declare const wrapFunctionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<FunctionProps>) => import("../common-types").Collection<FunctionProps, FunctionProps>;

package/dist/{typings → types}/entities/index.d.ts

@@ -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 @@ declare const _default: {
     environmentTemplateInstallation: typeof environmentTemplateInstallation;
     extension: typeof extension;
     func: typeof func;
+    functionLog: typeof functionLog;
     locale: typeof locale;
     organization: typeof organization;
     organizationInvitation: typeof organizationInvitation;

package/dist/{typings → types}/entities/ui-config.d.ts

@@ -44,7 +44,7 @@ export interface UIConfig extends UIConfigProps, DefaultElements<UIConfigProps>
  * @return Wrapped UIConfig
  */
 export declare function wrapUIConfig(makeRequest: MakeRequest, data: UIConfigProps): {
-    update: () => Promise<any & UIConfigProps & {
+    update: () => Promise</*elided*/ any & UIConfigProps & {
         toPlainObject(): UIConfigProps;
     }>;
 } & UIConfigProps & {

package/dist/{typings → types}/entities/user-ui-config.d.ts

@@ -37,7 +37,7 @@ export interface UserUIConfig extends UserUIConfigProps, DefaultElements<UserUIC
  * @return Wrapped UserUIConfig
  */
 export declare function wrapUserUIConfig(makeRequest: MakeRequest, data: UserUIConfigProps): {
-    update: () => Promise<any & UserUIConfigProps & {
+    update: () => Promise</*elided*/ any & UserUIConfigProps & {
         toPlainObject(): UserUIConfigProps;
     }>;
 } & UserUIConfigProps & {

package/dist/{typings/contentful-management.d.ts → types/index.d.ts}

@@ -9,7 +9,7 @@ import type { AdapterParams } from './create-adapter';
 import type { ClientAPI } from './create-contentful-api';
 import type { PlainClientAPI } from './plain/common-types';
 import type { DefaultParams } from './plain/plain-client';
-import * as editorInterfaceDefaults from './constants/editor-interface-defaults';
+import * as editorInterfaceDefaults from './constants/editor-interface-defaults/index';
 export type { ClientAPI } from './create-contentful-api';
 export { asIterator } from './plain/as-iterator';
 export { fetchAll } from './plain/pagination-helper';

package/dist/{typings → types}/plain/common-types.d.ts

@@ -63,7 +63,9 @@ import type { WorkflowPlainClientAPI } from './entities/workflow';
 import type { WorkflowDefinitionPlainClientAPI } from './entities/workflow-definition';
 import type { WorkflowsChangelogPlainClientAPI } from './entities/workflows-changelog';
 import type { DefaultParams, OptionalDefaults } from './wrappers/wrap';
+import type { FunctionLogPlainClientAPI } from './entities/function-log';
 export type PlainClientAPI = {
+    version: string;
     raw: {
         getDefaultParams(): DefaultParams | undefined;
         get<T = unknown>(url: string, config?: RawAxiosRequestConfig): Promise<T>;
@@ -83,6 +85,7 @@ export type PlainClientAPI = {
     appSigningSecret: AppSigningSecretPlainClientAPI;
     appAccessToken: AppAccessTokenPlainClientAPI;
     function: FunctionPlainClientAPI;
+    functionLog: FunctionLogPlainClientAPI;
     editorInterface: EditorInterfacePlainClientAPI;
     space: SpacePlainClientAPI;
     environment: EnvironmentPlainClientAPI;
@@ -175,7 +178,7 @@ export type PlainClientAPI = {
         unpublish<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
             entryId: string;
             locales?: string[];
-        }>): Promise<EntryProps<T>>;
+        }>, rawData?: EntryProps<T>): Promise<EntryProps<T>>;
         archive<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & {
             entryId: string;
         }>): Promise<EntryProps<T>>;
@@ -213,7 +216,7 @@ export type PlainClientAPI = {
         unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & {
             assetId: string;
             locales?: string[];
-        }>): Promise<AssetProps>;
+        }>, rawData?: AssetProps): Promise<AssetProps>;
         archive(params: OptionalDefaults<GetSpaceEnvironmentParams & {
             assetId: string;
         }>): Promise<AssetProps>;

package/dist/types/plain/entities/function-log.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionProp, GetFunctionLogParams, GetManyFunctionLogParams } from '../../common-types';
+import type { FunctionLogProps } from '../../entities/function-log';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type FunctionLogPlainClientAPI = {
+    /**
+     * Fetches the specified FunctionLog
+     * @params spaceId, environmentId, appInstallationId, functionId, logId
+     * @returns the FunctionLog
+     * @throws if the request fails, or the FunctionLog is not found
+     * @example
+     * ```javascript
+     * const functionLog = await client.functionLog.get({
+     *    spaceId: '<space_id>',
+     *    environmentId: '<environment_id>',
+     *    appInstallationId: '<app_installation_id>',
+     *    functionId: '<function_id>',
+     *    logId: '<log_id>'
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetFunctionLogParams>): Promise<FunctionLogProps>;
+    /**
+     * Fetches all FunctionLogs for the given function
+     * @params spaceId, environmentId, appInstallationId, functionId, query
+     * @returns an object containing an array of FunctionLogs
+     * @throws if the request fails, or the FunctionLogs are not found
+     * @example
+     * ```javascript
+     * const functionLogs = await client.functionLog.getAll({
+     *    spaceId: '<space_id>',
+     *    environmentId: '<environment_id>',
+     *    appInstallationId: '<app_installation_id>',
+     *    functionId: '<function_id>',
+     *    query: { limit: 100 }
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetManyFunctionLogParams>): Promise<CollectionProp<FunctionLogProps>>;
+};

package/dist/{typings → types}/plain/entities/function.d.ts

@@ -4,7 +4,7 @@ import type { OptionalDefaults } from '../wrappers/wrap';
 export type FunctionPlainClientAPI = {
     /**
      * Fetches the specified Function
-     * @param params organization ID, app definition ID, entity ID to identify the function
+     * @params organizationId, appDefinitionId, functionId
      * @returns the Function
      * @throws if the request fails, or the Function is not found
      * @example
@@ -19,7 +19,7 @@ export type FunctionPlainClientAPI = {
     get(params: OptionalDefaults<GetFunctionParams>): Promise<FunctionProps>;
     /**
      * Fetches all Functions for the given app
-     * @param params organization ID, app definition ID to identify the functions
+     * @params organizationId, appDefinitionId, query
      * @returns an object containing an array of Functions
      * @throws if the request fails, or the App is not found
      * @example
@@ -27,13 +27,14 @@ export type FunctionPlainClientAPI = {
      * const functions = await client.function.getMany({
      *   organizationId: "<org_id>",
      *   appDefinitionId: "<app_definition_id>",
+     *   query: { 'accepts[all]': '<action>' },
      * });
      * ```
      */
     getMany(params: OptionalDefaults<GetManyFunctionParams>): Promise<CollectionProp<FunctionProps>>;
     /**
      * Fetches all Functions for the given environment
-     * @param params space ID, environment ID, app installation ID to identify the functions
+     * @params spaceId, environmentId, appInstallationId, query
      * @returns an object containing an array of Functions
      * @throws if the request fails, or the Environment is not found
      * @example
@@ -42,6 +43,7 @@ export type FunctionPlainClientAPI = {
      *   spaceId: "<space_id>",
      *   environmentId: "<environment_id>",
      *   appInstallationId: "<app_installation_id>",
+     *   query: { 'accepts[all]': '<action>' },
      * });
      * ```
      */