contentful-management 12.4.0 → 12.6.0-dev.1

package/dist/types/plain/entities/component-type.d.ts

@@ -1,13 +1,13 @@
-import type { GetSpaceEnvironmentParams, CollectionProp } from '../../common-types';
-import type { ComponentTypeQueryOptions, ComponentTypeProps } from '../../entities/component-type';
+import type { GetSpaceEnvironmentParams, GetComponentTypeParams, ExoCursorPaginatedCollectionProp } from '../../common-types';
+import type { ComponentTypeQueryOptions, ComponentTypeProps, CreateComponentTypeProps, UpsertComponentTypeProps } from '../../entities/component-type';
 import type { OptionalDefaults } from '../wrappers/wrap';
 export type ComponentTypePlainClientAPI = {
     /**
      * Fetches all component types for a space and environment
      * @param params the space and environment IDs and query parameters
-     * @param params.query.experienceCtId the experience component type ID
      * @param params.query.limit the maximum number of component types to return
-     * @param params.query.skip the number of component types to skip
+     * @param params.query.pageNext cursor token for the next page
+     * @param params.query.pagePrev cursor token for the previous page
      * @returns a collection of component types
      * @throws if the request fails, or the space, environment, or experience component type is not found
      * @internal - Experimental endpoint, subject to breaking changes without notice
@@ -17,14 +17,126 @@ export type ComponentTypePlainClientAPI = {
      *   spaceId: '<space_id>',
      *   environmentId: '<environment_id>',
      *   query: {
-     *     _experienceCtId: '<experience_ct_id>',
      *     limit: 10,
-     *     skip: 0,
      *   },
      * });
      * ```
      */
     getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
         query: ComponentTypeQueryOptions;
-    }>): Promise<CollectionProp<ComponentTypeProps>>;
+    }>): Promise<ExoCursorPaginatedCollectionProp<ComponentTypeProps>>;
+    /**
+     * Fetches a single component type by ID
+     * @param params the space, environment, and component type IDs
+     * @returns the component type
+     * @throws if the request fails, or the space, environment, or component type is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const componentType = await client.componentType.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   componentTypeId: '<component_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetComponentTypeParams>): Promise<ComponentTypeProps>;
+    /**
+     * Creates a new component type
+     * @param params the space and environment IDs
+     * @param rawData the component type data to create
+     * @returns the created component type
+     * @throws if the request fails
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const componentType = await client.componentType.create({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * }, {
+     *   name: 'My Component',
+     *   description: 'A new component type',
+     *   viewports: [],
+     *   contentProperties: [],
+     *   designProperties: [],
+     *   dimensionKeyMap: { designProperties: {} },
+     * });
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateComponentTypeProps): Promise<ComponentTypeProps>;
+    /**
+     * Upserts a component type (creates or updates via PUT)
+     * @param params the space, environment, and component type IDs
+     * @param rawData the component type data to upsert (include sys.version for updates, omit for creates)
+     * @returns the upserted component type
+     * @throws if the request fails
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const current = await client.componentType.get({ componentTypeId: '<component_id>' });
+     * const updated = await client.componentType.upsert({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   componentTypeId: '<component_id>',
+     * }, {
+     *   sys: { id: current.sys.id, type: 'ComponentType', version: current.sys.version },
+     *   name: 'Updated Component',
+     *   ...otherFields,
+     * });
+     * ```
+     */
+    upsert(params: OptionalDefaults<GetComponentTypeParams>, rawData: UpsertComponentTypeProps): Promise<ComponentTypeProps>;
+    /**
+     * Deletes a single component type
+     * @param params the space, environment, and component type IDs
+     * @throws if the request fails, or the component type is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * await client.componentType.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   componentTypeId: '<component_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetComponentTypeParams>): Promise<void>;
+    /**
+     * Publishes a component type
+     * @param params the space, environment, and component type IDs, and the version number
+     * @returns the published component type
+     * @throws if the request fails, or the component type is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const componentType = await client.componentType.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   componentTypeId: '<component_type_id>',
+     *   version: <version>,
+     * });
+     * ```
+     */
+    publish(params: OptionalDefaults<GetComponentTypeParams & {
+        version: number;
+    }>): Promise<ComponentTypeProps>;
+    /**
+     * Unpublishes a component type
+     * @param params the space, environment, and component type IDs, and the version number
+     * @returns the unpublished component type
+     * @throws if the request fails, or the component type is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const componentType = await client.componentType.unpublish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   componentTypeId: '<component_type_id>',
+     *   version: <version>,
+     * });
+     * ```
+     */
+    unpublish(params: OptionalDefaults<GetComponentTypeParams & {
+        version: number;
+    }>): Promise<ComponentTypeProps>;
 };

