contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/plain/entities/concept.d.ts

@@ -0,0 +1,147 @@
+import type { CursorPaginatedCollectionProp, DeleteConceptParams, GetConceptDescendantsParams, GetConceptParams, GetManyConceptParams, GetOrganizationParams, UpdateConceptParams } from '../../common-types.js';
+import type { ConceptProps, CreateConceptProps } from '../../entities/concept.js';
+import type { OpPatch } from 'json-patch';
+import type { SetOptional } from 'type-fest';
+export type ConceptPlainClientAPI = {
+    /**
+     * Create Concept
+     * @returns ConceptProps
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/create-a-concept}
+     * @example
+     * ```javascript
+     * const concept = await client.concept.create({
+     *   organizationId: '<organization_id>',
+     * }, conceptProps);
+     * ```
+     */
+    create(params: SetOptional<GetOrganizationParams, 'organizationId'>, payload: CreateConceptProps): Promise<ConceptProps>;
+    /**
+     * Create Concept With Id
+     * @returns ConceptProps
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/create-a-concept-with-user-defined-id}
+     * @example
+     * ```javascript
+     * const concept = await client.concept.createWithId({
+     *   organizationId: '<organization_id>',
+     *   conceptId: '<concept_id>',
+     * }, conceptProps);
+     * ```
+     */
+    createWithId(params: SetOptional<GetConceptParams, 'organizationId'>, payload: CreateConceptProps): Promise<ConceptProps>;
+    /**
+     * Update Concept with PUT
+     * @returns the updated Concept
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/concept}
+     * @example
+     * ```javascript
+     * const updatedConcept = await client.concept.update({
+     *   organizationId: '<organization_id>',
+     *   conceptId: '<concept_id>',
+     *   version: 1,
+     * }, conceptProps);
+     * ```
+     */
+    update(params: SetOptional<UpdateConceptParams, 'organizationId'>, payload: CreateConceptProps): Promise<ConceptProps>;
+    /**
+     * Update Concept with PATCH
+     * @returns the updated Concept
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/concept}
+     * @example
+     * ```javascript
+     * const updatedConcept = await client.concept.patch({
+     *   organizationId: '<organization_id>',
+     *   conceptId: '<concept_id>',
+     *   version: 1,
+     * }, patch);
+     * ```
+     */
+    patch(params: SetOptional<UpdateConceptParams, 'organizationId'>, payload: OpPatch[]): Promise<ConceptProps>;
+    /**
+     * Get Concept
+     * @returns the Concept
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/concept}
+     * @example
+     * ```javascript
+     * const concept = await client.concept.get({
+     *   organizationId: '<organization_id>',
+     *   conceptId: '<concept_id>',
+     * });
+     * ```
+     */
+    get(params: SetOptional<GetConceptParams, 'organizationId'>): Promise<ConceptProps>;
+    /**
+     * Delete Concept
+     * @returns nothing
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/concept}
+     * @example
+     * ```javascript
+     * await client.concept.delete({
+     *   conceptId: '<concept_id>',
+     *   version: 1,
+     * });
+     * ```
+     */
+    delete(params: SetOptional<DeleteConceptParams, 'organizationId'>): Promise<void>;
+    /**
+     * Get many Concepts
+     * @returns list of many Concepts
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/concept-collection}
+     * @example
+     * ```javascript
+     * const concepts = await client.concept.getMany({
+     *   organizationId: '<organization_id>',
+     * });
+     * ```
+     */
+    getMany(params: SetOptional<GetManyConceptParams, 'organizationId'>): Promise<CursorPaginatedCollectionProp<ConceptProps>>;
+    /**
+     * Get number of total Concept
+     * @returns number of total Concept
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/total-concepts}
+     * @example
+     * ```javascript
+     * const {total} = await client.concept.getTotal({
+     *   organizationId: '<organization_id>',
+     * });
+     * ```
+     */
+    getTotal(params: SetOptional<GetOrganizationParams, 'organizationId'>): Promise<{
+        total: number;
+    }>;
+    /**
+     * Get descendant Concepts
+     * @returns list of Concepts
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/descendants}
+     * @example
+     * ```javascript
+     * const concepts = await client.concept.getDescendants({
+     *   organizationId: '<organization_id>',
+     *   conceptId: '<concept_id>',
+     * });
+     * ```
+     */
+    getDescendants(params: SetOptional<GetConceptDescendantsParams, 'organizationId'>): Promise<CursorPaginatedCollectionProp<ConceptProps>>;
+    /**
+     * Get ancestor Concepts
+     * @returns list of ancestor Concepts
+     * @throws if the request fails
+     * @see {@link https://www.contentful.com/developers/docs/references/content-management-api/#/reference/taxonomy/ancestors}
+     * @example
+     * ```javascript
+     * const concepts = await client.concept.getAncestors({
+     *   organizationId: '<organization_id>',
+     *   conceptId: '<concept_id>',
+     * });
+     * ```
+     */
+    getAncestors(params: SetOptional<GetConceptDescendantsParams, 'organizationId'>): Promise<CursorPaginatedCollectionProp<ConceptProps>>;
+};

