contentful-management 12.5.0 → 12.6.0-dev.2

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

@@ -1,8 +1,7 @@
-import type { Link, MetadataProps, SysLink } from '../common-types';
-export type ComponentTypeQueryOptions = {
-    _experienceCtId: string;
-    skip?: number;
-    limit?: number;
+import type { Except } from 'type-fest';
+import type { CursorPaginationParams, DataTypeDefinition, ExoCursorPaginatedCollectionProp, ExoMetadataProps, ExoQueryFilters, Link, ResourceLink } from '../common-types';
+export type ComponentTypeQueryOptions = CursorPaginationParams & ExoQueryFilters & {
+    order?: string;
 };
 export type ComponentTypeViewport = {
     id: string;
@@ -10,89 +9,110 @@ export type ComponentTypeViewport = {
     displayName: string;
     previewSize: string;
 };
-export type ComponentTypeContentProperty = {
+export type ComponentTypeContentProperty = DataTypeDefinition & {
     id: string;
     name: string;
-    type: string;
     required: boolean;
     defaultValue?: unknown;
 };
-export type ComponentTypeDesignPropertyValidation = {
-    value: string | number | boolean;
-    name: string;
-    description?: string;
+export type StringDesignPropertyRegexpValidation = {
+    regexp: {
+        pattern: string;
+    };
+};
+export type DesignTokenAllowedResource = {
+    type: 'DesignToken';
+    value: string;
+    name?: string;
 };
-export type ComponentTypeDesignProperty = {
+export type DTCGDesignPropertyType = 'DTCG.Color' | 'DTCG.Dimension' | 'DTCG.FontFamily' | 'DTCG.FontWeight' | 'DTCG.Duration' | 'DTCG.CubicBezier' | 'DTCG.Number' | 'DTCG.StrokeStyle' | 'DTCG.Border' | 'DTCG.Transition' | 'DTCG.Shadow' | 'DTCG.Gradient' | 'DTCG.Typography';
+type DesignPropertyCommonFields = {
     id: string;
     name: string;
-    type: string;
-    required: boolean;
     description?: string;
-    defaultValue?: unknown;
-    validations?: {
-        in: ComponentTypeDesignPropertyValidation[];
+};
+export type StringDesignProperty = DesignPropertyCommonFields & {
+    type: 'String';
+    fallbackValue?: {
+        type: 'ManualDesignValue';
+        value: string;
     };
-    designTokenSet?: string[];
+    validations?: StringDesignPropertyRegexpValidation[];
+};
+export type BooleanDesignProperty = DesignPropertyCommonFields & {
+    type: 'Boolean';
+    fallbackValue?: {
+        type: 'ManualDesignValue';
+        value: boolean;
+    };
+};
+export type TokenBackedDesignProperty = DesignPropertyCommonFields & {
+    type: DTCGDesignPropertyType;
+    fallbackValue?: DesignTokenValue;
+    allowedResources?: DesignTokenAllowedResource[];
 };
+export type ComponentTypeDesignProperty = StringDesignProperty | BooleanDesignProperty | TokenBackedDesignProperty;
 export type ComponentTypeDimensionKeyMap = {
     designProperties: Record<string, Record<string, string>>;
 };
-export type ContentPropertyPointerValue = `$contentProperties/${string}` | `$contentBindings/${string}`;
+export type ContentPropertyPointerValue = `$contentProperties/${string}`;
 export type DesignPropertyPointerValue = `$designProperties/${string}`;
 export type ManualDesignValue = {
     type: 'ManualDesignValue';
-    value: string | number | boolean | Record<string, unknown>;
+    value: string | number | boolean;
 };
 export type DesignTokenValue = {
-    type: 'DesignValue';
-    token: string;
+    type: 'DesignToken';
+    /** Must be non-empty (min length 1) */
+    value: string;
 };
-export type DesignPropertyValue = ManualDesignValue | DesignTokenValue | DesignPropertyPointerValue | Record<string, ManualDesignValue | DesignTokenValue | DesignPropertyPointerValue>;
+export type DesignPropertyValue = ManualDesignValue | DesignTokenValue;
+export type DimensionedDesignPropertyValue = Record<string, DesignPropertyValue>;
+export type ComponentTreeDesignPropertyValue = DesignPropertyValue | DesignPropertyPointerValue | DimensionedDesignPropertyValue;
 export type ComponentNode = {
     id: string;
+    name?: string;
     nodeType: 'Component';
-    componentTypeId: string;
-    contentProperties: Record<string, ContentPropertyPointerValue | unknown>;
-    designProperties: Record<string, DesignPropertyValue>;
+    componentType: ResourceLink<'Contentful:ComponentType'>;
+    contentProperties: Record<string, ContentPropertyPointerValue | unknown> | string;
+    designProperties: Record<string, ComponentTreeDesignPropertyValue>;
     slots: Record<string, TreeNode[]>;
-    contentBindings?: string;
 };
-export type ViewNode = {
+export type FragmentNode = {
     id: string;
-    nodeType: 'View';
-    viewId: string;
+    name?: string;
+    nodeType: 'Fragment';
+    fragment: ResourceLink<'Contentful:Fragment'>;
 };
 export type SlotNode = {
     id: string;
     nodeType: 'Slot';
     slotId: string;
 };
-export type TreeNode = ComponentNode | ViewNode | SlotNode;
-export type ComponentTypeDataTypeField = {
-    id: string;
-    name: string;
-    type: string;
-    required: boolean;
-    source?: string;
-};
-export type DataAssemblyLink = Link<'DataAssembly'>;
-export type ComponentTypeContentBindings = DataAssemblyLink['sys'] & {
-    required: boolean;
-    dataType: ComponentTypeDataTypeField[];
-};
+export type TreeNode = ComponentNode | FragmentNode | SlotNode;
+export type DataAssemblyLink = ResourceLink<'Contentful:DataAssembly'>;
 export type ComponentTypeSlotDefinition = {
     id: string;
     name: string;
-    componentTypeId: string[];
     required: boolean;
-    validations: unknown[];
+    validations: Array<{
+        size?: {
+            min?: number;
+            max?: number;
+        };
+    }>;
+    allowedResources?: Array<{
+        type: 'Contentful:ComponentType';
+        source: string;
+        allowedTypes: string[];
+    }>;
 };
 export type ComponentTypeSys = {
     id: string;
     type: 'ComponentType';
     version: number;
-    space: SysLink;
-    environment: SysLink;
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
     fieldStatus?: Record<string, Record<string, 'draft' | 'published' | 'changed'>>;
     publishedAt?: string;
     publishedVersion?: number;
@@ -100,10 +120,12 @@ export type ComponentTypeSys = {
     firstPublishedAt?: string;
     publishedBy?: Link<'User'> | Link<'AppDefinition'>;
     variant?: string;
-    createdAt?: string;
-    createdBy?: Link<'User'>;
-    updatedAt?: string;
-    updatedBy?: Link<'User'>;
+    variantType?: string;
+    variantDimension?: string;
+    createdAt: string;
+    createdBy: Link<'User'>;
+    updatedAt: string;
+    updatedBy: Link<'User'>;
 };
 export type ComponentTypeProps = {
     sys: ComponentTypeSys;
@@ -114,8 +136,21 @@ export type ComponentTypeProps = {
     designProperties: ComponentTypeDesignProperty[];
     dimensionKeyMap: ComponentTypeDimensionKeyMap;
     componentTree?: TreeNode[];
-    contentBindings?: ComponentTypeContentBindings;
     slots?: ComponentTypeSlotDefinition[];
-    metadata?: MetadataProps;
+    metadata?: ExoMetadataProps;
     dataAssemblies?: DataAssemblyLink[];
+    source?: ResourceLink<'Contentful:DesignSystemSource'>;
+};
+export type CreateComponentTypeProps = Except<ComponentTypeProps, 'sys' | 'source'> & {
+    source?: ResourceLink<'Contentful:DesignSystemSource'> | null;
+};
+export type UpsertComponentTypeProps = Except<ComponentTypeProps, 'sys' | 'source'> & {
+    sys: {
+        id: string;
+        type: 'ComponentType';
+        version?: number;
+    };
+    source?: ResourceLink<'Contentful:DesignSystemSource'> | null;
 };
+export type ComponentTypeCollection = ExoCursorPaginatedCollectionProp<ComponentTypeProps>;
+export {};

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

@@ -0,0 +1,92 @@
+import type { CursorPaginationParams, DataTypeDefinition, ExoCursorPaginatedCollectionProp, Link, MetadataProps, PointerExpressionValue, ResourceLink } from '../common-types';
+export type DataAssemblyDataTypeField = DataTypeDefinition & {
+    id: string;
+    name: string;
+    source?: string;
+};
+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?: PointerExpressionValue;
+};
+export type DataAssemblyNestedResolver = {
+    source: 'Contentful:DataAssembly';
+    dataAssembly: ResourceLink<'Contentful:DataAssembly'>;
+    parameters?: PointerExpressionValue;
+};
+export type DataAssemblyResolverDefinition = DataAssemblyGraphQLResolver | DataAssemblyNestedResolver;
+export type DataAssemblyResolverConfig = Record<string, DataAssemblyResolverDefinition>;
+export type DataAssemblyReturnMappingConfig = Record<string, PointerExpressionValue>;
+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,84 @@
+import type { CursorPaginationParams, ExoCursorPaginatedCollectionProp, ExperienceMetadataProps, ExoQueryFilters, Link, ResourceLink } from '../common-types';
+import type { ComponentTypeViewport, DimensionedDesignPropertyValue, FragmentNode } from './component-type';
+export type ExperienceDimensionKeyMap = {
+    designProperties: Record<string, {
+        breakpoint: string;
+    }>;
+};
+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>;
+    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: 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

@@ -0,0 +1,53 @@
+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, ExperienceDimensionKeyMap, 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>;
+    dimensionKeyMap: ExperienceDimensionKeyMap;
+    contentBindings?: ExperienceContentBindings;
+    metadata?: ExperienceMetadataProps;
+    slots?: Record<string, Array<FragmentNode | InlineFragmentNode>>;
+};
+export type CreateFragmentProps = Except<FragmentProps, 'sys'> & {
+    componentType: ResourceLink<'Contentful:ComponentType'>;
+};
+export type UpdateFragmentProps = 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

@@ -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, } 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>;
 };