package/dist/types/plain/entities/data-assembly.d.ts

@@ -0,0 +1,178 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { GetDataAssemblyParams, GetSpaceEnvironmentParams } from '../../common-types';
+import type { CreateDataAssemblyProps, DataAssemblyProps, DataAssemblyQueryOptions, UpdateDataAssemblyProps, DataAssemblyCollection } from '../../entities/data-assembly';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type DataAssemblyPlainClientAPI = {
+    /**
+     * Fetches all data assemblies for a space and environment
+     * @param params the space, environment IDs and query options (see {@link DataAssemblyQueryOptions})
+     * @returns a collection of data assemblies
+     * @throws if the request fails, or the space or environment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssemblies = await client.dataAssembly.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   query: {
+     *     limit: 10,
+     *   },
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        query: DataAssemblyQueryOptions;
+    }>): Promise<DataAssemblyCollection>;
+    /**
+     * Fetches a single data assembly by ID
+     * @param params the space, environment, and data assembly IDs
+     * @returns the data assembly
+     * @throws if the request fails, or the data assembly is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssembly = await client.dataAssembly.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   dataAssemblyId: '<data_assembly_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetDataAssemblyParams>): Promise<DataAssemblyProps>;
+    /**
+     * Creates a new data assembly
+     * @param params the space and environment IDs
+     * @param rawData the data assembly data to create
+     * @param headers optional custom headers
+     * @returns the created data assembly
+     * @throws if the request fails
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssembly = await client.dataAssembly.create({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * }, {
+     *   sys: { type: 'DataAssembly', dataType: [] },
+     *   metadata: { tags: [] },
+     *   name: 'My Assembly',
+     *   description: 'A data assembly',
+     *   parameters: {},
+     *   resolvers: {},
+     *   return: {},
+     * });
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateDataAssemblyProps, headers?: RawAxiosRequestHeaders): Promise<DataAssemblyProps>;
+    /**
+     * Updates a data assembly with PUT
+     * @param params the space, environment, and data assembly IDs
+     * @param rawData the data assembly data to update (must include sys.version)
+     * @param headers optional custom headers
+     * @returns the updated data assembly
+     * @throws if the request fails, or the data assembly is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const updated = await client.dataAssembly.update(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     dataAssemblyId: '<data_assembly_id>',
+     *   },
+     *   { ...dataAssembly, name: 'Updated Name' },
+     * );
+     * ```
+     */
+    update(params: OptionalDefaults<GetDataAssemblyParams>, rawData: UpdateDataAssemblyProps, headers?: RawAxiosRequestHeaders): Promise<DataAssemblyProps>;
+    /**
+     * Deletes a data assembly
+     * @param params the space, environment, and data assembly IDs
+     * @returns void
+     * @throws if the request fails, or the data assembly is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * await client.dataAssembly.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   dataAssemblyId: '<data_assembly_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetDataAssemblyParams>): Promise<void>;
+    /**
+     * Publishes a data assembly
+     * @param params the space, environment, and data assembly IDs, and the version number
+     * @returns the published data assembly
+     * @throws if the request fails, or the data assembly is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssembly = await client.dataAssembly.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   dataAssemblyId: '<data_assembly_id>',
+     *   version: 1,
+     * });
+     * ```
+     */
+    publish(params: OptionalDefaults<GetDataAssemblyParams & {
+        version: number;
+    }>): Promise<DataAssemblyProps>;
+    /**
+     * Unpublishes a data assembly
+     * @param params the space, environment, and data assembly IDs, and the version number
+     * @returns the unpublished data assembly
+     * @throws if the request fails, or the data assembly is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssembly = await client.dataAssembly.unpublish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   dataAssemblyId: '<data_assembly_id>',
+     *   version: 1,
+     * });
+     * ```
+     */
+    unpublish(params: OptionalDefaults<GetDataAssemblyParams & {
+        version: number;
+    }>): Promise<DataAssemblyProps>;
+    /**
+     * Fetches all published data assemblies for a space and environment
+     * @param params the space, environment IDs and query options (see {@link DataAssemblyQueryOptions})
+     * @returns a collection of published data assemblies
+     * @throws if the request fails, or the space or environment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssemblies = await client.dataAssembly.getManyPublished({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   query: {
+     *     limit: 10,
+     *   },
+     * });
+     * ```
+     */
+    getManyPublished(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        query: DataAssemblyQueryOptions;
+    }>): Promise<DataAssemblyCollection>;
+    /**
+     * Fetches a single published data assembly by ID
+     * @param params the space, environment, and data assembly IDs
+     * @returns the published data assembly
+     * @throws if the request fails, or the data assembly is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const dataAssembly = await client.dataAssembly.getPublished({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   dataAssemblyId: '<data_assembly_id>',
+     * });
+     * ```
+     */
+    getPublished(params: OptionalDefaults<GetDataAssemblyParams>): Promise<DataAssemblyProps>;
+};

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