package/dist/types/plain/entities/editor-interface.d.ts

@@ -0,0 +1,67 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { CollectionProp, GetEditorInterfaceParams, GetSpaceEnvironmentParams, QueryParams } from '../../common-types.js';
+import type { EditorInterfaceProps } from '../../entities/editor-interface.js';
+import type { OptionalDefaults } from '../wrappers/wrap.js';
+export type EditorInterfacePlainClientAPI = {
+    /**
+     * Fetch an Editor Interface
+     * @param params entity IDs to identify the Editor Interface
+     * @returns the Editor Interface config
+     * @throws if the request fails, or the Editor Interface is not found
+     * @example
+     * ```javascript
+     * const editorInterface = await client.editorInterface.get({
+     *   spaceId: "<space_id>",
+     *   environmentId: "<environment_id>",
+     *   contentTypeId: "<content_type_id>",
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetEditorInterfaceParams>): Promise<EditorInterfaceProps>;
+    /**
+     * Fetch all Editor Interfaces for the given Space and Environment
+     * @param params entity IDs to identify the Environment from which to fetch Editor Interfaces
+     * @returns an object containing an array of Editor Interfaces
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const results = await client.editorInterface.getMany({
+     *   spaceId: "<space_id>",
+     *   environmentId: "<environment_id>"
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<EditorInterfaceProps>>;
+    /**
+     * Update an Editor Interface
+     * @param params entity IDs to identify the Editor Interface
+     * @param rawData the updated Editor Interface config
+     * @returns the updated Editor Interface config
+     * @throws if the request fails, the Editor Interface is not found, or the update payload is malformed
+     * @example
+     * ```javascript
+     * const updatedEditorInterface =
+     *   await client.editorInterface.update(
+     *     {
+     *       spaceId: "<space_id>",
+     *       environmentId: "<environment_id>",
+     *       contentTypeId: "<content_type_id>",
+     *     },
+     *     {
+     *       ...currentEditorInterface,
+     *       sidebar: [
+     *         ...(currentEditorInterface.sidebar ?? []),
+     *         {
+     *           widgetId: "translation-widget",
+     *           widgetNamespace: "sidebar-builtin",
+     *           settings: {
+     *             defaultLocale: "en-US",
+     *           },
+     *         },
+     *       ],
+     *     }
+     *   );
+     * ```
+     */
+    update(params: OptionalDefaults<GetEditorInterfaceParams>, rawData: EditorInterfaceProps, headers?: RawAxiosRequestHeaders): Promise<EditorInterfaceProps>;
+};

package/dist/types/plain/entities/environment-alias.d.ts

