contentful-management 11.64.0 → 11.66.0

package/dist/typings/common-types.d.ts

@@ -64,6 +64,11 @@ import type { CreateOAuthApplicationProps, OAuthApplicationProps, UpdateOAuthApp
 import type { FunctionLogProps } from './entities/function-log';
 import type { AiActionProps, AiActionQueryOptions, CreateAiActionProps } from './entities/ai-action';
 import type { AiActionInvocationProps, AiActionInvocationType } from './entities/ai-action-invocation';
+import type { UpdateVectorizationStatusProps, VectorizationStatusProps } from './entities/vectorization-status';
+import type { GetSemanticDuplicatesProps, SemanticDuplicatesProps } from './entities/semantic-duplicates';
+import type { GetSemanticRecommendationsProps, SemanticRecommendationsProps } from './entities/semantic-recommendations';
+import type { GetSemanticReferenceSuggestionsProps, SemanticReferenceSuggestionsProps } from './entities/semantic-reference-suggestions';
+import type { GetSemanticSearchProps, SemanticSearchProps } from './entities/semantic-search';
 export interface DefaultElements<TPlainObject extends object = object> {
     toPlainObject(): TPlainObject;
 }
@@ -297,6 +302,7 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'Asset', 'getMany', UA>): MRReturn<'Asset', 'getMany'>;
     (opts: MROpts<'Asset', 'getManyWithCursor', UA>): MRReturn<'Asset', 'getManyWithCursor'>;
     (opts: MROpts<'Asset', 'getPublished', UA>): MRReturn<'Asset', 'getPublished'>;
+    (opts: MROpts<'Asset', 'getPublishedWithCursor', UA>): MRReturn<'Asset', 'getPublishedWithCursor'>;
     (opts: MROpts<'Asset', 'get', UA>): MRReturn<'Asset', 'get'>;
     (opts: MROpts<'Asset', 'update', UA>): MRReturn<'Asset', 'update'>;
     (opts: MROpts<'Asset', 'delete', UA>): MRReturn<'Asset', 'delete'>;
@@ -399,6 +405,7 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'Entry', 'getMany', UA>): MRReturn<'Entry', 'getMany'>;
     (opts: MROpts<'Entry', 'getManyWithCursor', UA>): MRReturn<'Entry', 'getManyWithCursor'>;
     (opts: MROpts<'Entry', 'getPublished', UA>): MRReturn<'Entry', 'getPublished'>;
+    (opts: MROpts<'Entry', 'getPublishedWithCursor', UA>): MRReturn<'Entry', 'getPublishedWithCursor'>;
     (opts: MROpts<'Entry', 'get', UA>): MRReturn<'Entry', 'get'>;
     (opts: MROpts<'Entry', 'patch', UA>): MRReturn<'Entry', 'patch'>;
     (opts: MROpts<'Entry', 'update', UA>): MRReturn<'Entry', 'update'>;
@@ -563,6 +570,12 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'User', 'getManyForOrganization', UA>): MRReturn<'User', 'getManyForOrganization'>;
     (opts: MROpts<'UserUIConfig', 'get', UA>): MRReturn<'UserUIConfig', 'update'>;
     (opts: MROpts<'UserUIConfig', 'update', UA>): MRReturn<'UserUIConfig', 'update'>;
+    (opts: MROpts<'VectorizationStatus', 'get', UA>): MRReturn<'VectorizationStatus', 'get'>;
+    (opts: MROpts<'VectorizationStatus', 'update', UA>): MRReturn<'VectorizationStatus', 'update'>;
+    (opts: MROpts<'SemanticDuplicates', 'get', UA>): MRReturn<'SemanticDuplicates', 'get'>;
+    (opts: MROpts<'SemanticRecommendations', 'get', UA>): MRReturn<'SemanticRecommendations', 'get'>;
+    (opts: MROpts<'SemanticReferenceSuggestions', 'get', UA>): MRReturn<'SemanticReferenceSuggestions', 'get'>;
+    (opts: MROpts<'SemanticSearch', 'get', UA>): MRReturn<'SemanticSearch', 'get'>;
     (opts: MROpts<'Webhook', 'get', UA>): MRReturn<'Webhook', 'get'>;
     (opts: MROpts<'Webhook', 'getMany', UA>): MRReturn<'Webhook', 'getMany'>;
     (opts: MROpts<'Webhook', 'getCallDetails', UA>): MRReturn<'Webhook', 'getCallDetails'>;
