@salesforce/lds-adapters-industries-timeline 1.168.0 → 1.169.0

package/dist/es/es2018/industries-timeline.js

@@ -58,6 +58,373 @@ function createLink(ref) {
     };
 }
 
+function validate$e(obj, path = 'DmoFieldsOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_displayName = obj.displayName;
+        const path_displayName = path + '.displayName';
+        if (typeof obj_displayName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_displayName + '" (at "' + path_displayName + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$d(obj, path = 'RelationshipTypeOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_attribute = obj.attribute;
+        const path_attribute = path + '.attribute';
+        if (typeof obj_attribute !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_attribute + '" (at "' + path_attribute + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$c(obj, path = 'DmoRelationshipsOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fromEntity = obj.fromEntity;
+        const path_fromEntity = path + '.fromEntity';
+        const referencepath_fromEntityValidationError = validate$d(obj_fromEntity, path_fromEntity);
+        if (referencepath_fromEntityValidationError !== null) {
+            let message = 'Object doesn\'t match RelationshipTypeOutputRepresentation (at "' + path_fromEntity + '")\n';
+            message += referencepath_fromEntityValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_toEntity = obj.toEntity;
+        const path_toEntity = path + '.toEntity';
+        const referencepath_toEntityValidationError = validate$d(obj_toEntity, path_toEntity);
+        if (referencepath_toEntityValidationError !== null) {
+            let message = 'Object doesn\'t match RelationshipTypeOutputRepresentation (at "' + path_toEntity + '")\n';
+            message += referencepath_toEntityValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$b(obj, path = 'DmoOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_category = obj.category;
+        const path_category = path + '.category';
+        if (typeof obj_category !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_category + '" (at "' + path_category + '")');
+        }
+        const obj_displayName = obj.displayName;
+        const path_displayName = path + '.displayName';
+        if (typeof obj_displayName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_displayName + '" (at "' + path_displayName + '")');
+        }
+        const obj_fields = obj.fields;
+        const path_fields = path + '.fields';
+        if (!ArrayIsArray(obj_fields)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_fields + '" (at "' + path_fields + '")');
+        }
+        for (let i = 0; i < obj_fields.length; i++) {
+            const obj_fields_item = obj_fields[i];
+            const path_fields_item = path_fields + '[' + i + ']';
+            const referencepath_fields_itemValidationError = validate$e(obj_fields_item, path_fields_item);
+            if (referencepath_fields_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DmoFieldsOutputRepresentation (at "' + path_fields_item + '")\n';
+                message += referencepath_fields_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_relationships = obj.relationships;
+        const path_relationships = path + '.relationships';
+        if (!ArrayIsArray(obj_relationships)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_relationships + '" (at "' + path_relationships + '")');
+        }
+        for (let i = 0; i < obj_relationships.length; i++) {
+            const obj_relationships_item = obj_relationships[i];
+            const path_relationships_item = path_relationships + '[' + i + ']';
+            const referencepath_relationships_itemValidationError = validate$c(obj_relationships_item, path_relationships_item);
+            if (referencepath_relationships_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DmoRelationshipsOutputRepresentation (at "' + path_relationships_item + '")\n';
+                message += referencepath_relationships_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$2 = 600000;
+const VERSION$2 = "84ccc17f91013e292e7b01a291dd0322";
+function validate$a(obj, path = 'CdpMetadataOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_dmos = obj.dmos;
+        const path_dmos = path + '.dmos';
+        if (!ArrayIsArray(obj_dmos)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_dmos + '" (at "' + path_dmos + '")');
+        }
+        for (let i = 0; i < obj_dmos.length; i++) {
+            const obj_dmos_item = obj_dmos[i];
+            const path_dmos_item = path_dmos + '[' + i + ']';
+            const referencepath_dmos_itemValidationError = validate$b(obj_dmos_item, path_dmos_item);
+            if (referencepath_dmos_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DmoOutputRepresentation (at "' + path_dmos_item + '")\n';
+                message += referencepath_dmos_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'CdpMetadataOutputRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$5 = function CdpMetadataOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        opaque: true
+    };
+};
+function equals$2(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function CdpMetadataOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$2;
+    let incomingRecord = normalize$2(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "Timeline",
+            version: VERSION$2,
+            representationName: RepresentationType$2,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$4(luvio, params) {
+    return select$5();
+}
+function keyBuilder$5(luvio, params) {
+    return keyPrefix + '::CdpMetadataOutputRepresentation:(' + 'objectCategory:' + params.queryParams.objectCategory + ')';
+}
+function getResponseCacheKeys$2(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response, () => keyBuilder$5(luvio, resourceParams));
+}
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$5(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$5(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$2,
+        representationName: RepresentationType$2
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/connect/timeline/cust-data-pfrm/data-model-objects',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getDataModelObjects_ConfigPropertyNames = {
+    displayName: 'getDataModelObjects',
+    parameters: {
+        required: [],
+        optional: ['objectCategory']
+    }
+};
+function createResourceParams$2(config) {
+    const resourceParams = {
+        queryParams: {
+            objectCategory: config.objectCategory
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$4(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$5(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_objectCategory = untrustedConfig.objectCategory;
+    if (typeof untrustedConfig_objectCategory === 'string') {
+        config.objectCategory = untrustedConfig_objectCategory;
+    }
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$2(luvio, config) {
+    createResourceParams$2(config);
+    return select$4();
+}
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$2(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$2(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$4(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDataModelObjectsAdapterFactory = (luvio) => function Timeline__getDataModelObjects(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getDataModelObjects_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
 function validate$9(obj, path = 'TimelineErrorRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1505,4 +1872,4 @@ const getTimelineMetadataAdapterFactory = (luvio) => function Timeline__getTimel
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { getTimelineDataAdapterFactory, getTimelineMetadataAdapterFactory };
+export { getDataModelObjectsAdapterFactory, getTimelineDataAdapterFactory, getTimelineMetadataAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/getDataModelObjects.d.ts

@@ -0,0 +1,26 @@
+import { AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig, Untrusted as adapter$45$utils_Untrusted } from './adapter-utils';
+import { ResourceRequestConfig as resources_getConnectTimelineCustDataPfrmDataModelObjects_ResourceRequestConfig } from '../resources/getConnectTimelineCustDataPfrmDataModelObjects';
+import { Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { CdpMetadataOutputRepresentation as types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation } from '../types/CdpMetadataOutputRepresentation';
+export declare const adapterName = "getDataModelObjects";
+export declare const getDataModelObjects_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetDataModelObjectsConfig {
+    objectCategory?: string;
+}
+export declare function createResourceParams(config: GetDataModelObjectsConfig): resources_getConnectTimelineCustDataPfrmDataModelObjects_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetDataModelObjectsConfig>): adapter$45$utils_Untrusted<GetDataModelObjectsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetDataModelObjectsConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig): $64$luvio_engine_Snapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig, resourceParams: resources_getConnectTimelineCustDataPfrmDataModelObjects_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig, resourceParams: resources_getConnectTimelineCustDataPfrmDataModelObjects_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetDataModelObjectsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetDataModelObjectsConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation>): $64$luvio_engine_Snapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, any>;
+export declare const getDataModelObjectsAdapterFactory: $64$luvio_engine_AdapterFactory<GetDataModelObjectsConfig, types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -1,2 +1,3 @@
+export { getDataModelObjectsAdapterFactory } from '../adapters/getDataModelObjects';
 export { getTimelineDataAdapterFactory } from '../adapters/getTimelineData';
 export { getTimelineMetadataAdapterFactory } from '../adapters/getTimelineMetadata';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -1,5 +1,7 @@
+declare let getDataModelObjects: any;
 declare let getTimelineData: any;
 declare let getTimelineMetadata: any;
+declare let getDataModelObjects_imperative: any;
 declare let getTimelineData_imperative: any;
 declare let getTimelineMetadata_imperative: any;
-export { getTimelineData, getTimelineMetadata, getTimelineData_imperative, getTimelineMetadata_imperative };
+export { getDataModelObjects, getTimelineData, getTimelineMetadata, getDataModelObjects_imperative, getTimelineData_imperative, getTimelineMetadata_imperative };

package/dist/es/es2018/types/src/generated/resources/getConnectTimelineCustDataPfrmDataModelObjects.d.ts

@@ -0,0 +1,15 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { CdpMetadataOutputRepresentation as types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation } from '../types/CdpMetadataOutputRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        objectCategory?: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_CdpMetadataOutputRepresentation_CdpMetadataOutputRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/es/es2018/types/src/generated/types/CdpMetadataOutputRepresentation.d.ts

@@ -0,0 +1,30 @@
+import { DmoOutputRepresentation as DmoOutputRepresentation_DmoOutputRepresentation } from './DmoOutputRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 600000;
+export declare const VERSION = "84ccc17f91013e292e7b01a291dd0322";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMetadataOutputRepresentation, existing: CdpMetadataOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMetadataOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: CdpMetadataOutputRepresentationNormalized, incoming: CdpMetadataOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: CdpMetadataOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation to fetch all engagement dmos
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMetadataOutputRepresentationNormalized {
+    /** get all dmos */
+    dmos: Array<DmoOutputRepresentation_DmoOutputRepresentation>;
+}
+/**
+ * Output representation to fetch all engagement dmos
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMetadataOutputRepresentation {
+    dmos: Array<DmoOutputRepresentation_DmoOutputRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/DmoFieldsOutputRepresentation.d.ts

@@ -0,0 +1,34 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "3de3d025c0a0af44f39305af7a738239";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DmoFieldsOutputRepresentation, existing: DmoFieldsOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DmoFieldsOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DmoFieldsOutputRepresentationNormalized, incoming: DmoFieldsOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DmoFieldsOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of each field of DMO
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DmoFieldsOutputRepresentationNormalized {
+    /** get display name of a dmo */
+    displayName: string;
+    /** get name of a dmo */
+    name: string;
+    /** get type of fields */
+    type: string;
+}
+/**
+ * Output representation of each field of DMO
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DmoFieldsOutputRepresentation {
+    displayName: string;
+    name: string;
+    type: string;
+}

package/dist/es/es2018/types/src/generated/types/DmoOutputRepresentation.d.ts

@@ -0,0 +1,42 @@
+import { DmoFieldsOutputRepresentation as DmoFieldsOutputRepresentation_DmoFieldsOutputRepresentation } from './DmoFieldsOutputRepresentation';
+import { DmoRelationshipsOutputRepresentation as DmoRelationshipsOutputRepresentation_DmoRelationshipsOutputRepresentation } from './DmoRelationshipsOutputRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "f50724468fc2f740b113fd9591e37b8b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DmoOutputRepresentation, existing: DmoOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DmoOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DmoOutputRepresentationNormalized, incoming: DmoOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DmoOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of each dmo
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DmoOutputRepresentationNormalized {
+    /** get category of a dmo */
+    category: string;
+    /** get display name of a dmo */
+    displayName: string;
+    /** get all fields of a dmo */
+    fields: Array<DmoFieldsOutputRepresentation_DmoFieldsOutputRepresentation>;
+    /** get name of a dmo */
+    name: string;
+    /** get all relationships of a dmo */
+    relationships: Array<DmoRelationshipsOutputRepresentation_DmoRelationshipsOutputRepresentation>;
+}
+/**
+ * Output representation of each dmo
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DmoOutputRepresentation {
+    category: string;
+    displayName: string;
+    fields: Array<DmoFieldsOutputRepresentation_DmoFieldsOutputRepresentation>;
+    name: string;
+    relationships: Array<DmoRelationshipsOutputRepresentation_DmoRelationshipsOutputRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/DmoRelationshipsOutputRepresentation.d.ts

@@ -0,0 +1,30 @@
+import { RelationshipTypeOutputRepresentation as RelationshipTypeOutputRepresentation_RelationshipTypeOutputRepresentation } from './RelationshipTypeOutputRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "bd9cfb2e9b327ac378ff320957463a19";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DmoRelationshipsOutputRepresentation, existing: DmoRelationshipsOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DmoRelationshipsOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DmoRelationshipsOutputRepresentationNormalized, incoming: DmoRelationshipsOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DmoRelationshipsOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of relationships for a DMO
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DmoRelationshipsOutputRepresentationNormalized {
+    fromEntity: RelationshipTypeOutputRepresentation_RelationshipTypeOutputRepresentation;
+    toEntity: RelationshipTypeOutputRepresentation_RelationshipTypeOutputRepresentation;
+}
+/**
+ * Output representation of relationships for a DMO
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DmoRelationshipsOutputRepresentation {
+    fromEntity: RelationshipTypeOutputRepresentation_RelationshipTypeOutputRepresentation;
+    toEntity: RelationshipTypeOutputRepresentation_RelationshipTypeOutputRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/RelationshipTypeOutputRepresentation.d.ts

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "9d364af703abf32478364b295d0a5a1b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: RelationshipTypeOutputRepresentation, existing: RelationshipTypeOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): RelationshipTypeOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: RelationshipTypeOutputRepresentationNormalized, incoming: RelationshipTypeOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: RelationshipTypeOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of relationship type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RelationshipTypeOutputRepresentationNormalized {
+    /** get attribute of the entity in Relationship  */
+    attribute: string;
+    /** get name of the entity in Relationship  */
+    name: string;
+}
+/**
+ * Output representation of relationship type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RelationshipTypeOutputRepresentation {
+    attribute: string;
+    name: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-industries-timeline",
-    "version": "1.168.0",
+    "version": "1.169.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": " GET Resource to get the Timeline Data",
     "main": "dist/es/es2018/industries-timeline.js",

package/sfdc/index.js

@@ -68,6 +68,373 @@ function createLink(ref) {
     };
 }
 
+function validate$e(obj, path = 'DmoFieldsOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_displayName = obj.displayName;
+        const path_displayName = path + '.displayName';
+        if (typeof obj_displayName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_displayName + '" (at "' + path_displayName + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$d(obj, path = 'RelationshipTypeOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_attribute = obj.attribute;
+        const path_attribute = path + '.attribute';
+        if (typeof obj_attribute !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_attribute + '" (at "' + path_attribute + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$c(obj, path = 'DmoRelationshipsOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fromEntity = obj.fromEntity;
+        const path_fromEntity = path + '.fromEntity';
+        const referencepath_fromEntityValidationError = validate$d(obj_fromEntity, path_fromEntity);
+        if (referencepath_fromEntityValidationError !== null) {
+            let message = 'Object doesn\'t match RelationshipTypeOutputRepresentation (at "' + path_fromEntity + '")\n';
+            message += referencepath_fromEntityValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_toEntity = obj.toEntity;
+        const path_toEntity = path + '.toEntity';
+        const referencepath_toEntityValidationError = validate$d(obj_toEntity, path_toEntity);
+        if (referencepath_toEntityValidationError !== null) {
+            let message = 'Object doesn\'t match RelationshipTypeOutputRepresentation (at "' + path_toEntity + '")\n';
+            message += referencepath_toEntityValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$b(obj, path = 'DmoOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_category = obj.category;
+        const path_category = path + '.category';
+        if (typeof obj_category !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_category + '" (at "' + path_category + '")');
+        }
+        const obj_displayName = obj.displayName;
+        const path_displayName = path + '.displayName';
+        if (typeof obj_displayName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_displayName + '" (at "' + path_displayName + '")');
+        }
+        const obj_fields = obj.fields;
+        const path_fields = path + '.fields';
+        if (!ArrayIsArray(obj_fields)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_fields + '" (at "' + path_fields + '")');
+        }
+        for (let i = 0; i < obj_fields.length; i++) {
+            const obj_fields_item = obj_fields[i];
+            const path_fields_item = path_fields + '[' + i + ']';
+            const referencepath_fields_itemValidationError = validate$e(obj_fields_item, path_fields_item);
+            if (referencepath_fields_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DmoFieldsOutputRepresentation (at "' + path_fields_item + '")\n';
+                message += referencepath_fields_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_relationships = obj.relationships;
+        const path_relationships = path + '.relationships';
+        if (!ArrayIsArray(obj_relationships)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_relationships + '" (at "' + path_relationships + '")');
+        }
+        for (let i = 0; i < obj_relationships.length; i++) {
+            const obj_relationships_item = obj_relationships[i];
+            const path_relationships_item = path_relationships + '[' + i + ']';
+            const referencepath_relationships_itemValidationError = validate$c(obj_relationships_item, path_relationships_item);
+            if (referencepath_relationships_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DmoRelationshipsOutputRepresentation (at "' + path_relationships_item + '")\n';
+                message += referencepath_relationships_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$2 = 600000;
+const VERSION$2 = "84ccc17f91013e292e7b01a291dd0322";
+function validate$a(obj, path = 'CdpMetadataOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_dmos = obj.dmos;
+        const path_dmos = path + '.dmos';
+        if (!ArrayIsArray(obj_dmos)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_dmos + '" (at "' + path_dmos + '")');
+        }
+        for (let i = 0; i < obj_dmos.length; i++) {
+            const obj_dmos_item = obj_dmos[i];
+            const path_dmos_item = path_dmos + '[' + i + ']';
+            const referencepath_dmos_itemValidationError = validate$b(obj_dmos_item, path_dmos_item);
+            if (referencepath_dmos_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DmoOutputRepresentation (at "' + path_dmos_item + '")\n';
+                message += referencepath_dmos_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'CdpMetadataOutputRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$5 = function CdpMetadataOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        opaque: true
+    };
+};
+function equals$2(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function CdpMetadataOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$a(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = TTL$2;
+    let incomingRecord = normalize$2(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$2(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "Timeline",
+            version: VERSION$2,
+            representationName: RepresentationType$2,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$2(luvio, input, fullPathFactory) {
+    const rootKeySet = new StoreKeyMap();
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    return rootKeySet;
+}
+
+function select$4(luvio, params) {
+    return select$5();
+}
+function keyBuilder$5(luvio, params) {
+    return keyPrefix + '::CdpMetadataOutputRepresentation:(' + 'objectCategory:' + params.queryParams.objectCategory + ')';
+}
+function getResponseCacheKeys$2(luvio, resourceParams, response) {
+    return getTypeCacheKeys$2(luvio, response, () => keyBuilder$5(luvio, resourceParams));
+}
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$5(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$5(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$2,
+        namespace: keyPrefix,
+        version: VERSION$2,
+        representationName: RepresentationType$2
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/connect/timeline/cust-data-pfrm/data-model-objects',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getDataModelObjects_ConfigPropertyNames = {
+    displayName: 'getDataModelObjects',
+    parameters: {
+        required: [],
+        optional: ['objectCategory']
+    }
+};
+function createResourceParams$2(config) {
+    const resourceParams = {
+        queryParams: {
+            objectCategory: config.objectCategory
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$4(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$5(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_objectCategory = untrustedConfig.objectCategory;
+    if (typeof untrustedConfig_objectCategory === 'string') {
+        config.objectCategory = untrustedConfig_objectCategory;
+    }
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$2(luvio, config) {
+    createResourceParams$2(config);
+    return select$4();
+}
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => getResponseCacheKeys$2(luvio, resourceParams, response.body));
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$2(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$4(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDataModelObjectsAdapterFactory = (luvio) => function Timeline__getDataModelObjects(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getDataModelObjects_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
 function validate$9(obj, path = 'TimelineErrorRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1515,34 +1882,42 @@ const getTimelineMetadataAdapterFactory = (luvio) => function Timeline__getTimel
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
+let getDataModelObjects;
 let getTimelineData;
 let getTimelineMetadata;
 // Imperative GET Adapters
+let getDataModelObjects_imperative;
 let getTimelineData_imperative;
 let getTimelineMetadata_imperative;
 // Adapter Metadata
+const getDataModelObjectsMetadata = { apiFamily: 'Timeline', name: 'getDataModelObjects', ttl: 600000 };
 const getTimelineDataMetadata = { apiFamily: 'Timeline', name: 'getTimelineData', ttl: 500 };
 const getTimelineMetadataMetadata = { apiFamily: 'Timeline', name: 'getTimelineMetadata', ttl: 500 };
 function bindExportsTo(luvio) {
     // LDS Adapters
+    const getDataModelObjects_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getDataModelObjects', getDataModelObjectsAdapterFactory), getDataModelObjectsMetadata);
     const getTimelineData_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getTimelineData', getTimelineDataAdapterFactory), getTimelineDataMetadata);
     const getTimelineMetadata_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getTimelineMetadata', getTimelineMetadataAdapterFactory), getTimelineMetadataMetadata);
     return {
+        getDataModelObjects: createWireAdapterConstructor(luvio, getDataModelObjects_ldsAdapter, getDataModelObjectsMetadata),
         getTimelineData: createWireAdapterConstructor(luvio, getTimelineData_ldsAdapter, getTimelineDataMetadata),
         getTimelineMetadata: createWireAdapterConstructor(luvio, getTimelineMetadata_ldsAdapter, getTimelineMetadataMetadata),
         // Imperative GET Adapters
+        getDataModelObjects_imperative: createImperativeAdapter(luvio, getDataModelObjects_ldsAdapter, getDataModelObjectsMetadata),
         getTimelineData_imperative: createImperativeAdapter(luvio, getTimelineData_ldsAdapter, getTimelineDataMetadata),
         getTimelineMetadata_imperative: createImperativeAdapter(luvio, getTimelineMetadata_ldsAdapter, getTimelineMetadataMetadata)
     };
 }
 withDefaultLuvio((luvio) => {
     ({
+        getDataModelObjects,
         getTimelineData,
         getTimelineMetadata,
+        getDataModelObjects_imperative,
         getTimelineData_imperative,
         getTimelineMetadata_imperative
     } = bindExportsTo(luvio));
 });
 
-export { getTimelineData, getTimelineData_imperative, getTimelineMetadata, getTimelineMetadata_imperative };
-// version: 1.168.0-c58504c20
+export { getDataModelObjects, getDataModelObjects_imperative, getTimelineData, getTimelineData_imperative, getTimelineMetadata, getTimelineMetadata_imperative };
+// version: 1.169.0-0c8c3dc31

package/src/raml/api.raml

@@ -25,6 +25,71 @@ annotationTypes:
     type: string
     allowedTargets: TypeDeclaration
 types:
+  CdpMetadataOutputRepresentation:
+    description: Output representation to fetch all engagement dmos
+    type: object
+    properties:
+      dmos:
+        description: get all dmos
+        type: array
+        items:
+          type: DmoOutputRepresentation
+  DmoFieldsOutputRepresentation:
+    description: Output representation of each field of DMO
+    type: object
+    properties:
+      displayName:
+        description: get display name of a dmo
+        type: string
+      name:
+        description: get name of a dmo
+        type: string
+      type:
+        description: get type of fields
+        type: string
+  DmoOutputRepresentation:
+    description: Output representation of each dmo
+    type: object
+    properties:
+      category:
+        description: get category of a dmo
+        type: string
+      displayName:
+        description: get display name of a dmo
+        type: string
+      fields:
+        description: get all fields of a dmo
+        type: array
+        items:
+          type: DmoFieldsOutputRepresentation
+      name:
+        description: get name of a dmo
+        type: string
+      relationships:
+        description: get all relationships of a dmo
+        type: array
+        items:
+          type: DmoRelationshipsOutputRepresentation
+  DmoRelationshipsOutputRepresentation:
+    description: Output representation of relationships for a DMO
+    type: object
+    properties:
+      fromEntity:
+        description: 'get fromEntity in relationship '
+        type: RelationshipTypeOutputRepresentation
+      toEntity:
+        description: 'get toEntity in relationship '
+        type: RelationshipTypeOutputRepresentation
+  RelationshipTypeOutputRepresentation:
+    description: Output representation of relationship type
+    type: object
+    properties:
+      attribute:
+        description: 'get attribute of the entity in Relationship '
+        type: string
+      name:
+        description: 'get name of the entity in Relationship '
+        type: string
   TimelineDataGetResultRepresentation:
     description: Output representation of Timeline Data from the GET Resource
     type: object
@@ -237,6 +302,20 @@ types:
         description: Element label Name
         type: string | nil
 /connect/timeline:
+  /cust-data-pfrm/data-model-objects:
+    get:
+      displayName: getTimelineGetCDPMetadata
+      description: Method to fetch TimelineMetadata
+      responses:
+        '200':
+          description: Success
+          body:
+            application/json:
+              type: CdpMetadataOutputRepresentation
+      queryParameters:
+        objectCategory:
+          type: string
+          required: false
   /{timelineObjRecordId}/timeline-definitions/{timelineConfigFullName}/events:
     get:
       description: API to get Timeline data

package/src/raml/luvio.raml

@@ -8,6 +8,9 @@ uses:
 (luvio.ttl): 360000
 
 types:
+  CdpMetadataOutputRepresentation:
+    (luvio.opaque): true
+    (luvio.ttl): 600000
   TimelineDataGetResultRepresentation:
     (luvio.opaque): true
     (luvio.ttl): 500
@@ -21,6 +24,22 @@ types:
       validMetadataResponse: !include ../wire/getTimelineMetadata/__karma__/data/TimelineMetadataResponse.json
 
 /connect/timeline:
+  /cust-data-pfrm/data-model-objects:
+    get:
+      (luvio.adapter):
+        name: getDataModelObjects
+        tests:
+          validConfigs:
+            - |
+              {}
+            - |
+              {
+                "objectCategory": "Engagement"
+              }
+      queryParameters:
+        objectCategory:
+          examples:
+            validResponse: 'Engagement'
   /{timelineObjRecordId}/timeline-definitions/{timelineConfigFullName}/events:
     get:
       (luvio.adapter):