@@ -0,0 +1,99 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { CollectionProp, GetSpaceEnvAliasParams, GetSpaceParams, PaginationQueryParams } from '../../common-types.js';
+import type { CreateEnvironmentAliasProps, EnvironmentAliasProps } from '../../entities/environment-alias.js';
+import type { OptionalDefaults } from '../wrappers/wrap.js';
+export type EnvironmentAliasPlainClientAPI = {
+    /**
+     * Fetch an environment alias
+     * @param params a space and environment alias id
+     * @returns the environment alias\
+     * @throws if the environment alias does not exist
+     * @example
+     * ```javascript
+     * const environmentAlias = await client.environmentAlias.get({
+     *   spaceId: '<space_id>',
+     *   environmentAliasId: '<environment_alias_id>'
+     * })
+     * ```
+     */
+    get(params: OptionalDefaults<GetSpaceEnvAliasParams>): Promise<EnvironmentAliasProps>;
+    /**
+     * Fetch all environment aliases in a space
+     * @param params a space Id and optional pagination parameters
+     * @returns a collection of environment aliases
+     * @throws if the space does not exist
+     * @example
+     * ```javascript
+     * const environmentAliases = await client.environmentAlias.getMany({
+     *   spaceId: '<space_id>'
+     * })
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>): Promise<CollectionProp<EnvironmentAliasProps>>;
+    /**
+     * Create an environment alias
+     * @param params a space ID to create the environment alias in
+     * @param rawData the environment alias metadata
+     * @param headers optional custom headers
+     * @returns the created environment alias
+     * @throws if the space does not exist, or `rawData` is invalid
+     * @example
+     * ```javascript
+     * const environmentAlias = await client.environmentAlias.createWithId(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentAliasId: '<environment_alias_id>',
+     *   },
+     *   {
+     *     environment: {
+     *       sys: {
+     *         type: 'Link',
+     *         linkType: 'Environment',
+     *         id: '<environment_id>',
+     *       },
+     *     },
+     *   }
+     * );
+     * ```
+     */
+    createWithId(params: OptionalDefaults<GetSpaceEnvAliasParams>, rawData: CreateEnvironmentAliasProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentAliasProps>;
+    /**
+     * Update an environment alias
+     * @param params a space and environment alias id
+     * @param rawData the updated environment alias metadata
+     * @param headers optional custom headers
+     * @returns the updated environment alias
+     * @throws if the environment alias does not exist, or `rawData` is invalid
+     * @example
+     * ```javascript
+     * const environmentAlias = await client.environmentAlias.update(
+     *   {
+     *      spaceId: '<space_id>',
+     *      environmentAliasId: '<environment_alias_id>',
+     *   },
+     *   {
+     *     environment: {
+     *     sys: {
+     *       type: 'Link',
+     *       linkType: 'Environment',
+     *       id: '<environment_id>',
+     *     },
+     *   }
+     * );
+     */
+    update(params: OptionalDefaults<GetSpaceEnvAliasParams>, rawData: EnvironmentAliasProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentAliasProps>;
+    /**
+     * Delete an environment alias
+     * @param params a space and environment alias id
+     * @returns an empty object
+     * @throws if the environment alias does not exist
+     * @example
+     * ```javascript
+     * await client.environmentAlias.delete({
+     *   spaceId: '<space_id>',
+     *   environmentAliasId: '<environment_alias_id>',
+     * })
+     * ```
+     */
+    delete(params: OptionalDefaults<GetSpaceEnvAliasParams>): Promise<any>;
+};

package/dist/types/plain/entities/environment.d.ts

@@ -0,0 +1,116 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { CollectionProp, GetSpaceEnvironmentParams, GetSpaceParams, PaginationQueryParams } from '../../common-types.js';
+import type { CreateEnvironmentProps, EnvironmentProps } from '../../entities/environment.js';
+import type { OptionalDefaults } from '../wrappers/wrap.js';
+export type EnvironmentPlainClientAPI = {
+    /**
+     * Fetch an environment
+     * @param params a space and environment id
+     * @returns the environment
+     * @throws if the environment does not exist
+     * @example
+     * ```javascript
+     * const environment = await client.environment.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>'
+     * })
+     * ```
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<EnvironmentProps>;
+    /**
+     * Fetch all environments in a space
+     * @param params a space Id and optional pagination parameters
+     * @returns a collection of environments
+     * @throws if the space does not exist
+     * @example
+     * ```javascript
+     * const environments = await client.environment.getMany({
+     *   spaceId: '<space_id>'
+     * })
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>): Promise<CollectionProp<EnvironmentProps>>;
+    /**
+     * Create an environment
+     * @param params a space ID to create the environment in
+     * @param rawData the environment metadata
+     * @param headers optional custom headers
+     * @returns the created environment
+     * @throws if the space does not exist, or `rawData` is invalid
+     * @example
+     * ```javascript
+     * const environment = await client.environment.create(
+     *   {
+     *     spaceId: '<space_id>'
+     *   },
+     *   {
+     *      name: 'new-env'
+     *   }
+     * )
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceParams>, rawData: Partial<Pick<EnvironmentProps, 'name'>>, headers?: RawAxiosRequestHeaders): Promise<EnvironmentProps>;
+    /**
+     * Create an environment with a specific ID
+     * @param params a space ID to create the environment in
+     * @param rawData the environment metadata
+     * @param headers optional custom headers
+     * @returns the created environment
+     * @throws if the space does not exist, or `rawData` is invalid
+     * @example
+     * ```javascript
+     * const environment = await client.environment.createWithId(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>'
+     *   },
+     *   {
+     *      name: 'new-env'
+     *   }
+     * )
+     * ```
+     */
+    createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        sourceEnvironmentId?: string;
+    }>, rawData: CreateEnvironmentProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentProps>;
+    /**
+     * Update an environment
+     * @param params a space and environment id
+     * @param rawData the environment metadata
+     * @param headers optional custom headers
+     * @returns the updated environment
+     * @throws if the environment does not exist, or `rawData` is invalid
+     * @example
+     * ```javascript
+     * let environment = await client.environment.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>'
+     * })
+     *
+     * environment = await client.environment.update(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>'
+     *   },
+     *   {
+     *      name: 'updated-env'
+     *   }
+     * )
+     * ```
+     */
+    update(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: EnvironmentProps, headers?: RawAxiosRequestHeaders): Promise<EnvironmentProps>;
+    /**
+     * Delete an environment
+     * @param params a space and environment id
+     * @returns an empty object
+     * @throws if the environment does not exist
+     * @example
+     * ```javascript
+     * await client.environment.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>'
+     * })
+     * ```
+     */
+    delete(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<any>;
+};

package/dist/types/plain/entities/extension.d.ts

@@ -0,0 +1,157 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { CollectionProp, GetExtensionParams, GetSpaceEnvironmentParams, QueryParams } from '../../common-types.js';
+import type { CreateExtensionProps, ExtensionProps } from '../../entities/extension.js';
+import type { OptionalDefaults } from '../wrappers/wrap.js';
+export type ExtensionPlainClientAPI = {
+    /**
+     * Fetches the Extension
+     * @param params entity IDs to identify the Extension
+     * @returns the Extension and its metadata
+     * @throws if the request fails, or the Extension is not found
+     * @example
+     * ```javascript
+     * const uiExtension = await client.extension.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   extensionId: '<extension_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetExtensionParams & QueryParams>): Promise<ExtensionProps>;
+    /**
+     * Fetches all Extensions of a Space/Environment
+     * @param params entity IDs to identify the Space/Environment from which to fetch Extensions
+     * @returns an object containing the array of Extensions
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const results = await client.extension.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<ExtensionProps>>;
+    /**
+     * Creates a new Extension with an auto-generated ID
+     * @param params entity IDs to identify the Environment in which to create the Extension
+     * @param rawData the Extension
+     * @returns the created Extension and its metadata
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const rawData = {
+     *   extension: {
+     *     name: 'My extension',
+     *     src: 'https://www.example.com',
+     *     fieldTypes: [
+     *       {
+     *         type: 'Symbol',
+     *       },
+     *     ],
+     *     sidebar: false,
+     *   }
+     * };
+     * const uiExtension = await client.extension.create(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *   },
+     *   rawData
+     * );
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateExtensionProps, headers?: RawAxiosRequestHeaders): Promise<ExtensionProps>;
+    /**
+     * Creates a new Extension with a given ID
+     * @param params entity IDs to identify the Environment in which to create the Extension
+     * @param rawData the Extension
+     * @returns the created Extension and its metadata
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const rawData = {
+     *   extension: {
+     *     name: 'My extension',
+     *     src: 'https://www.example.com',
+     *     fieldTypes: [
+     *       {
+     *         type: 'Symbol',
+     *       },
+     *     ],
+     *     sidebar: false,
+     *   }
+     * };
+     * const uiExtension = await client.extension.createWithId(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     extensionId: '<extension_id>',
+     *   },
+     *   rawData
+     * );
+     * ```
+     */
+    createWithId(params: OptionalDefaults<GetExtensionParams>, rawData: CreateExtensionProps, headers?: RawAxiosRequestHeaders): Promise<ExtensionProps>;
+    /**
+     * Updates an Extension
+     * @param params entity IDs to identify the Extension
+     * @param rawData the Extension update
+     * @param headers when updating an existing Extension, use the 'X-Contentful-Version' header to specify the last version of the Extension you are updating
+     * @returns the updated Extension and its metadata
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * // Create Extension
+     * let uiExtension = await client.extension.create(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *   },
+     *   {
+     *     extension: {
+     *       name: 'My extension',
+     *       src: 'https://www.example.com',
+     *       fieldTypes: [
+     *         {
+     *           type: 'Symbol',
+     *         },
+     *       ],
+     *       sidebar: false,
+     *     },
+     *   }
+     * );
+     *
+     * // Update Extension
+     * uiExtension = await client.extension.update(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     extensionId: '<extension_id>',
+     *   },
+     *   {
+     *     sys: uiExtension.sys,
+     *     extension: {
+     *       ...uiExtension.extension,
+     *       name: 'Even more awesome extension',
+     *     },
+     *   }
+     * );
+     * ```
+     */
+    update(params: OptionalDefaults<GetExtensionParams>, rawData: ExtensionProps, headers?: RawAxiosRequestHeaders): Promise<ExtensionProps>;
+    /**
+     * Deletes the Extension
+     * @param params entity IDs to identity the Extension
+     * @throws if the request fails, or the Extension is not found
+     * @example
+     * ```javascript
+     * await client.extension.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   extensionId: '<extension_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetExtensionParams>): Promise<any>;
+};

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

@@ -0,0 +1,51 @@
+import type { CollectionProp, GetFunctionLogParams, GetManyFunctionLogParams } from '../../common-types.js';
+import type { FunctionLogProps } from '../../entities/function-log.js';
+import type { OptionalDefaults } from '../wrappers/wrap.js';
+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 start = new Date()
+     * const end = new Date()
+     * start.setHours(start.getHours() - 1)
+     *
+     * const functionLogs = await client.functionLog.getMany({
+     *    spaceId: '<space_id>',
+     *    environmentId: '<environment_id>',
+     *    appInstallationId: '<app_installation_id>',
+     *    functionId: '<function_id>',
+     *    query: {
+     *      // optional limit
+     *      limit: 10,
+     *      // optional interval query
+     *      'sys.createdAt[gte]': start,
+     *      'sys.createdAt[lt]': end,
+     *      // optional cursor based pagination parameters
+     *      pageNext: '<page_next>',
+     *    }
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetManyFunctionLogParams>): Promise<CollectionProp<FunctionLogProps>>;
+};