contentful-management 12.5.0 → 12.6.0-dev.1

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

@@ -0,0 +1,119 @@
+import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, Link, MetadataProps, ResourceLink } from '../common-types';
+export type DataAssemblyPrimitiveDataTypeField = {
+    id: string;
+    name: string;
+    type: string;
+    required: boolean;
+    source?: string;
+};
+export type DataAssemblyTypeRefDataTypeField = {
+    id: string;
+    name: string;
+    type: 'TypeRef';
+    ref: ResourceLink<'Contentful:DataAssembly'>;
+    required: boolean;
+};
+export type DataAssemblyDataTypeField = DataAssemblyPrimitiveDataTypeField | DataAssemblyTypeRefDataTypeField;
+export type DataAssemblyLinkParameter = {
+    name?: string;
+    description?: string;
+    type: 'Link';
+    linkType: string;
+    allowedContentTypes: string[];
+};
+export type DataAssemblyResourceLinkParameter = {
+    name?: string;
+    description?: string;
+    type: 'ResourceLink';
+    linkType: string;
+    allowedResources: Array<{
+        type: string;
+        source: string;
+        allowedTypes: string[];
+    }>;
+};
+export type DataAssemblyParameterConfig = Record<string, DataAssemblyLinkParameter | DataAssemblyResourceLinkParameter>;
+export type DataAssemblyGraphQLResolver = {
+    source: 'Contentful:GraphQL';
+    query: string;
+    parameters?: Record<string, unknown>;
+};
+export type DataAssemblyNestedResolver = {
+    source: 'Contentful:DataAssembly';
+    dataAssembly: ResourceLink<'Contentful:DataAssembly'>;
+    parameters?: Record<string, unknown>;
+};
+export type DataAssemblyResolverDefinition = DataAssemblyGraphQLResolver | DataAssemblyNestedResolver;
+export type DataAssemblyResolverConfig = Record<string, DataAssemblyResolverDefinition>;
+export type DataAssemblyReturnMappingSelectValue = string | {
+    $on: {
+        type: Record<string, DataAssemblyReturnMappingSelectValue>;
+        default?: DataAssemblyReturnMappingSelectValue;
+    };
+} | {
+    [key: string]: DataAssemblyReturnMappingSelectValue;
+};
+export type DataAssemblyReturnMappingFromObject = {
+    $from: {
+        source: string;
+        select?: DataAssemblyReturnMappingSelectValue;
+    };
+};
+export type DataAssemblyReturnMappingValue = string | DataAssemblyReturnMappingFromObject | {
+    [key: string]: DataAssemblyReturnMappingValue;
+};
+export type DataAssemblyReturnMappingConfig = Record<string, DataAssemblyReturnMappingValue>;
+export type DataAssemblySys = {
+    id: string;
+    type: 'DataAssembly';
+    dataType: DataAssemblyDataTypeField[];
+    version: number;
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    createdBy: Link<'User'>;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+    updatedBy?: Link<'User'>;
+    publishedAt?: string | Date;
+    publishedVersion?: number;
+    publishedCounter?: number;
+    firstPublishedAt?: string | Date;
+    publishedBy?: Link<'User'> | Link<'AppDefinition'>;
+    variant?: string;
+};
+type DataAssemblyCommonProps = {
+    metadata: Pick<MetadataProps, 'tags'>;
+    name: string;
+    description: string;
+    parameters: DataAssemblyParameterConfig;
+    resolvers: DataAssemblyResolverConfig;
+    return: DataAssemblyReturnMappingConfig;
+};
+export type DataAssemblyProps = DataAssemblyCommonProps & {
+    sys: DataAssemblySys;
+};
+export type CreateDataAssemblyProps = DataAssemblyCommonProps & {
+    sys: {
+        type: 'DataAssembly';
+        variant?: string;
+        dataType: DataAssemblyDataTypeField[];
+    };
+};
+export type UpdateDataAssemblyProps = DataAssemblyCommonProps & {
+    sys: {
+        id: string;
+        type: 'DataAssembly';
+        variant?: string;
+        version: number;
+        dataType: DataAssemblyDataTypeField[];
+    };
+};
+export type DataAssemblyQueryOptions = CursorPaginationParams & {
+    'sys.id[in]'?: string;
+};
+export type DataAssemblyCollection = ExoCursorPaginatedCollectionProp<DataAssemblyProps> & {
+    errors?: {
+        notFoundIds: string[];
+    };
+};
+export {};

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