@@ -0,0 +1,165 @@
+import type { ExoCursorPaginatedCollectionProp, GetSpaceEnvironmentParams, GetExperienceParams } from '../../common-types';
+import type { CreateExperienceProps, UpsertExperienceProps, ExperienceLocalePublishPayload, ExperienceProps, ExperienceQueryOptions } from '../../entities/experience';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type ExperiencePlainClientAPI = {
+    /**
+     * Fetches all experiences for a space and environment
+     * @param params the space, environment IDs and query options (see {@link ExperienceQueryOptions})
+     * @returns a collection of experiences
+     * @throws if the request fails, or the space or environment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const experiences = await client.experience.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   query: {
+     *     limit: 10,
+     *   },
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        query: ExperienceQueryOptions;
+    }>): Promise<ExoCursorPaginatedCollectionProp<ExperienceProps>>;
+    /**
+     * Fetches a single experience by ID
+     * @param params the space ID, environment ID, and experience ID
+     * @returns the experience
+     * @throws if the request fails, or the space, environment, or experience is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const experience = await client.experience.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetExperienceParams>): Promise<ExperienceProps>;
+    /**
+     * Creates a new experience
+     * @param params the space ID and environment ID
+     * @param rawData the experience data to create
+     * @returns the created experience
+     * @throws if the request fails
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const experience = await client.experience.create({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * }, {
+     *   name: 'My Experience',
+     *   description: 'A new experience',
+     *   template: { sys: { type: 'Link', linkType: 'Template', id: '<template_id>' } },
+     *   viewports: [],
+     *   contentProperties: {},
+     *   designProperties: {},
+     *   dimensionKeyMap: { designProperties: {} },
+     * });
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateExperienceProps): Promise<ExperienceProps>;
+    /**
+     * Upserts an experience (creates or updates via PUT)
+     * @param params the space ID, environment ID, and experience ID
+     * @param rawData the experience data to upsert (include sys.version for updates, omit for creates)
+     * @returns the upserted experience
+     * @throws if the request fails
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const current = await client.experience.get({ experienceId: '<experience_id>' });
+     * const updated = await client.experience.upsert({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     * }, {
+     *   sys: { id: current.sys.id, type: 'Experience', version: current.sys.version },
+     *   name: 'Updated Experience',
+     *   ...otherFields,
+     * });
+     * ```
+     */
+    upsert(params: OptionalDefaults<GetExperienceParams>, rawData: UpsertExperienceProps): Promise<ExperienceProps>;
+    /**
+     * Deletes an experience
+     * @param params the space ID, environment ID, and experience ID
+     * @returns void
+     * @throws if the request fails, or the experience is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * await client.experience.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetExperienceParams>): Promise<void>;
+    /**
+     * Publishes an experience, optionally targeting specific locales.
+     *
+     * When called without a payload, the experience is fully published across all locales.
+     * Pass `{ add: ['en-US'] }` to publish specific locales, or `{ remove: ['de-DE'] }`
+     * to remove specific locales from an already-published experience.
+     * The payload is a union — only `add` or `remove` can be sent per request, not both.
+     *
+     * @param params the space ID, environment ID, experience ID, and the version number
+     * @param payload optional locale-based publish payload
+     * @returns the published experience
+     * @throws if the request fails, or the experience is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * // Full publish (all locales)
+     * const experience = await client.experience.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     *   version: 1,
+     * });
+     *
+     * // Publish specific locales
+     * const experience = await client.experience.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     *   version: 1,
+     * }, { add: ['en-US', 'de-DE'] });
+     *
+     * // Remove specific locales from publishing
+     * const experience = await client.experience.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     *   version: 1,
+     * }, { remove: ['de-DE'] });
+     * ```
+     */
+    publish(params: OptionalDefaults<GetExperienceParams & {
+        version: number;
+    }>, payload?: ExperienceLocalePublishPayload): Promise<ExperienceProps>;
+    /**
+     * Unpublishes an experience
+     * @param params the space ID, environment ID, experience ID, and the version number
+     * @returns the unpublished experience
+     * @throws if the request fails, or the experience is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const experience = await client.experience.unpublish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   experienceId: '<experience_id>',
+     *   version: <version>,
+     * });
+     * ```
+     */
+    unpublish(params: OptionalDefaults<GetExperienceParams & {
+        version: number;
+    }>): Promise<ExperienceProps>;
+};

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