@@ -1063,6 +1076,11 @@ export type MRActions = {
             headers?: RawAxiosRequestHeaders;
             return: CollectionProp<AssetProps>;
         };
+        getPublishedWithCursor: {
+            params: GetSpaceEnvironmentParams & CursorBasedParams;
+            headers?: RawAxiosRequestHeaders;
+            return: CursorPaginatedCollectionProp<AssetProps>;
+        };
         getMany: {
             params: GetSpaceEnvironmentParams & QueryParams & {
                 releaseId?: string;
@@ -1567,6 +1585,10 @@ export type MRActions = {
             params: GetSpaceEnvironmentParams & QueryParams;
             return: CollectionProp<EntryProps<any>>;
         };
+        getPublishedWithCursor: {
+            params: GetSpaceEnvironmentParams & CursorBasedParams;
+            return: CursorPaginatedCollectionProp<EntryProps<any>>;
+        };
         getMany: {
             params: GetSpaceEnvironmentParams & QueryParams & {
                 releaseId?: string;
@@ -2152,6 +2174,38 @@ export type MRActions = {
             return: any;
         };
     };
+    SemanticDuplicates: {
+        get: {
+            params: GetSpaceEnvironmentParams;
+            headers?: RawAxiosRequestHeaders;
+            payload: GetSemanticDuplicatesProps;
+            return: SemanticDuplicatesProps;
+        };
+    };
+    SemanticRecommendations: {
+        get: {
+            params: GetSpaceEnvironmentParams;
+            headers?: RawAxiosRequestHeaders;
+            payload: GetSemanticRecommendationsProps;
+            return: SemanticRecommendationsProps;
+        };
+    };
+    SemanticReferenceSuggestions: {
+        get: {
+            params: GetSpaceEnvironmentParams;
+            headers?: RawAxiosRequestHeaders;
+            payload: GetSemanticReferenceSuggestionsProps;
+            return: SemanticReferenceSuggestionsProps;
+        };
+    };
+    SemanticSearch: {
+        get: {
+            params: GetSpaceEnvironmentParams;
+            headers?: RawAxiosRequestHeaders;
+            payload: GetSemanticSearchProps;
+            return: SemanticSearchProps;
+        };
+    };
     Snapshot: {
         getManyForEntry: {
             params: GetSnapshotForEntryParams & QueryParams;
@@ -2499,6 +2553,19 @@ export type MRActions = {
             return: UserUIConfigProps;
         };
     };
+    VectorizationStatus: {
+        get: {
+            params: GetOrganizationParams;
+            headers?: RawAxiosRequestHeaders;
+            return: VectorizationStatusProps;
+        };
+        update: {
+            params: GetOrganizationParams;
+            headers?: RawAxiosRequestHeaders;
+            payload: UpdateVectorizationStatusProps;
+            return: VectorizationStatusProps;
+        };
+    };
     Webhook: {
         get: {
             params: GetWebhookParams;
@@ -2969,4 +3036,8 @@ export declare enum ScheduledActionReferenceFilters {
 export type ReleaseEnvironmentParams = GetSpaceEnvironmentParams & {
     releaseSchemaVersion?: 'Release.v1' | 'Release.v2';
 };
+export type SemanticRequestFilter = {
+    entityType?: 'Entry';
+    contentTypeIds?: string[];
+};
 export {};

package/dist/typings/create-environment-api.d.ts

@@ -17,6 +17,10 @@ import type { TagVisibility } from './entities/tag';
 import type { CreateAppAccessTokenProps } from './entities/app-access-token';
 import type { ResourceQueryOptions } from './entities/resource';
 import type { AiActionInvocationType } from './entities/ai-action-invocation';
+import type { GetSemanticDuplicatesProps } from './entities/semantic-duplicates';
+import type { GetSemanticRecommendationsProps } from './entities/semantic-recommendations';
+import type { GetSemanticReferenceSuggestionsProps } from './entities/semantic-reference-suggestions';
+import type { GetSemanticSearchProps } from './entities/semantic-search';
 /**
  * @private
  */
@@ -546,6 +550,25 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
      * ```
      */
     getPublishedEntries(query?: QueryOptions): Promise<import("./common-types").Collection<import("./entities/entry").Entry, EntryProps<import("./common-types").KeyValueMap, unknown>>>;
+    /**
+     * Gets a collection of published Entries with cursor based pagination
+     * @param query - Object with cursor pagination parameters. Check the <a href="https://www.contentful.com/developers/docs/references/content-management-api/#/introduction/cursor-pagination">REST API reference</a> for more details.
+     * @return Promise for a collection of published Entries
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment-id>'))
+     * .then((environment) => environment.getPublishedEntriesWithCursor())
+     * .then((response) => console.log(response.items))
+     * .catch(console.error)
+     * ```
+     */
+    getPublishedEntriesWithCursor(query?: BasicCursorPaginationOptions): Promise<import("./common-types").CursorPaginatedCollection<import("./entities/entry").Entry, EntryProps<import("./common-types").KeyValueMap, unknown>>>;
     /**
      * Creates a Entry
      * @param contentTypeId - The Content Type ID of the newly created Entry
@@ -706,6 +729,25 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
      * ```
      */
     getPublishedAssets(query?: QueryOptions): Promise<import("./common-types").Collection<import("./entities/asset").Asset, AssetProps<{}>>>;
+    /**
+     * Gets a collection of published Assets with cursor based pagination
+     * @param query - Object with cursor pagination parameters. Check the <a href="https://www.contentful.com/developers/docs/references/content-management-api/#/introduction/cursor-pagination">REST API reference</a> for more details.
+     * @return Promise for a collection of published Assets
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment-id>'))
+     * .then((environment) => environment.getPublishedAssetsWithCursor())
+     * .then((response) => console.log(response.items))
+     * .catch(console.error)
+     * ```
+     */
+    getPublishedAssetsWithCursor(query?: BasicCursorPaginationOptions): Promise<import("./common-types").CursorPaginatedCollection<import("./entities/asset").Asset, AssetProps<{}>>>;
     /**
      * Creates a Asset. After creation, call asset.processForLocale or asset.processForAllLocales to start asset processing.
      * @param data - Object representation of the Asset to be created. Note that the field object should have an upload property on asset creation, which will be removed and replaced with an url property when processing is finished.
@@ -1746,4 +1788,65 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
         aiActionId: string;
         invocationId: string;
     }): Promise<import("./entities/ai-action-invocation").AiActionInvocation>;
+    /**
+     * Retrieves Semantic Duplicates for the given entity ID
+     * @param payload - Object containing the entityId and optional filters
+     * @return Promise for Semantic Duplicates
+     * @example ```javascript
+     * client.getSpace('<space_id>')
+     *   .then(space => space.getEnvironment('<environment_id>'))
+     *   .then(environment => environment.getSemanticDuplicates({
+     *      entityId: '<entity_id>',
+     *      filters: {
+     *        contentTypeIds: ['<content_type_id1>', '<content_type_id2>'],
+     *      }
+     *    })
+     */
+    getSemanticDuplicates(payload: GetSemanticDuplicatesProps): Promise<import("./entities/semantic-duplicates").SemanticDuplicates>;
+    /**
+     * Retrieves Semantic Recommendations for the given entity ID
+     * @param payload - Object containing the entityId and optional filters
+     * @return Promise for Semantic Recommendations
+     * @example ```javascript
+     * client.getSpace('<space_id>')
+     *   .then(space => space.getEnvironment('<environment_id>'))
+     *   .then(environment => environment.getSemanticRecommendations({
+     *      entityId: '<entity_id>',
+     *      filters: {
+     *        contentTypeIds: ['<content_type_id1>', '<content_type_id2>'],
+     *      }
+     *    })
+     */
+    getSemanticRecommendations(payload: GetSemanticRecommendationsProps): Promise<import("./entities/semantic-recommendations").SemanticRecommendations>;
+    /**
+     * Retrieves Semantic Reference Suggestions for the given entity ID and its reference field ID
+     * @param payload - Object containing the entityId and optional filters
+     * @return Promise for Semantic Reference Suggestions
+     * @example ```javascript
+     * client.getSpace('<space_id>')
+     *   .then(space => space.getEnvironment('<environment_id>'))
+     *   .then(environment => environment.getSemanticRecommendations({
+     *      entityId: '<entity_id>',
+     *      referenceFieldId: '<reference_field_id>',
+     *      filters: {
+     *        contentTypeIds: ['<content_type_id1>', '<content_type_id2>'],
+     *      }
+     *    })
+     */
+    getSemanticReferenceSuggestions(payload: GetSemanticReferenceSuggestionsProps): Promise<import("./entities/semantic-reference-suggestions").SemanticReferenceSuggestions>;
+    /**
+     * Retrieves Semantic Search results for the given query
+     * @param payload - Object containing the search query and optional filters
+     * @return Promise for Semantic Search results
+     * @example ```javascript
+     * client.getSpace('<space_id>')
+     *   .then(space => space.getEnvironment('<environment_id>'))
+     *   .then(environment => environment.getSemanticSearch({
+     *      query: '<search_query>',
+     *      filters: {
+     *        contentTypeIds: ['<content_type_id1>', '<content_type_id2>'],
+     *      }
+     *    })
+     */
+    getSemanticSearch(payload: GetSemanticSearchProps): Promise<import("./entities/semantic-search").SemanticSearch>;
 };

package/dist/typings/create-organization-api.d.ts

@@ -9,6 +9,7 @@ import type { CreateAppSigningSecretProps } from './entities/app-signing-secret'
 import type { CreateAppEventSubscriptionProps } from './entities/app-event-subscription';
 import type { CreateAppKeyProps } from './entities/app-key';
 import type { CreateAppDetailsProps } from './entities/app-details';
+import type { UpdateVectorizationStatusProps } from './entities/vectorization-status';
 /**
  * @private
  */
@@ -1177,4 +1178,31 @@ export default function createOrganizationApi(makeRequest: MakeRequest): {
      * const functions = await org.getFunctions('<app_definition_id>', { 'accepts[all]': '<action>' })
      */
     getFunctions(appDefinitionId: string, query?: AcceptsQueryOptions): Promise<import("./common-types").Collection<import("./export-types").FunctionProps, import("./export-types").FunctionProps>>;
+    /**
+     * Gets the vectorization status for the organization
+     * @returns Promise for a VectorizationStatus
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * const org = await client.getOrganization('<org_id>')
+     * const vectorizationStatus = await org.getVectorizationStatus()
+     */
+    getVectorizationStatus(): Promise<import("./entities/vectorization-status").VectorizationStatus>;
+    /**
+     * Updates the vectorization status for the organization
+     * @returns Promise for a VectorizationStatus
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     * const org = await client.getOrganization('<org_id>')
+     * const updatedVectorizationStatus = await org.updateVectorizationStatus([
+     *  { spaceId: '<space_id1>', enabled: true },
+     *  { spaceId: '<space_id2>', enabled: false }
+     * ])
+     */
+    updateVectorizationStatus(data: UpdateVectorizationStatusProps): Promise<import("./entities/vectorization-status").VectorizationStatus>;
 };

package/dist/typings/entities/index.d.ts

@@ -39,6 +39,10 @@ import * as release from './release';
 import * as releaseAction from './release-action';
 import * as role from './role';
 import * as scheduledAction from './scheduled-action';
+import * as semanticDuplicates from './semantic-duplicates';
+import * as semanticRecommendations from './semantic-recommendations';
+import * as semanticReferenceSuggestions from './semantic-reference-suggestions';
+import * as semanticSearch from './semantic-search';
 import * as snapshot from './snapshot';
 import * as space from './space';
 import * as spaceMember from './space-member';
@@ -53,6 +57,7 @@ import * as upload from './upload';
 import * as usage from './usage';
 import * as user from './user';
 import * as userUIConfig from './user-ui-config';
+import * as vectorizationStatus from './vectorization-status';
 import * as webhook from './webhook';
 import * as workflowDefinition from './workflow-definition';
 import * as concept from './concept';
@@ -107,6 +112,10 @@ declare const _default: {
     resource: typeof resource;
     role: typeof role;
     scheduledAction: typeof scheduledAction;
+    semanticDuplicates: typeof semanticDuplicates;
+    semanticRecommendations: typeof semanticRecommendations;
+    semanticReferenceSuggestions: typeof semanticReferenceSuggestions;
+    semanticSearch: typeof semanticSearch;
     snapshot: typeof snapshot;
     space: typeof space;
     spaceMember: typeof spaceMember;
@@ -121,6 +130,7 @@ declare const _default: {
     usage: typeof usage;
     user: typeof user;
     userUIConfig: typeof userUIConfig;
+    vectorizationStatus: typeof vectorizationStatus;
     webhook: typeof webhook;
     workflowDefinition: typeof workflowDefinition;
 };

package/dist/typings/entities/resource.d.ts

@@ -3,10 +3,12 @@ export type ResourceQueryOptions = LookupQueryOptions | SearchQueryOptions;
 type LookupQueryOptions = {
     'sys.urn[in]': string;
     locale?: string;
+    referencingEntryId?: string;
 } & BasicCursorPaginationOptions;
 type SearchQueryOptions = {
     query: string;
     locale?: string;
+    referencingEntryId?: string;
 } & BasicCursorPaginationOptions;
 export type ResourceProps = {
     sys: {

package/dist/typings/entities/semantic-duplicates.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultElements, Link, MakeRequest, SemanticRequestFilter } from '../common-types';
+export type DuplicateLabel = 'high' | 'medium' | 'low';
+export type GetSemanticDuplicatesProps = {
+    entityId: string;
+    filter?: SemanticRequestFilter;
+};
+export type SemanticDuplicatesResult = {
+    sys: {
+        type: 'SemanticDuplicatesResult';
+        entity: Link<'Entry'>;
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+    };
+    label: DuplicateLabel;
+};
+export type SemanticDuplicatesProps = {
+    sys: {
+        type: 'Array';
+        correlationId?: string;
+    };
+    items: SemanticDuplicatesResult[];
+};
+export interface SemanticDuplicates extends SemanticDuplicatesProps, DefaultElements<SemanticDuplicatesProps> {
+}
+export declare function wrapSemanticDuplicates(_makeRequest: MakeRequest, data: SemanticDuplicatesProps): SemanticDuplicates;

package/dist/typings/entities/semantic-recommendations.d.ts

@@ -0,0 +1,23 @@
+import type { DefaultElements, Link, MakeRequest, SemanticRequestFilter } from '../common-types';
+export type GetSemanticRecommendationsProps = {
+    entityId: string;
+    filter?: SemanticRequestFilter;
+};
+export type SemanticRecommendationsResult = {
+    sys: {
+        type: 'SemanticRecommendationsResult';
+        entity: Link<'Entry'>;
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+    };
+};
+export type SemanticRecommendationsProps = {
+    sys: {
+        type: 'Array';
+        correlationId?: string;
+    };
+    items: SemanticRecommendationsResult[];
+};
+export interface SemanticRecommendations extends SemanticRecommendationsProps, DefaultElements<SemanticRecommendationsProps> {
+}
+export declare function wrapSemanticRecommendations(_makeRequest: MakeRequest, data: SemanticRecommendationsProps): SemanticRecommendations;

package/dist/typings/entities/semantic-reference-suggestions.d.ts

@@ -0,0 +1,24 @@
+import type { DefaultElements, Link, MakeRequest, SemanticRequestFilter } from '../common-types';
+export type GetSemanticReferenceSuggestionsProps = {
+    entityId: string;
+    referenceFieldId: string;
+    filter?: SemanticRequestFilter;
+};
+export type SemanticReferenceSuggestionsResult = {
+    sys: {
+        type: 'SemanticReferenceSuggestionsResult';
+        entity: Link<'Entry'>;
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+    };
+};
+export type SemanticReferenceSuggestionsProps = {
+    sys: {
+        type: 'Array';
+        correlationId?: string;
+    };
+    items: SemanticReferenceSuggestionsResult[];
+};
+export interface SemanticReferenceSuggestions extends SemanticReferenceSuggestionsProps, DefaultElements<SemanticReferenceSuggestionsProps> {
+}
+export declare function wrapSemanticReferenceSuggestions(_makeRequest: MakeRequest, data: SemanticReferenceSuggestionsProps): SemanticReferenceSuggestions;

package/dist/typings/entities/semantic-search.d.ts

@@ -0,0 +1,23 @@
+import type { DefaultElements, Link, MakeRequest, SemanticRequestFilter } from '../common-types';
+export type GetSemanticSearchProps = {
+    query: string;
+    filter?: SemanticRequestFilter;
+};
+export type SemanticSearchResult = {
+    sys: {
+        type: 'SemanticSearchResult';
+        entity: Link<'Entry'>;
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+    };
+};
+export type SemanticSearchProps = {
+    sys: {
+        type: 'Array';
+        correlationId?: string;
+    };
+    items: SemanticSearchResult[];
+};
+export interface SemanticSearch extends SemanticSearchProps, DefaultElements<SemanticSearchProps> {
+}
+export declare function wrapSemanticSearch(_makeRequest: MakeRequest, data: SemanticSearchProps): SemanticSearch;

package/dist/typings/entities/vectorization-status.d.ts

@@ -0,0 +1,32 @@
+import type { DefaultElements, Link, MakeRequest } from '../common-types';
+export declare enum EmbeddingSetStatus {
+    ACTIVE = "ACTIVE",
+    PENDING = "PENDING",
+    ERROR = "ERROR",
+    DISABLED = "DISABLED",
+    DELETING = "DELETING"
+}
+export type SpaceVectorizationStatus = {
+    sys: {
+        space: Link<'Space'>;
+        status: EmbeddingSetStatus;
+        type: 'VectorizationStatus';
+        createdAt: string;
+        updatedAt: string;
+        disabledAt?: string;
+    };
+};
+export type VectorizationStatusProps = {
+    sys: {
+        type: 'Array';
+        correlationId?: string;
+    };
+    items: SpaceVectorizationStatus[];
+};
+export type UpdateVectorizationStatusProps = {
+    spaceId: string;
+    enabled: boolean;
+}[];
+export interface VectorizationStatus extends VectorizationStatusProps, DefaultElements<VectorizationStatusProps> {
+}
+export declare function wrapVectorizationStatus(_makeRequest: MakeRequest, data: VectorizationStatusProps): VectorizationStatus;

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

@@ -65,6 +65,11 @@ export type { ConceptSchemeProps, CreateConceptSchemeProps } from './entities/co
 export type { ResourceProps, ResourceQueryOptions } from './entities/resource';
 export type { ResourceProvider, ResourceProviderProps, UpsertResourceProviderProps, } from './entities/resource-provider';
 export type { ResourceType, ResourceTypeProps, SpaceEnvResourceTypeProps, UpsertResourceTypeProps, } from './entities/resource-type';
+export type { VectorizationStatusProps, VectorizationStatus } from './entities/vectorization-status';
+export type { SemanticDuplicatesProps, SemanticDuplicates } from './entities/semantic-duplicates';
+export type { SemanticRecommendationsProps, SemanticRecommendations, } from './entities/semantic-recommendations';
+export type { SemanticReferenceSuggestionsProps, SemanticReferenceSuggestions, } from './entities/semantic-reference-suggestions';
+export type { SemanticSearchProps, SemanticSearch } from './entities/semantic-search';
 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';

package/dist/typings/plain/common-types.d.ts

@@ -67,6 +67,11 @@ import type { OAuthApplicationPlainClientAPI } from './entities/oauth-applicatio
 import type { FunctionLogPlainClientAPI } from './entities/function-log';
 import type { AiActionPlainClientAPI } from './entities/ai-action';
 import type { AiActionInvocationPlainClientAPI } from './entities/ai-action-invocation';
+import type { VectorizationStatusPlainClientAPI } from './entities/vectorization-status';
+import type { SemanticDuplicatesPlainClientAPI } from './entities/semantic-duplicates';
+import type { SemanticRecommendationsPlainClientAPI } from './entities/semantic-recommendations';
+import type { SemanticReferenceSuggestionsPlainClientAPI } from './entities/semantic-reference-suggestions';
+import type { SemanticSearchPlainClientAPI } from './entities/semantic-search';
 export type PlainClientAPI = {
     raw: {
         getDefaultParams(): DefaultParams | undefined;
@@ -170,6 +175,7 @@ export type PlainClientAPI = {
     user: UserPlainClientAPI;
     entry: {
         getPublished<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<EntryProps<T>>>;
+        getPublishedWithCursor<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorBasedParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<EntryProps<T>>>;
         getMany<T extends KeyValueMap = KeyValueMap>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams & {
             releaseId?: string;
         }>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<EntryProps<T>>>;
@@ -222,6 +228,7 @@ export type PlainClientAPI = {
     };
     asset: {
         getPublished(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<AssetProps>>;
+        getPublishedWithCursor(params: OptionalDefaults<GetSpaceEnvironmentParams & CursorBasedParams>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CursorPaginatedCollectionProp<AssetProps>>;
         getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams & {
             releaseId?: string;
         }>, rawData?: unknown, headers?: RawAxiosRequestHeaders): Promise<CollectionProp<AssetProps>>;
@@ -468,4 +475,9 @@ export type PlainClientAPI = {
     workflow: WorkflowPlainClientAPI;
     workflowsChangelog: WorkflowsChangelogPlainClientAPI;
     oauthApplication: OAuthApplicationPlainClientAPI;
+    vectorizationStatus: VectorizationStatusPlainClientAPI;
+    semanticSearch: SemanticSearchPlainClientAPI;
+    semanticDuplicates: SemanticDuplicatesPlainClientAPI;
+    semanticRecommendations: SemanticRecommendationsPlainClientAPI;
+    semanticReferenceSuggestions: SemanticReferenceSuggestionsPlainClientAPI;
 };

package/dist/typings/plain/entities/semantic-duplicates.d.ts

@@ -0,0 +1,14 @@
+import type { GetSemanticDuplicatesProps, SemanticDuplicatesProps } from '../../entities/semantic-duplicates';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { GetSpaceEnvironmentParams } from '../../common-types';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type SemanticDuplicatesPlainClientAPI = {
+    /**
+     * Retrieves Semantic Duplicates for the given entity ID.
+     * @param params Parameters for getting the space and environment IDs.
+     * @param payload Payload containing entity ID and optional filters.
+     * @param headers Optional headers for the request.
+     * @returns A promise that resolves to Semantic Duplicates.
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams>, payload: GetSemanticDuplicatesProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<SemanticDuplicatesProps>;
+};

package/dist/typings/plain/entities/semantic-recommendations.d.ts

@@ -0,0 +1,14 @@
+import type { GetSemanticRecommendationsProps, SemanticRecommendationsProps } from '../../entities/semantic-recommendations';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { GetSpaceEnvironmentParams } from '../../common-types';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type SemanticRecommendationsPlainClientAPI = {
+    /**
+     * Retrieves Semantic Recommendations for the given entity ID.
+     * @param params Parameters for getting the space and environment IDs.
+     * @param payload Payload containing entity ID and optional filters.
+     * @param headers Optional headers for the request.
+     * @returns A promise that resolves to Semantic Recommendations.
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams>, payload: GetSemanticRecommendationsProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<SemanticRecommendationsProps>;
+};

package/dist/typings/plain/entities/semantic-reference-suggestions.d.ts

@@ -0,0 +1,14 @@
+import type { GetSemanticReferenceSuggestionsProps, SemanticReferenceSuggestionsProps } from '../../entities/semantic-reference-suggestions';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { GetSpaceEnvironmentParams } from '../../common-types';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type SemanticReferenceSuggestionsPlainClientAPI = {
+    /**
+     * Retrieves Semantic Reference Suggestions for the given entity ID and its reference field ID.
+     * @param params Parameters for getting the space and environment IDs.
+     * @param payload Payload containing entity ID, reference field ID and optional filters.
+     * @param headers Optional headers for the request.
+     * @returns A promise that resolves to Semantic Reference Suggestions.
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams>, payload: GetSemanticReferenceSuggestionsProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<SemanticReferenceSuggestionsProps>;
+};

package/dist/typings/plain/entities/semantic-search.d.ts

@@ -0,0 +1,14 @@
+import type { GetSemanticSearchProps, SemanticSearchProps } from '../../entities/semantic-search';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { GetSpaceEnvironmentParams } from '../../common-types';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type SemanticSearchPlainClientAPI = {
+    /**
+     * Retrieves Semantic Search results for the given query.
+     * @param params Parameters for getting the space and environment IDs.
+     * @param payload Payload containing query and optional filters.
+     * @param headers Optional headers for the request.
+     * @returns A promise that resolves to Semantic Search results.
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams>, payload: GetSemanticSearchProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<SemanticSearchProps>;
+};

package/dist/typings/plain/entities/vectorization-status.d.ts

@@ -0,0 +1,21 @@
+import type { UpdateVectorizationStatusProps, VectorizationStatusProps } from '../../entities/vectorization-status';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { GetOrganizationParams } from '../../common-types';
+import type { RawAxiosRequestHeaders } from 'axios';
+export type VectorizationStatusPlainClientAPI = {
+    /**
+     * Fetches the vectorization status for all spaces in an organization.
+     * @param params Parameters for getting the organization.
+     * @param headers Optional headers for the request.
+     * @returns A promise that resolves to the vectorization status of spaces.
+     */
+    get(params: OptionalDefaults<GetOrganizationParams>, headers?: Partial<RawAxiosRequestHeaders>): Promise<VectorizationStatusProps>;
+    /**
+     * Updates the vectorization status for spaces within an organization.
+     * @param params Parameters for getting the organization.
+     * @param payload Payload containing the update information.
+     * @param headers Optional headers for the request.
+     * @returns A promise that resolves to the vectorization status of spaces.
+     */
+    update(params: OptionalDefaults<GetOrganizationParams>, payload: UpdateVectorizationStatusProps, headers?: Partial<RawAxiosRequestHeaders>): Promise<VectorizationStatusProps>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contentful-management",
-  "version": "11.64.0",
+  "version": "11.66.0",
   "description": "Client for Contentful's Content Management API",
   "homepage": "https://www.contentful.com/developers/documentation/content-management-api/",
   "main": "./dist/contentful-management.node.js",