@@ -0,0 +1,89 @@
+import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExperienceMetadataProps, ExoQueryFilters, Link } from '../common-types';
+import type { ComponentTypeViewport, DimensionedDesignPropertyValue, FragmentNode } from './component-type';
+export type ExperienceDimensionKeyMap = {
+    designProperties: Record<string, {
+        breakpoint: string;
+    }>;
+};
+export type ExperienceContentBindings = {
+    sys: {
+        type: 'Link';
+        id: string;
+        linkType: 'DataAssembly';
+    };
+    parameters: Record<string, Link<string>>;
+};
+export type ExperienceSys = {
+    id: string;
+    type: 'Experience';
+    version: number;
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    template?: Link<'Template'>;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: Link<'User'>;
+    updatedBy: Link<'User'>;
+    archivedAt?: string;
+    archivedBy?: Link<'User'>;
+    archivedVersion?: number;
+    variant?: string;
+    variantType?: string;
+    variantDimension?: string;
+    publishedAt?: string;
+    publishedVersion?: number;
+    publishedCounter?: number;
+    firstPublishedAt?: string;
+    publishedBy?: Link<'User'> | Link<'AppDefinition'>;
+    localeStatus?: Record<string, 'draft' | 'published' | 'changed'>;
+};
+type ExperienceCommonProps = {
+    name: string;
+    description: string;
+    viewports: ComponentTypeViewport[];
+    contentProperties: Record<string, unknown>;
+    designProperties: Record<string, DimensionedDesignPropertyValue>;
+    dimensionKeyMap: ExperienceDimensionKeyMap;
+    contentBindings?: ExperienceContentBindings;
+    metadata?: ExperienceMetadataProps;
+    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
+};
+export type ExperienceProps = ExperienceCommonProps & {
+    sys: ExperienceSys;
+};
+export type ExperienceQueryOptions = CursorPaginationParams & ExoQueryFilters & {
+    order?: string;
+};
+export type ExperienceLocalePublishPayload = {
+    add: string[];
+} | {
+    remove: string[];
+};
+export type CreateExperienceProps = ExperienceCommonProps & {
+    template: Link<'Template'>;
+};
+export type UpsertExperienceProps = ExperienceCommonProps & {
+    sys: {
+        id: string;
+        type: 'Experience';
+        version?: number;
+    };
+    template?: Link<'Template'>;
+};
+export type InlineFragmentNode = {
+    id: string;
+    nodeType: 'InlineFragment';
+    componentTypeId: string;
+    designProperties: Record<string, DimensionedDesignPropertyValue>;
+    contentBindings?: ExperienceContentBindings;
+    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
+};
+export type ExperienceCollection = ExoCursorPaginatedCollectionProp<ExperienceProps>;
+export type ReleaseExperienceSys = Omit<ExperienceSys, 'variant' | 'variantType' | 'variantDimension'> & {
+    release: Link<'Release'>;
+};
+export type ReleaseExperience = Omit<ExperienceProps, 'sys'> & {
+    sys: ReleaseExperienceSys;
+};
+export type ReleaseExperienceCollection = ExoCursorPaginatedCollectionProp<ReleaseExperience>;
+export {};

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