@@ -0,0 +1,134 @@
+import type { ExoCursorPaginatedCollectionProp, GetFragmentParams, GetSpaceEnvironmentParams } from '../../common-types';
+import type { CreateFragmentProps, FragmentProps, FragmentQueryOptions, UpdateFragmentProps } from '../../entities/fragment';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type FragmentPlainClientAPI = {
+    /**
+     * Fetches all fragments for a space and environment
+     * @param params the space, environment IDs and query options (see {@link FragmentQueryOptions})
+     * @returns a collection of fragments
+     * @throws if the request fails, or the space or environment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const fragments = await client.fragment.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   query: {
+     *     limit: 10,
+     *   },
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        query: FragmentQueryOptions;
+    }>): Promise<ExoCursorPaginatedCollectionProp<FragmentProps>>;
+    /**
+     * Fetches a single fragment by ID
+     * @param params the space, environment, and fragment IDs
+     * @returns the fragment
+     * @throws if the request fails, or the space, environment, or fragment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const fragment = await client.fragment.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   fragmentId: '<fragment_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetFragmentParams>): Promise<FragmentProps>;
+    /**
+     * Creates a new fragment
+     * @param params the space and environment IDs
+     * @param data the fragment data
+     * @returns the created fragment
+     * @throws if the request fails, or the space or environment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const fragment = await client.fragment.create({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * }, {
+     *   name: 'My Fragment',
+     *   description: 'A new fragment',
+     *   componentType: { sys: { type: 'Link', linkType: 'ComponentType', id: '<component_type_id>' } },
+     *   viewports: [],
+     *   designProperties: {},
+     *   dimensionKeyMap: { designProperties: {} },
+     * });
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateFragmentProps): Promise<FragmentProps>;
+    /**
+     * Updates a fragment with PUT
+     * @param params the space, environment, and fragment IDs
+     * @param data the fragment data (including sys.version)
+     * @returns the updated fragment
+     * @throws if the request fails, or the space, environment, or fragment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const fragment = await client.fragment.update({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   fragmentId: '<fragment_id>',
+     * }, fragmentData);
+     * ```
+     */
+    update(params: OptionalDefaults<GetFragmentParams>, data: UpdateFragmentProps): Promise<FragmentProps>;
+    /**
+     * Deletes a fragment
+     * @param params the space, environment, and fragment IDs
+     * @throws if the request fails, or the space, environment, or fragment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * await client.fragment.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   fragmentId: '<fragment_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetFragmentParams>): Promise<void>;
+    /**
+     * Publishes a fragment
+     * @param params the space, environment, and fragment IDs, plus the current version
+     * @returns the published fragment
+     * @throws if the request fails, or the space, environment, or fragment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const fragment = await client.fragment.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   fragmentId: '<fragment_id>',
+     *   version: 1,
+     * });
+     * ```
+     */
+    publish(params: OptionalDefaults<GetFragmentParams & {
+        version: number;
+    }>): Promise<FragmentProps>;
+    /**
+     * Unpublishes a fragment
+     * @param params the space, environment, and fragment IDs, plus the current version
+     * @returns the unpublished fragment
+     * @throws if the request fails, or the space, environment, or fragment is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const fragment = await client.fragment.unpublish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   fragmentId: '<fragment_id>',
+     *   version: 2,
+     * });
+     * ```
+     */
+    unpublish(params: OptionalDefaults<GetFragmentParams & {
+        version: number;
+    }>): Promise<FragmentProps>;
+};

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

