contentful-management 12.5.0 → 12.6.0-dev.1

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/template.d.ts

@@ -0,0 +1,139 @@
+import type { ExoCursorPaginatedCollectionProp, GetSpaceEnvironmentParams, GetTemplateParams } from '../../common-types';
+import type { CreateTemplateProps, TemplateProps, TemplateQueryOptions, UpsertTemplateProps } from '../../entities/template';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type TemplatePlainClientAPI = {
+    /**
+     * Fetches all templates for a space and environment
+     * @param params the space, environment IDs and query options (see {@link TemplateQueryOptions})
+     * @returns a collection of templates
+     * @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 templates = await client.template.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   query: {
+     *     limit: 10,
+     *   },
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        query: TemplateQueryOptions;
+    }>): Promise<ExoCursorPaginatedCollectionProp<TemplateProps>>;
+    /**
+     * Fetches a single template by ID
+     * @param params the space, environment, and template IDs
+     * @returns the template
+     * @throws if the request fails, or the space, environment, or template is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const template = await client.template.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   templateId: '<template_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetTemplateParams>): Promise<TemplateProps>;
+    /**
+     * Creates a new template
+     * @param params the space and environment IDs
+     * @param data the template data
+     * @returns the created template
+     * @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 template = await client.template.create({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * }, {
+     *   name: 'My Template',
+     *   description: 'A new template',
+     *   viewports: [],
+     *   contentProperties: [],
+     *   designProperties: [],
+     *   dimensionKeyMap: { designProperties: {} },
+     * });
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateTemplateProps): Promise<TemplateProps>;
+    /**
+     * Upserts a template (creates or updates via PUT)
+     * @param params the space, environment, and template IDs
+     * @param data the template data to upsert (include sys.version for updates, omit for creates)
+     * @returns the upserted template
+     * @throws if the request fails
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const current = await client.template.get({ templateId: '<template_id>' });
+     * const updated = await client.template.upsert({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   templateId: '<template_id>',
+     * }, {
+     *   sys: { id: current.sys.id, type: 'Template', version: current.sys.version },
+     *   name: 'Updated Template',
+     *   ...otherFields,
+     * });
+     * ```
+     */
+    upsert(params: OptionalDefaults<GetTemplateParams>, data: UpsertTemplateProps): Promise<TemplateProps>;
+    /**
+     * Deletes a template
+     * @param params the space, environment, and template IDs
+     * @throws if the request fails, or the space, environment, or template is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * await client.template.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   templateId: '<template_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetTemplateParams>): Promise<void>;
+    /**
+     * Publishes a template
+     * @param params the space, environment, and template IDs, plus the current version
+     * @returns the published template
+     * @throws if the request fails, or the space, environment, or template is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const template = await client.template.publish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   templateId: '<template_id>',
+     *   version: 1,
+     * });
+     * ```
+     */
+    publish(params: OptionalDefaults<GetTemplateParams & {
+        version: number;
+    }>): Promise<TemplateProps>;
+    /**
+     * Unpublishes a template
+     * @param params the space, environment, and template IDs, plus the current version
+     * @returns the unpublished template
+     * @throws if the request fails, or the space, environment, or template is not found
+     * @internal - Experimental endpoint, subject to breaking changes without notice
+     * @example
+     * ```javascript
+     * const template = await client.template.unpublish({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   templateId: '<template_id>',
+     *   version: 2,
+     * });
+     * ```
+     */
+    unpublish(params: OptionalDefaults<GetTemplateParams & {
+        version: number;
+    }>): Promise<TemplateProps>;
+};

package/dist/types/plain/plain-client-types.d.ts

@@ -51,6 +51,8 @@ import type { TaskPlainClientAPI } from './entities/task';
 import type { TeamPlainClientAPI } from './entities/team';
 import type { TeamMembershipPlainClientAPI } from './entities/team-membership';
 import type { TeamSpaceMembershipPlainClientAPI } from './entities/team-space-membership';
+import type { FragmentPlainClientAPI } from './entities/fragment';
+import type { TemplatePlainClientAPI } from './entities/template';
 import type { UIConfigPlainClientAPI } from './entities/ui-config';
 import type { UploadPlainClientAPI } from './entities/upload';
 import type { UploadCredentialAPI } from './entities/upload-credential';
@@ -77,6 +79,8 @@ import type { SemanticSearchPlainClientAPI } from './entities/semantic-search';
 import type { SemanticSettingsPlainClientAPI } from './entities/semantic-settings';
 import type { ContentSemanticsIndexPlainClientAPI } from './entities/content-semantics-index';
 import type { ComponentTypePlainClientAPI } from './entities/component-type';