@@ -0,0 +1,52 @@
+import type { Except } from 'type-fest';
+import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExoQueryFilters, ExperienceMetadataProps, Link } from '../common-types';
+import type { ComponentTypeViewport, DimensionedDesignPropertyValue, FragmentNode } from './component-type';
+import type { ExperienceContentBindings, ExperienceDimensionKeyMap, InlineFragmentNode } from './experience';
+export type FragmentSys = {
+    id: string;
+    type: 'Fragment';
+    version: number;
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    componentType: Link<'ComponentType'>;
+    archivedAt?: string;
+    archivedBy?: Link<'User'>;
+    archivedVersion?: number;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: Link<'User'>;
+    updatedBy: Link<'User'>;
+    variant?: string;
+    variantType?: string;
+    variantDimension?: string;
+    publishedAt?: string;
+    publishedVersion?: number;
+    publishedCounter?: number;
+    firstPublishedAt?: string;
+    publishedBy?: Link<'User'> | Link<'AppDefinition'>;
+};
+export type FragmentProps = {
+    sys: FragmentSys;
+    name: string;
+    description: string;
+    viewports: ComponentTypeViewport[];
+    designProperties: Record<string, DimensionedDesignPropertyValue>;
+    dimensionKeyMap: ExperienceDimensionKeyMap;
+    contentBindings?: ExperienceContentBindings;
+    metadata?: ExperienceMetadataProps;
+    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
+};
+export type CreateFragmentProps = Except<FragmentProps, 'sys'> & {
+    componentType: Link<'ComponentType'>;
+};
+export type UpdateFragmentProps = Omit<FragmentProps, 'sys'> & {
+    sys: {
+        id: string;
+        type: 'Fragment';
+        version: number;
+    };
+};
+export type FragmentQueryOptions = CursorPaginationParams & ExoQueryFilters & {
+    order?: string;
+};
+export type FragmentCollection = ExoCursorPaginatedCollectionProp<FragmentProps>;

package/dist/types/entities/template.d.ts

@@ -0,0 +1,48 @@
+import type { Except } from 'type-fest';
+import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExoMetadataProps, ExoQueryFilters, Link } from '../common-types';
+import type { ComponentTypeContentProperty, ComponentTypeDesignProperty, ComponentTypeDimensionKeyMap, ComponentTypeSlotDefinition, ComponentTypeViewport, DataAssemblyLink, TreeNode } from './component-type';
+export type TemplateSys = {
+    id: string;
+    type: 'Template';
+    version: number;
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    fieldStatus?: Record<string, Record<string, 'draft' | 'published' | 'changed'>>;
+    publishedAt?: string;
+    publishedVersion?: number;
+    publishedCounter?: number;
+    firstPublishedAt?: string;
+    publishedBy?: Link<'User'> | Link<'AppDefinition'>;
+    variant?: string;
+    variantType?: string;
+    variantDimension?: string;
+    createdAt: string;
+    createdBy: Link<'User'>;
+    updatedAt: string;
+    updatedBy: Link<'User'>;
+};
+export type TemplateProps = {
+    sys: TemplateSys;
+    name: string;
+    description: string;
+    viewports: ComponentTypeViewport[];
+    contentProperties: ComponentTypeContentProperty[];
+    designProperties: ComponentTypeDesignProperty[];
+    dimensionKeyMap: ComponentTypeDimensionKeyMap;
+    componentTree?: TreeNode[];
+    slots?: ComponentTypeSlotDefinition[];
+    metadata?: ExoMetadataProps;
+    dataAssemblies?: DataAssemblyLink[];
+};
+export type CreateTemplateProps = Except<TemplateProps, 'sys'>;
+export type UpsertTemplateProps = Except<TemplateProps, 'sys'> & {
+    sys: {
+        id: string;
+        type: 'Template';
+        version?: number;
+    };
+};
+export type TemplateQueryOptions = CursorPaginationParams & ExoQueryFilters & {
+    order?: string;
+};
+export type TemplateCollection = ExoCursorPaginatedCollectionProp<TemplateProps>;

package/dist/types/export-types.d.ts

@@ -85,3 +85,8 @@ export type { SemanticSearchProps, SemanticSearch } from './entities/semantic-se
 export type { DefinedParameters, FreeFormParameters, InstallationParameterType, ParameterDefinition, ParameterOption, ParameterType, } from './entities/widget-parameters';
 export type { CreateWorkflowProps, DeleteWorkflowParams, UpdateWorkflowProps, Workflow, WorkflowProps, WorkflowQueryOptions, } from './entities/workflow';
 export type { WorkflowsChangelogEntry, WorkflowsChangelogEntryProps, WorkflowsChangelogQueryOptions, } from './entities/workflows-changelog-entry';
+export type { ComponentTypeCollection } from './entities/component-type';
+export type { TemplateCollection } from './entities/template';
+export type { ExperienceCollection, ReleaseExperience, ReleaseExperienceCollection, ReleaseExperienceSys, } from './entities/experience';
+export type { FragmentCollection } from './entities/fragment';
+export type { DataAssemblyCollection, DataAssemblyResourceLinkParameter, DataAssemblyReturnMappingFromObject, DataAssemblyReturnMappingSelectValue, } from './entities/data-assembly';

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>;
+};