@@ -1,7 +1,7 @@
 import type { RawAxiosRequestHeaders } from 'axios';
 import type { GetSpaceParams, QueryParams, CollectionProp, CursorPaginatedCollectionProp, BasicCursorPaginationOptions, GetOrganizationParams } from '../../common-types';
 import type { OptionalDefaults } from '../wrappers/wrap';
-import type { SpaceProps } from '../../entities/space';
+import type { SpaceIncludeParam, SpaceIncludes, SpaceProps } from '../../entities/space';
 export type SpacePlainClientAPI = {
     /**
      * Fetches a space
@@ -14,7 +14,9 @@ export type SpacePlainClientAPI = {
      * });
      * ```
      */
-    get(params: OptionalDefaults<GetSpaceParams>): Promise<SpaceProps>;
+    get(params: OptionalDefaults<GetSpaceParams & SpaceIncludeParam>): Promise<SpaceProps & {
+        includes?: SpaceIncludes;
+    }>;
     /**
      * Fetches all the spaces that the logged in user has access to
      * @param params (optional) filter and pagination query parameters
@@ -31,11 +33,15 @@ export type SpacePlainClientAPI = {
     getMany(params: OptionalDefaults<{
         query?: QueryParams['query'];
         organizationId?: string;
-    }>): Promise<CollectionProp<SpaceProps>>;
+    } & SpaceIncludeParam>): Promise<CollectionProp<SpaceProps> & {
+        includes?: SpaceIncludes;
+    }>;
     getMany(params: OptionalDefaults<{
         query: BasicCursorPaginationOptions;
         organizationId?: string;
-    }>): Promise<CursorPaginatedCollectionProp<SpaceProps>>;
+    } & SpaceIncludeParam>): Promise<CursorPaginatedCollectionProp<SpaceProps> & {
+        includes?: SpaceIncludes;
+    }>;
     /**
      * Fetches all the spaces in the given organization
      * @param params the organization ID and query parameters