+import type { DataAssemblyPlainClientAPI } from './entities/data-assembly';
+import type { ExperiencePlainClientAPI } from './entities/experience';
 export type PlainClientAPI = {
     raw: {
         getDefaultParams(): PlainClientDefaultParams | undefined;
@@ -166,6 +170,7 @@ export type PlainClientAPI = {
     };
     comment: CommentPlainClientAPI;
     componentType: ComponentTypePlainClientAPI;
+    dataAssembly: DataAssemblyPlainClientAPI;
     concept: ConceptPlainClientAPI;
     conceptScheme: ConceptSchemePlainClientAPI;
     contentType: {
@@ -479,12 +484,15 @@ export type PlainClientAPI = {
     team: TeamPlainClientAPI;
     teamMembership: TeamMembershipPlainClientAPI;
     teamSpaceMembership: TeamSpaceMembershipPlainClientAPI;
+    fragment: FragmentPlainClientAPI;
+    template: TemplatePlainClientAPI;
     uiConfig: UIConfigPlainClientAPI;
     userUIConfig: UserUIConfigPlainClientAPI;
     workflowDefinition: WorkflowDefinitionPlainClientAPI;
     workflow: WorkflowPlainClientAPI;
     workflowsChangelog: WorkflowsChangelogPlainClientAPI;
     oauthApplication: OAuthApplicationPlainClientAPI;
+    experience: ExperiencePlainClientAPI;
     semanticSearch: SemanticSearchPlainClientAPI;
     semanticDuplicates: SemanticDuplicatesPlainClientAPI;
     semanticRecommendations: SemanticRecommendationsPlainClientAPI;

package/dist/types/plain/plain-client.js

@@ -221,6 +221,12 @@ const createPlainClient = (makeRequest, defaults) => {
         },
         componentType: {
             getMany: wrap(wrapParams, 'ComponentType', 'getMany'),
+            get: wrap(wrapParams, 'ComponentType', 'get'),
+            create: wrap(wrapParams, 'ComponentType', 'create'),
+            upsert: wrap(wrapParams, 'ComponentType', 'upsert'),
+            delete: wrap(wrapParams, 'ComponentType', 'delete'),
+            publish: wrap(wrapParams, 'ComponentType', 'publish'),
+            unpublish: wrap(wrapParams, 'ComponentType', 'unpublish'),
         },
         contentType: {
             get: wrap(wrapParams, 'ContentType', 'get'),
@@ -234,6 +240,17 @@ const createPlainClient = (makeRequest, defaults) => {
             createWithId: wrap(wrapParams, 'ContentType', 'createWithId'),
             omitAndDeleteField: (params, contentType, fieldId) => omitAndDeleteField(makeRequest, { ...{ ...defaults, ...params }, fieldId }, contentType),
         },
+        dataAssembly: {
+            getMany: wrap(wrapParams, 'DataAssembly', 'getMany'),
+            getManyPublished: wrap(wrapParams, 'DataAssembly', 'getManyPublished'),
+            getPublished: wrap(wrapParams, 'DataAssembly', 'getPublished'),
+            get: wrap(wrapParams, 'DataAssembly', 'get'),
+            create: wrap(wrapParams, 'DataAssembly', 'create'),
+            update: wrap(wrapParams, 'DataAssembly', 'update'),
+            delete: wrap(wrapParams, 'DataAssembly', 'delete'),
+            publish: wrap(wrapParams, 'DataAssembly', 'publish'),
+            unpublish: wrap(wrapParams, 'DataAssembly', 'unpublish'),
+        },
         user: {
             getManyForSpace: wrap(wrapParams, 'User', 'getManyForSpace'),
             getForSpace: wrap(wrapParams, 'User', 'getForSpace'),
@@ -581,6 +598,24 @@ const createPlainClient = (makeRequest, defaults) => {
             update: wrap(wrapParams, 'TeamSpaceMembership', 'update'),
             delete: wrap(wrapParams, 'TeamSpaceMembership', 'delete'),
         },
+        fragment: {
+            getMany: wrap(wrapParams, 'Fragment', 'getMany'),
+            get: wrap(wrapParams, 'Fragment', 'get'),
+            create: wrap(wrapParams, 'Fragment', 'create'),
+            update: wrap(wrapParams, 'Fragment', 'update'),
+            delete: wrap(wrapParams, 'Fragment', 'delete'),
+            publish: wrap(wrapParams, 'Fragment', 'publish'),
+            unpublish: wrap(wrapParams, 'Fragment', 'unpublish'),
+        },
+        template: {
+            getMany: wrap(wrapParams, 'Template', 'getMany'),
+            get: wrap(wrapParams, 'Template', 'get'),
+            create: wrap(wrapParams, 'Template', 'create'),
+            upsert: wrap(wrapParams, 'Template', 'upsert'),
+            delete: wrap(wrapParams, 'Template', 'delete'),
+            publish: wrap(wrapParams, 'Template', 'publish'),
+            unpublish: wrap(wrapParams, 'Template', 'unpublish'),
+        },
         uiConfig: {
             get: wrap(wrapParams, 'UIConfig', 'get'),
             update: wrap(wrapParams, 'UIConfig', 'update'),
@@ -589,6 +624,15 @@ const createPlainClient = (makeRequest, defaults) => {
             get: wrap(wrapParams, 'UserUIConfig', 'get'),
             update: wrap(wrapParams, 'UserUIConfig', 'update'),
         },
+        experience: {
+            getMany: wrap(wrapParams, 'Experience', 'getMany'),
+            get: wrap(wrapParams, 'Experience', 'get'),
+            create: wrap(wrapParams, 'Experience', 'create'),
+            upsert: wrap(wrapParams, 'Experience', 'upsert'),
+            delete: wrap(wrapParams, 'Experience', 'delete'),
+            publish: wrap(wrapParams, 'Experience', 'publish'),
+            unpublish: wrap(wrapParams, 'Experience', 'unpublish'),
+        },
         workflowDefinition: {
             get: wrap(wrapParams, 'WorkflowDefinition', 'get'),
             getMany: wrap(wrapParams, 'WorkflowDefinition', 'getMany'),