contentful-management 12.6.0-dev.3 → 12.6.0

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

@@ -1,78 +0,0 @@
-import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExperienceMetadataProps, ExoQueryFilters, Link, ResourceLink } from '../common-types';
-import type { ComponentTypeViewport, DimensionedDesignPropertyValue, FragmentNode } from './component-type';
-export type ExperienceContentBindings = {
-    sys: ResourceLink<'Contentful:DataAssembly'>['sys'];
-    parameters: Record<string, ResourceLink<string>>;
-};
-export type ExperienceSys = {
-    id: string;
-    type: 'Experience';
-    version: number;
-    space: Link<'Space'>;
-    environment: Link<'Environment'>;
-    template: ResourceLink<'Contentful: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[];
-    designProperties: Record<string, DimensionedDesignPropertyValue>;
-    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: ResourceLink<'Contentful:Template'>;
-};
-export type UpsertExperienceProps = ExperienceCommonProps & {
-    sys: {
-        id: string;
-        type: 'Experience';
-        version?: number;
-    };
-    template?: ResourceLink<'Contentful:Template'>;
-};
-export type InlineFragmentNode = {
-    id: string;
-    nodeType: 'InlineFragment';
-    componentType: ResourceLink<'Contentful:ComponentType'>;
-    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

@@ -1,52 +0,0 @@
-import type { Except } from 'type-fest';
-import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExoQueryFilters, ExperienceMetadataProps, Link, ResourceLink } from '../common-types';
-import type { ComponentTypeViewport, DimensionedDesignPropertyValue, FragmentNode } from './component-type';
-import type { ExperienceContentBindings, InlineFragmentNode } from './experience';
-export type FragmentSys = {
-    id: string;
-    type: 'Fragment';
-    version: number;
-    space: Link<'Space'>;
-    environment: Link<'Environment'>;
-    componentType: ResourceLink<'Contentful: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>;
-    contentBindings?: ExperienceContentBindings;
-    metadata?: ExperienceMetadataProps;
-    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
-};
-export type CreateFragmentProps = Except<FragmentProps, 'sys'> & {
-    componentType: ResourceLink<'Contentful:ComponentType'>;
-};
-export type UpsertFragmentProps = Omit<FragmentProps, 'sys'> & {
-    sys: {
-        id: string;
-        type: 'Fragment';
-        version?: number;
-    };
-    componentType?: ResourceLink<'Contentful:ComponentType'>;
-};
-export type FragmentQueryOptions = CursorPaginationParams & ExoQueryFilters & {
-    order?: string;
-};
-export type FragmentCollection = ExoCursorPaginatedCollectionProp<FragmentProps>;

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

@@ -1,47 +0,0 @@
-import type { Except } from 'type-fest';
-import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExoMetadataProps, ExoQueryFilters, Link } from '../common-types';
-import type { ComponentTypeContentProperty, ComponentTypeDesignProperty, 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[];
-    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/plain/entities/data-assembly.d.ts

@@ -1,178 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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: {},
-     * });
-     * ```
-     */
-    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

@@ -1,133 +0,0 @@
-import type { ExoCursorPaginatedCollectionProp, GetFragmentParams, GetSpaceEnvironmentParams } from '../../common-types';
-import type { CreateFragmentProps, FragmentProps, FragmentQueryOptions, UpsertFragmentProps } 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: {},
-     * });
-     * ```
-     */
-    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateFragmentProps): Promise<FragmentProps>;
-    /**
-     * Upserts a fragment (creates or updates via PUT)
-     * @param params the space, environment, and fragment IDs
-     * @param data the fragment data to upsert (include sys.version for updates, omit for creates)
-     * @returns the upserted 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.upsert({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   fragmentId: '<fragment_id>',
-     * }, fragmentData);
-     * ```
-     */
-    upsert(params: OptionalDefaults<GetFragmentParams>, data: UpsertFragmentProps): 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>;
-};