@kontent-ai/delivery-sdk 15.1.1 → 16.0.0-0

package/lib/mappers/language.mapper.ts

@@ -1,20 +1,24 @@
 import { Contracts } from '../contracts';
 import { ILanguage } from '../models';
 
-export class LanguageMapper {
-    mapMultipleLanguages(response: Contracts.IListLanguagesContract): ILanguage[] {
+export class LanguageMapper<TLanguageCodenames extends string> {
+    mapMultipleLanguages(response: Contracts.IListLanguagesContract): ILanguage<TLanguageCodenames>[] {
         return response.languages.map((language) => {
             return this.mapLanguage(language);
         });
     }
 
-    private mapLanguage(language: Contracts.ILanguageContract): ILanguage {
+    private mapLanguage(language: Contracts.ILanguageContract): ILanguage<TLanguageCodenames> {
         if (!language) {
             throw Error(`Cannot map language`);
         }
 
         return {
-            system: language.system
+            system: {
+                codename: language.system.codename as TLanguageCodenames,
+                id: language.system.id,
+                name: language.system.name
+            }
         };
     }
 }

package/lib/mappers/taxonomy.mapper.ts

@@ -1,11 +1,11 @@
 import { Contracts } from '../contracts';
 import { ITaxonomyGroup, ITaxonomySystemAttributes, ITaxonomyTerms } from '../models';
 
-export class TaxonomyMapper {
+export class TaxonomyMapper<TaxonomyCodenames extends string> {
     mapTaxonomy(
         taxonomySystem: Contracts.ITaxonomySystemAttributesContract,
         taxonomyTerms: Contracts.ITaxonomyTermsContract[]
-    ): ITaxonomyGroup {
+    ): ITaxonomyGroup<TaxonomyCodenames> {
         if (!taxonomySystem) {
             throw Error(`Cannot map taxonomy due to missing 'system' property`);
         }
@@ -18,9 +18,9 @@ export class TaxonomyMapper {
             throw Error(`Cannot map terms because no terms array was provided`);
         }
 
-        const mappedSystemAttributes: ITaxonomySystemAttributes = {
+        const mappedSystemAttributes: ITaxonomySystemAttributes<TaxonomyCodenames> = {
             name: taxonomySystem.name,
-            codename: taxonomySystem.codename,
+            codename: taxonomySystem.codename as TaxonomyCodenames,
             id: taxonomySystem.id,
             lastModified: taxonomySystem.last_modified
         };
@@ -33,7 +33,7 @@ export class TaxonomyMapper {
         };
     }
 
-    mapTaxonomies(taxonomies: Contracts.ITaxonomyGroupContract[]): ITaxonomyGroup[] {
+    mapTaxonomies(taxonomies: Contracts.ITaxonomyGroupContract[]): ITaxonomyGroup<TaxonomyCodenames>[] {
         if (!taxonomies) {
             throw Error(`Cannot map taxonomy due to missing 'taxonomies' property`);
         }
@@ -42,7 +42,7 @@ export class TaxonomyMapper {
             throw Error(`Cannot map taxonomies because the 'taxonomies' property is not an array `);
         }
 
-        const mappedTaxonomies: ITaxonomyGroup[] = [];
+        const mappedTaxonomies: ITaxonomyGroup<TaxonomyCodenames>[] = [];
 
         taxonomies.forEach((taxonomy) => {
             mappedTaxonomies.push(this.mapTaxonomy(taxonomy.system, taxonomy.terms));

package/lib/mappers/type.mapper.ts

@@ -1,18 +1,18 @@
 import { Contracts } from '../contracts';
 import { IContentType, IContentTypeSystemAttributes, IGenericElement } from '../models';
 
-export class TypeMapper {
-    mapSingleType(response: Contracts.IViewContentTypeContract): IContentType {
+export class TypeMapper<TContentTypeCodenames extends string> {
+    mapSingleType(response: Contracts.IViewContentTypeContract): IContentType<TContentTypeCodenames> {
         return this.mapType(response);
     }
 
-    mapMultipleTypes(response: Contracts.IListContentTypeContract): IContentType[] {
+    mapMultipleTypes(response: Contracts.IListContentTypeContract): IContentType<TContentTypeCodenames>[] {
         return response.types.map((type) => {
             return this.mapType(type);
         });
     }
 
-    private mapType(type: Contracts.IContentTypeContract): IContentType {
+    private mapType(type: Contracts.IContentTypeContract): IContentType<TContentTypeCodenames> {
         if (!type) {
             throw Error(`Cannot map type`);
         }
@@ -21,8 +21,8 @@ export class TypeMapper {
             throw Error(`Cannot map type elements`);
         }
 
-        const system: IContentTypeSystemAttributes = {
-            codename: type.system.codename,
+        const system: IContentTypeSystemAttributes<TContentTypeCodenames> = {
+            codename: type.system.codename as TContentTypeCodenames,
             id: type.system.id,
             name: type.system.name,
             lastModified: type.system.last_modified

package/lib/models/content-type-models.ts

@@ -1,7 +1,7 @@
 import { IQueryConfig } from './common/common-models';
 import { IGenericElement } from './element-models';
 
-export interface IContentTypeSystemAttributes {
+export interface IContentTypeSystemAttributes<TContentTypeCodename extends string> {
     /**
      * Id of the type
      */
@@ -15,7 +15,7 @@ export interface IContentTypeSystemAttributes {
     /**
      * Codename of the type
      */
-    codename: string;
+    codename: TContentTypeCodename;
 
     /**
      * Date of last modification
@@ -23,11 +23,11 @@ export interface IContentTypeSystemAttributes {
     lastModified: Date;
 }
 
-export interface IContentType {
+export interface IContentType<TContentTypeCodename extends string> {
     /**
      * Content type system attributes
      */
-    system: IContentTypeSystemAttributes;
+    system: IContentTypeSystemAttributes<TContentTypeCodename>;
 
     /**
      * Elements (elements) assigned to content type

package/lib/models/item-models.ts

@@ -2,9 +2,12 @@ import { Contracts } from '../contracts';
 import { ElementModels } from '../elements/element-models';
 import { IQueryConfig } from './common/common-models';
 
-export interface IMapElementsResult<TContentItem extends IContentItem = IContentItem> {
+export interface IMapElementsResult<
+    TContentItem extends IContentItem = IContentItem,
+    TLinkedItemType extends IContentItem = IContentItem
+> {
     item: TContentItem;
-    processedItems: IContentItemsContainer;
+    processedItems: IContentItemsContainer<TLinkedItemType>;
     preparedItems: IContentItemWithRawDataContainer;
     processingStartedForCodenames: string[];
 }
@@ -83,6 +86,11 @@ export type IContentItemElements<TElementCodenames extends string = string> = Re
     ContentItemElementsIndexer
 >;
 
+export type Snippet<
+    TElementCodenames extends string,
+    TElements extends IContentItemElements<TElementCodenames>
+> = TElements;
+
 export interface IContentItem<
     TElements extends IContentItemElements<TTypeElementCodenames> = IContentItemElements,
     TTypeCodename extends string = string,
@@ -140,8 +148,8 @@ export interface IContentItemWithRawDataContainer {
     [key: string]: IContentItemWithRawElements;
 }
 
-export interface IContentItemsContainer {
-    [key: string]: IContentItem;
+export interface IContentItemsContainer<TContentItem extends IContentItem> {
+    [key: string]: TContentItem | undefined;
 }
 
 export interface IRichTextImage {
@@ -157,3 +165,14 @@ export interface IItemQueryConfig extends IQueryConfig {}
 export interface IItemFeedQueryConfig extends IQueryConfig {
     disableItemLinking?: boolean;
 }
+
+export type ClientTypes = {
+    readonly contentItemType: IContentItem;
+    readonly contentTypeCodenames: string;
+    readonly workflowCodenames: string;
+    readonly worfklowStepCodenames: string;
+    readonly collectionCodenames: string;
+    readonly taxonomyCodenames: string;
+    readonly languageCodenames: string;
+    readonly elementCodenames: string;
+};

package/lib/models/language-models.ts

@@ -1,13 +1,13 @@
 import { IQueryConfig } from './common';
 
-export interface ILanguageSystem {
+export interface ILanguageSystem<TLanguageCodenames extends string> {
     id: string;
     name: string;
-    codename: string;
+    codename: TLanguageCodenames;
 }
 
-export interface ILanguage {
-    system: ILanguageSystem;
+export interface ILanguage<TLanguageCodenames extends string> {
+    system: ILanguageSystem<TLanguageCodenames>;
 }
 
 export interface ILanguagesQueryConfig extends IQueryConfig {

package/lib/models/responses.ts

@@ -10,61 +10,76 @@ import { IContentItemDelta } from './sync-models';
 import { ITaxonomyGroup } from './taxonomy-models';
 
 export namespace Responses {
-    export interface IListContentTypesResponse extends IKontentListResponse {
-        items: IContentType[];
+    export interface IListContentTypesResponse<TContentTypeCodename extends string> extends IKontentListResponse {
+        items: IContentType<TContentTypeCodename>[];
         pagination: IPagination;
     }
 
-    export interface IListContentTypesAllResponse extends IKontentListAllResponse {
-        items: IContentType[];
-        responses: IDeliveryNetworkResponse<IListContentTypesResponse, Contracts.IListContentTypeContract>[];
+    export interface IListContentTypesAllResponse<TContentTypeCodename extends string> extends IKontentListAllResponse {
+        items: IContentType<TContentTypeCodename>[];
+        responses: IDeliveryNetworkResponse<
+            IListContentTypesResponse<TContentTypeCodename>,
+            Contracts.IListContentTypeContract
+        >[];
     }
 
-    export interface IViewContentTypeResponse extends IKontentResponse {
-        type: IContentType;
+    export interface IViewContentTypeResponse<TContentTypeCodename extends string> extends IKontentResponse {
+        type: IContentType<TContentTypeCodename>;
     }
 
-    
     export interface IViewContentTypeElementResponse extends IKontentResponse {
-        codename?: string,
-        type: string,
+        codename?: string;
+        type: string;
         name: string;
-        taxonomyGroup?: string
+        taxonomyGroup?: string;
         options: IGenericElementOption[];
     }
 
-    export interface IListItemsFeedResponse<TContentItem extends IContentItem = IContentItem>
-        extends IKontentListResponse {
+    export interface IListItemsFeedResponse<
+        TContentItem extends IContentItem = IContentItem,
+        TLinkedItemType extends IContentItem = IContentItem
+    > extends IKontentListResponse {
         items: TContentItem[];
-        linkedItems: IContentItemsContainer;
+        linkedItems: IContentItemsContainer<TLinkedItemType>;
     }
 
-    export interface IListItemsFeedAllResponse<TContentItem extends IContentItem = IContentItem>
-        extends IKontentListAllResponse {
+    export interface IListItemsFeedAllResponse<
+        TContentItem extends IContentItem = IContentItem,
+        TLinkedItemType extends IContentItem = IContentItem
+    > extends IKontentListAllResponse {
         items: TContentItem[];
-        responses: IDeliveryNetworkResponse<IListItemsFeedResponse<TContentItem>, Contracts.IItemsFeedContract>[];
+        responses: IDeliveryNetworkResponse<
+            IListItemsFeedResponse<TContentItem, TLinkedItemType>,
+            Contracts.IItemsFeedContract
+        >[];
     }
 
-    export interface IListContentItemsResponse<TContentItem extends IContentItem = IContentItem>
-        extends IKontentListResponse {
+    export interface IListContentItemsResponse<
+        TContentItem extends IContentItem = IContentItem,
+        TLinkedItemType extends IContentItem = IContentItem
+    > extends IKontentListResponse {
         items: TContentItem[];
         pagination: IPagination;
-        linkedItems: IContentItemsContainer;
+        linkedItems: IContentItemsContainer<TLinkedItemType>;
     }
 
-    export interface IListContentItemsAllResponse<TContentItem extends IContentItem = IContentItem>
-        extends IKontentListAllResponse {
+    export interface IListContentItemsAllResponse<
+        TContentItem extends IContentItem = IContentItem,
+        TLinkedItemType extends IContentItem = IContentItem
+    > extends IKontentListAllResponse {
         items: TContentItem[];
         responses: IDeliveryNetworkResponse<
-            IListContentItemsResponse<TContentItem>,
+            IListContentItemsResponse<TContentItem, TLinkedItemType>,
             Contracts.IListContentItemsContract
         >[];
     }
 
-    export interface IViewContentItemResponse<TContentItem extends IContentItem = IContentItem>
-        extends IKontentResponse {
+    export interface IViewContentItemResponse<
+        TContentItem extends IContentItem = IContentItem,
+        TLinkedItemType extends IContentItem = IContentItem
+    > extends IKontentResponse {
         item: TContentItem;
-        linkedItems: IContentItemsContainer;
+        linkedItems: IContentItemsContainer<TLinkedItemType>;
     }
 
     export interface IInitializeSyncResponse extends IKontentResponse {
@@ -80,27 +95,33 @@ export namespace Responses {
         responses: IDeliveryNetworkResponse<ISyncChangesResponse, Contracts.ISyncChangesContract>[];
     }
 
-    export interface IListLanguagesResponse extends IKontentListResponse {
-        items: ILanguage[];
+    export interface IListLanguagesResponse<TLanguageCodenames extends string> extends IKontentListResponse {
+        items: ILanguage<TLanguageCodenames>[];
         pagination: IPagination;
     }
 
-    export interface IListLanguagesAllResponse extends IKontentListAllResponse {
-        items: ILanguage[];
-        responses: IDeliveryNetworkResponse<IListLanguagesResponse, Contracts.IListLanguagesContract>[];
+    export interface IListLanguagesAllResponse<TLanguageCodenames extends string> extends IKontentListAllResponse {
+        items: ILanguage<TLanguageCodenames>[];
+        responses: IDeliveryNetworkResponse<
+            IListLanguagesResponse<TLanguageCodenames>,
+            Contracts.IListLanguagesContract
+        >[];
     }
 
-    export interface IViewTaxonomyResponse extends IKontentResponse {
-        taxonomy: ITaxonomyGroup;
+    export interface IViewTaxonomyResponse<TaxonomyCodename extends string> extends IKontentResponse {
+        taxonomy: ITaxonomyGroup<TaxonomyCodename>;
     }
 
-    export interface IListTaxonomiesResponse extends IKontentListResponse {
-        items: ITaxonomyGroup[];
+    export interface IListTaxonomiesResponse<TaxonomyCodename extends string> extends IKontentListResponse {
+        items: ITaxonomyGroup<TaxonomyCodename>[];
         pagination: IPagination;
     }
 
-    export interface IListTaxonomiesAllResponse extends IKontentListAllResponse {
-        items: ITaxonomyGroup[];
-        responses: IDeliveryNetworkResponse<IListTaxonomiesResponse, Contracts.IListTaxonomyGroupsContract>[];
+    export interface IListTaxonomiesAllResponse<TaxonomyCodename extends string> extends IKontentListAllResponse {
+        items: ITaxonomyGroup<TaxonomyCodename>[];
+        responses: IDeliveryNetworkResponse<
+            IListTaxonomiesResponse<TaxonomyCodename>,
+            Contracts.IListTaxonomyGroupsContract
+        >[];
     }
 }

package/lib/models/taxonomy-models.ts

@@ -1,14 +1,14 @@
 import { IQueryConfig } from './common/common-models';
 
-export interface ITaxonomyGroup {
-    system: ITaxonomySystemAttributes;
+export interface ITaxonomyGroup<TaxonomyCodename extends string> {
+    system: ITaxonomySystemAttributes<TaxonomyCodename>;
     terms: ITaxonomyTerms[];
 }
 
-export interface ITaxonomySystemAttributes {
+export interface ITaxonomySystemAttributes<TaxonomyCodename extends string> {
     id: string;
     name: string;
-    codename: string;
+    codename: TaxonomyCodename;
     lastModified: Date;
 }
 

package/lib/query/common/base-item-listing-query.class.ts

@@ -1,5 +1,6 @@
 import { IDeliveryClientConfig } from '../../config';
 import {
+    ClientTypes,
     Filters,
     IKontentListAllResponse,
     IKontentListResponse,
@@ -11,12 +12,13 @@ import { QueryService } from '../../services';
 import { BaseListingQuery } from './base-listing-query.class';
 
 export abstract class BaseItemListingQuery<
+    TClientTypes extends ClientTypes,
     TResponse extends IKontentListResponse,
     TAllResponse extends IKontentListAllResponse,
     TQueryConfig extends IQueryConfig,
     TContract
-> extends BaseListingQuery<TResponse, TAllResponse, TQueryConfig, TContract> {
-    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+> extends BaseListingQuery<TClientTypes, TResponse, TAllResponse, TQueryConfig, TContract> {
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService<TClientTypes>) {
         super(config, queryService);
     }
 

package/lib/query/common/base-listing-query.class.ts

@@ -8,18 +8,20 @@ import {
     IDeliveryNetworkResponse,
     IListAllQueryConfig,
     IQueryConfig,
-    IContentItem
+    IContentItem,
+    ClientTypes
 } from '../../models';
 import { QueryService } from '../../services';
 import { BaseQuery } from './base-query.class';
 
 export abstract class BaseListingQuery<
+    TClientTypes extends ClientTypes,
     TResponse extends IKontentListResponse,
     TAllResponse extends IKontentListAllResponse,
     TQueryConfig extends IQueryConfig,
     TContract
-> extends BaseQuery<TResponse, TQueryConfig, TContract> {
-    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+> extends BaseQuery<TClientTypes, TResponse, TQueryConfig, TContract> {
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService<TClientTypes>) {
         super(config, queryService);
     }
 

package/lib/query/common/base-query.class.ts

@@ -1,14 +1,26 @@
 import { IHeader, IQueryParameter } from '@kontent-ai/core-sdk';
 
 import { IDeliveryClientConfig } from '../../config';
-import { Filters, IDeliveryNetworkResponse, IKontentResponse, IQueryConfig, Parameters } from '../../models';
+import {
+    ClientTypes,
+    Filters,
+    IDeliveryNetworkResponse,
+    IKontentResponse,
+    IQueryConfig,
+    Parameters
+} from '../../models';
 import { QueryService } from '../../services';
 
-export abstract class BaseQuery<TResponse extends IKontentResponse, TQueryConfig extends IQueryConfig, TContract> {
+export abstract class BaseQuery<
+    TClientTypes extends ClientTypes,
+    TResponse extends IKontentResponse,
+    TQueryConfig extends IQueryConfig,
+    TContract
+> {
     protected parameters: IQueryParameter[] = [];
     protected customUrl?: string;
     protected abstract _queryConfig: TQueryConfig;
-    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {}
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService<TClientTypes>) {}
 
     /**
      * Gets URL of the query

package/lib/query/element/element-query.class.ts

@@ -1,20 +1,20 @@
 import { Contracts } from '../../contracts';
 import { IDeliveryClientConfig } from '../../config';
-import { Responses, IElementQueryConfig, IDeliveryNetworkResponse } from '../../models';
+import { Responses, IElementQueryConfig, IDeliveryNetworkResponse, ClientTypes } from '../../models';
 import { QueryService } from '../../services';
 import { BaseQuery } from '../common/base-query.class';
 
-export class ElementQuery extends BaseQuery<
+export class ElementQuery<TClientTypes extends ClientTypes> extends BaseQuery<
+    TClientTypes,
     Responses.IViewContentTypeElementResponse,
     IElementQueryConfig,
     Contracts.IViewContentTypeElementContract
 > {
-
     protected _queryConfig: IElementQueryConfig = {};
 
     constructor(
         protected config: IDeliveryClientConfig,
-        protected queryService: QueryService,
+        protected queryService: QueryService<TClientTypes>,
         private typeCodename: string,
         private elementCodename: string
     ) {
@@ -30,10 +30,7 @@ export class ElementQuery extends BaseQuery<
     }
 
     toPromise(): Promise<
-        IDeliveryNetworkResponse<
-            Responses.IViewContentTypeElementResponse,
-            Contracts.IViewContentTypeElementContract
-        >
+        IDeliveryNetworkResponse<Responses.IViewContentTypeElementResponse, Contracts.IViewContentTypeElementContract>
     > {
         return this.queryService.getElementAsync(this.getUrl(), this._queryConfig ?? {});
     }

package/lib/query/item/multiple-items-query.class.ts

@@ -1,18 +1,30 @@
 import { Contracts } from '../../contracts';
 import { IDeliveryClientConfig } from '../../config';
-import { Filters, IContentItem, IItemQueryConfig, IDeliveryNetworkResponse, Responses, Parameters } from '../../models';
+import {
+    Filters,
+    IContentItem,
+    IItemQueryConfig,
+    IDeliveryNetworkResponse,
+    Responses,
+    Parameters,
+    ClientTypes
+} from '../../models';
 import { QueryService } from '../../services';
 import { BaseItemListingQuery } from '../common/base-item-listing-query.class';
 
-export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem> extends BaseItemListingQuery<
-    Responses.IListContentItemsResponse<TContentItem>,
-    Responses.IListContentItemsAllResponse<TContentItem>,
+export class MultipleItemsQuery<
+    TClientTypes extends ClientTypes,
+    TContentItem extends IContentItem = IContentItem
+> extends BaseItemListingQuery<
+    TClientTypes,
+    Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']>,
+    Responses.IListContentItemsAllResponse<TContentItem, TClientTypes['contentItemType']>,
     IItemQueryConfig,
     Contracts.IListContentItemsContract
 > {
     protected _queryConfig: IItemQueryConfig = {};
 
-    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService<TClientTypes>) {
         super(config, queryService);
     }
 
@@ -30,7 +42,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * Gets only item of given type
      * @param type Codename of type to get
      */
-    type(type: string): this {
+    type(type: TClientTypes['contentTypeCodenames']): this {
         this.parameters.push(new Filters.TypeFilter(type));
         return this;
     }
@@ -40,7 +52,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * I.e. get items of either 'Actor' or 'Movie' type
      * @param types Types to get
      */
-    types(types: string[]): this {
+    types(types: TClientTypes['contentTypeCodenames'][]): this {
         this.parameters.push(new Filters.TypeFilter(types));
         return this;
     }
@@ -49,7 +61,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * Gets only item from given collection
      * @param collection Codename of collection to get
      */
-    collection(collection: string): this {
+    collection(collection: TClientTypes['collectionCodenames']): this {
         this.parameters.push(new Filters.CollectionFilter(collection));
         return this;
     }
@@ -59,7 +71,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * I.e. get items of either 'default' or 'christmas-campaign' collection
      * @param collections Collections to get
      */
-    collections(collections: string[]): this {
+    collections(collections: TClientTypes['collectionCodenames'][]): this {
         this.parameters.push(new Filters.CollectionFilter(collections));
         return this;
     }
@@ -77,7 +89,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * Language codename
      * @param languageCodename Codename of the language
      */
-    languageParameter(languageCodename: string): this {
+    languageParameter(languageCodename: TClientTypes['languageCodenames']): this {
         this.parameters.push(new Parameters.LanguageParameter(languageCodename));
         return this;
     }
@@ -86,7 +98,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * Used to limit the number of elements returned by query.
      * @param elementCodenames Array of element codenames to fetch
      */
-    elementsParameter(elementCodenames: string[]): this {
+    elementsParameter(elementCodenames: TClientTypes['elementCodenames'][]): this {
         this.parameters.push(new Parameters.ElementsParameter(elementCodenames));
         return this;
     }
@@ -95,13 +107,16 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
      * Used to exclude elements returned by query.
      * @param elementCodenames Array of element codenames to exclude
      */
-    excludeElementsParameter(elementCodenames: string[]): this {
+    excludeElementsParameter(elementCodenames: TClientTypes['elementCodenames'][]): this {
         this.parameters.push(new Parameters.ExcludeElementsParameter(elementCodenames));
         return this;
     }
 
     toPromise(): Promise<
-        IDeliveryNetworkResponse<Responses.IListContentItemsResponse<TContentItem>, Contracts.IListContentItemsContract>
+        IDeliveryNetworkResponse<
+            Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']>,
+            Contracts.IListContentItemsContract
+        >
     > {
         return this.queryService.getMultipleItems(this.getUrl(), this._queryConfig ?? {});
     }
@@ -118,17 +133,17 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
         return super.resolveUrlInternal(action);
     }
 
-    map(json: any): Responses.IListContentItemsResponse<TContentItem> {
+    map(json: any): Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']> {
         return this.queryService.mappingService.listContentItemsResponse(json);
     }
 
     protected allResponseFactory(
         items: any[],
         responses: IDeliveryNetworkResponse<
-            Responses.IListContentItemsResponse<TContentItem>,
+            Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']>,
             Contracts.IListContentItemsContract
         >[]
-    ): Responses.IListContentItemsAllResponse<TContentItem> {
+    ): Responses.IListContentItemsAllResponse<TContentItem, TClientTypes['contentItemType']> {
         this.linkItems(items, responses);
 
         return {
@@ -140,7 +155,7 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
     private linkItems(
         items: IContentItem[],
         responses: IDeliveryNetworkResponse<
-            Responses.IListContentItemsResponse<TContentItem>,
+            Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']>,
             Contracts.IListContentItemsContract
         >[]
     ): void {
@@ -149,7 +164,11 @@ export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem
 
         // process linked items (modular_content part of the response)
         for (const response of responses) {
-            allContentItems.push(...Object.values(response.data.linkedItems));
+            allContentItems.push(
+                ...Object.values(response.data.linkedItems)
+                    .filter((m) => m !== undefined)
+                    .map((m) => m as TClientTypes['contentItemType'])
+            );
         }
 
         // add standard items