@salesforce/lds-adapters-marketing-cdp 0.1.0-dev1

package/dist/es/es2018/marketing-cdp.js

@@ -0,0 +1,2423 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$8, typeCheckConfig as typeCheckConfig$8, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$3 } from '@luvio/engine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = 'CDP';
+
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function equalsArray(a, b, equalsItem) {
+    const aLength = a.length;
+    const bLength = b.length;
+    if (aLength !== bLength) {
+        return false;
+    }
+    for (let i = 0; i < aLength; i++) {
+        if (equalsItem(a[i], b[i]) === false) {
+            return false;
+        }
+    }
+    return true;
+}
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+function validate$h(obj, path = 'DataGraphFullRefreshConfigInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.schedule !== undefined) {
+            const obj_schedule = obj.schedule;
+            const path_schedule = path + '.schedule';
+            if (typeof obj_schedule !== 'object' || ArrayIsArray(obj_schedule) || obj_schedule === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_schedule + '" (at "' + path_schedule + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$g(obj, path = 'DataGraphIncrementalRefreshConfigInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.enabled !== undefined) {
+            const obj_enabled = obj.enabled;
+            const path_enabled = path + '.enabled';
+            if (typeof obj_enabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_enabled + '" (at "' + path_enabled + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$f(obj, path = 'CdpObjectBaseOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.createdBy !== undefined) {
+            const obj_createdBy = obj.createdBy;
+            const path_createdBy = path + '.createdBy';
+            if (typeof obj_createdBy !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_createdBy + '" (at "' + path_createdBy + '")');
+            }
+        }
+        if (obj.createdDate !== undefined) {
+            const obj_createdDate = obj.createdDate;
+            const path_createdDate = path + '.createdDate';
+            if (typeof obj_createdDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+            }
+        }
+        if (obj.dataspaceName !== undefined) {
+            const obj_dataspaceName = obj.dataspaceName;
+            const path_dataspaceName = path + '.dataspaceName';
+            if (typeof obj_dataspaceName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dataspaceName + '" (at "' + path_dataspaceName + '")');
+            }
+        }
+        if (obj.description !== undefined) {
+            const obj_description = obj.description;
+            const path_description = path + '.description';
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        }
+        if (obj.id !== undefined) {
+            const obj_id = obj.id;
+            const path_id = path + '.id';
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        }
+        const obj_kind = obj.kind;
+        const path_kind = path + '.kind';
+        if (typeof obj_kind !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_kind + '" (at "' + path_kind + '")');
+        }
+        if (obj.label !== undefined) {
+            const obj_label = obj.label;
+            const path_label = path + '.label';
+            if (typeof obj_label !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+            }
+        }
+        if (obj.modifiedBy !== undefined) {
+            const obj_modifiedBy = obj.modifiedBy;
+            const path_modifiedBy = path + '.modifiedBy';
+            if (typeof obj_modifiedBy !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_modifiedBy + '" (at "' + path_modifiedBy + '")');
+            }
+        }
+        if (obj.modifiedDate !== undefined) {
+            const obj_modifiedDate = obj.modifiedDate;
+            const path_modifiedDate = path + '.modifiedDate';
+            if (typeof obj_modifiedDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_modifiedDate + '" (at "' + path_modifiedDate + '")');
+            }
+        }
+        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;
+}
+const RepresentationType$4 = 'CdpObjectBaseOutputRepresentation';
+function keyBuilder$b(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$4 + ':' + config.name;
+}
+function keyBuilderFromType$4(luvio, object) {
+    const keyParams = {
+        name: object.name
+    };
+    return keyBuilder$b(luvio, keyParams);
+}
+function equals$9(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+
+function validate$e(obj, path = 'DataGraphScheduleOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.frequency !== undefined) {
+            const obj_frequency = obj.frequency;
+            const path_frequency = path + '.frequency';
+            if (typeof obj_frequency !== 'number' || (typeof obj_frequency === 'number' && Math.floor(obj_frequency) !== obj_frequency)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_frequency + '" (at "' + path_frequency + '")');
+            }
+        }
+        if (obj.timeGranularity !== undefined) {
+            const obj_timeGranularity = obj.timeGranularity;
+            const path_timeGranularity = path + '.timeGranularity';
+            if (typeof obj_timeGranularity !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_timeGranularity + '" (at "' + path_timeGranularity + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function equals$8(existing, incoming) {
+    const existing_frequency = existing.frequency;
+    const incoming_frequency = incoming.frequency;
+    // if at least one of these optionals is defined
+    if (existing_frequency !== undefined || incoming_frequency !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_frequency === undefined || incoming_frequency === undefined) {
+            return false;
+        }
+        if (!(existing_frequency === incoming_frequency)) {
+            return false;
+        }
+    }
+    const existing_timeGranularity = existing.timeGranularity;
+    const incoming_timeGranularity = incoming.timeGranularity;
+    // if at least one of these optionals is defined
+    if (existing_timeGranularity !== undefined || incoming_timeGranularity !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_timeGranularity === undefined || incoming_timeGranularity === undefined) {
+            return false;
+        }
+        if (!(existing_timeGranularity === incoming_timeGranularity)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function validate$d(obj, path = 'DataGraphFullRefreshConfigOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.schedule !== undefined) {
+            const obj_schedule = obj.schedule;
+            const path_schedule = path + '.schedule';
+            const referencepath_scheduleValidationError = validate$e(obj_schedule, path_schedule);
+            if (referencepath_scheduleValidationError !== null) {
+                let message = 'Object doesn\'t match DataGraphScheduleOutputRepresentation (at "' + path_schedule + '")\n';
+                message += referencepath_scheduleValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function equals$7(existing, incoming) {
+    const existing_schedule = existing.schedule;
+    const incoming_schedule = incoming.schedule;
+    // if at least one of these optionals is defined
+    if (existing_schedule !== undefined || incoming_schedule !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_schedule === undefined || incoming_schedule === undefined) {
+            return false;
+        }
+        if (!(equals$8(existing_schedule, incoming_schedule))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function validate$c(obj, path = 'DataGraphIncrementalRefreshConfigOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.enabled !== undefined) {
+            const obj_enabled = obj.enabled;
+            const path_enabled = path + '.enabled';
+            if (typeof obj_enabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_enabled + '" (at "' + path_enabled + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function equals$6(existing, incoming) {
+    const existing_enabled = existing.enabled;
+    const incoming_enabled = incoming.enabled;
+    // if at least one of these optionals is defined
+    if (existing_enabled !== undefined || incoming_enabled !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_enabled === undefined || incoming_enabled === undefined) {
+            return false;
+        }
+        if (!(existing_enabled === incoming_enabled)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function validate$b(obj, path = 'DependencyOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_developerName = obj.developerName;
+        const path_developerName = path + '.developerName';
+        if (typeof obj_developerName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_developerName + '" (at "' + path_developerName + '")');
+        }
+        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_entityType = obj.entityType;
+        const path_entityType = path + '.entityType';
+        if (typeof obj_entityType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_entityType + '" (at "' + path_entityType + '")');
+        }
+        const obj_entityTypePluralLabel = obj.entityTypePluralLabel;
+        const path_entityTypePluralLabel = path + '.entityTypePluralLabel';
+        if (typeof obj_entityTypePluralLabel !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_entityTypePluralLabel + '" (at "' + path_entityTypePluralLabel + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+        const obj_linkable = obj.linkable;
+        const path_linkable = path + '.linkable';
+        if (typeof obj_linkable !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_linkable + '" (at "' + path_linkable + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+function equals$5(existing, incoming) {
+    const existing_linkable = existing.linkable;
+    const incoming_linkable = incoming.linkable;
+    if (!(existing_linkable === incoming_linkable)) {
+        return false;
+    }
+    const existing_developerName = existing.developerName;
+    const incoming_developerName = incoming.developerName;
+    if (!(existing_developerName === incoming_developerName)) {
+        return false;
+    }
+    const existing_displayName = existing.displayName;
+    const incoming_displayName = incoming.displayName;
+    if (!(existing_displayName === incoming_displayName)) {
+        return false;
+    }
+    const existing_entityType = existing.entityType;
+    const incoming_entityType = incoming.entityType;
+    if (!(existing_entityType === incoming_entityType)) {
+        return false;
+    }
+    const existing_entityTypePluralLabel = existing.entityTypePluralLabel;
+    const incoming_entityTypePluralLabel = incoming.entityTypePluralLabel;
+    if (!(existing_entityTypePluralLabel === incoming_entityTypePluralLabel)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    return true;
+}
+
+function validate$a(obj, path = 'CdpDataGraphFieldOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.ciFieldType !== undefined) {
+            const obj_ciFieldType = obj.ciFieldType;
+            const path_ciFieldType = path + '.ciFieldType';
+            if (typeof obj_ciFieldType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_ciFieldType + '" (at "' + path_ciFieldType + '")');
+            }
+        }
+        if (obj.ciFormula !== undefined) {
+            const obj_ciFormula = obj.ciFormula;
+            const path_ciFormula = path + '.ciFormula';
+            if (typeof obj_ciFormula !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_ciFormula + '" (at "' + path_ciFormula + '")');
+            }
+        }
+        if (obj.dataType !== undefined) {
+            const obj_dataType = obj.dataType;
+            const path_dataType = path + '.dataType';
+            if (typeof obj_dataType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dataType + '" (at "' + path_dataType + '")');
+            }
+        }
+        if (obj.dependency !== undefined) {
+            const obj_dependency = obj.dependency;
+            const path_dependency = path + '.dependency';
+            if (!ArrayIsArray(obj_dependency)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_dependency + '" (at "' + path_dependency + '")');
+            }
+            for (let i = 0; i < obj_dependency.length; i++) {
+                const obj_dependency_item = obj_dependency[i];
+                const path_dependency_item = path_dependency + '[' + i + ']';
+                const referencepath_dependency_itemValidationError = validate$b(obj_dependency_item, path_dependency_item);
+                if (referencepath_dependency_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match DependencyOutputRepresentation (at "' + path_dependency_item + '")\n';
+                    message += referencepath_dependency_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.devName !== undefined) {
+            const obj_devName = obj.devName;
+            const path_devName = path + '.devName';
+            if (typeof obj_devName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_devName + '" (at "' + path_devName + '")');
+            }
+        }
+        if (obj.isDGRootKeyField !== undefined) {
+            const obj_isDGRootKeyField = obj.isDGRootKeyField;
+            const path_isDGRootKeyField = path + '.isDGRootKeyField';
+            if (typeof obj_isDGRootKeyField !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isDGRootKeyField + '" (at "' + path_isDGRootKeyField + '")');
+            }
+        }
+        const obj_isKeyColumn = obj.isKeyColumn;
+        const path_isKeyColumn = path + '.isKeyColumn';
+        if (typeof obj_isKeyColumn !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isKeyColumn + '" (at "' + path_isKeyColumn + '")');
+        }
+        if (obj.isProjected !== undefined) {
+            const obj_isProjected = obj.isProjected;
+            const path_isProjected = path + '.isProjected';
+            if (typeof obj_isProjected !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isProjected + '" (at "' + path_isProjected + '")');
+            }
+        }
+        if (obj.keyQualifierName !== undefined) {
+            const obj_keyQualifierName = obj.keyQualifierName;
+            const path_keyQualifierName = path + '.keyQualifierName';
+            if (typeof obj_keyQualifierName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_keyQualifierName + '" (at "' + path_keyQualifierName + '")');
+            }
+        }
+        if (obj.sourceFieldLabel !== undefined) {
+            const obj_sourceFieldLabel = obj.sourceFieldLabel;
+            const path_sourceFieldLabel = path + '.sourceFieldLabel';
+            if (typeof obj_sourceFieldLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sourceFieldLabel + '" (at "' + path_sourceFieldLabel + '")');
+            }
+        }
+        const obj_sourceFieldName = obj.sourceFieldName;
+        const path_sourceFieldName = path + '.sourceFieldName';
+        if (typeof obj_sourceFieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_sourceFieldName + '" (at "' + path_sourceFieldName + '")');
+        }
+        if (obj.usageTag !== undefined) {
+            const obj_usageTag = obj.usageTag;
+            const path_usageTag = path + '.usageTag';
+            if (typeof obj_usageTag !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_usageTag + '" (at "' + path_usageTag + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$9(obj, path = 'CdpDataGraphFilterConditionOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldName = obj.fieldName;
+        const path_fieldName = path + '.fieldName';
+        if (typeof obj_fieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+        }
+        const obj_operator = obj.operator;
+        const path_operator = path + '.operator';
+        if (typeof obj_operator !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+        }
+        if (obj.values !== undefined) {
+            const obj_values = obj.values;
+            const path_values = path + '.values';
+            if (!ArrayIsArray(obj_values)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_values + '" (at "' + path_values + '")');
+            }
+            for (let i = 0; i < obj_values.length; i++) {
+                const obj_values_item = obj_values[i];
+                const path_values_item = path_values + '[' + i + ']';
+                if (typeof obj_values_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$8(obj, path = 'CdpDataGraphFilterCriteriaOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_conditions = obj.conditions;
+        const path_conditions = path + '.conditions';
+        if (!ArrayIsArray(obj_conditions)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_conditions + '" (at "' + path_conditions + '")');
+        }
+        for (let i = 0; i < obj_conditions.length; i++) {
+            const obj_conditions_item = obj_conditions[i];
+            const path_conditions_item = path_conditions + '[' + i + ']';
+            const referencepath_conditions_itemValidationError = validate$9(obj_conditions_item, path_conditions_item);
+            if (referencepath_conditions_itemValidationError !== null) {
+                let message = 'Object doesn\'t match CdpDataGraphFilterConditionOutputRepresentation (at "' + path_conditions_item + '")\n';
+                message += referencepath_conditions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_operator = obj.operator;
+        const path_operator = path + '.operator';
+        if (typeof obj_operator !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_operator + '" (at "' + path_operator + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$7(obj, path = 'CdpDataGraphPathToParentOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldName = obj.fieldName;
+        const path_fieldName = path + '.fieldName';
+        if (typeof obj_fieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+        }
+        const obj_parentFieldName = obj.parentFieldName;
+        const path_parentFieldName = path + '.parentFieldName';
+        if (typeof obj_parentFieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_parentFieldName + '" (at "' + path_parentFieldName + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$6(obj, path = 'CdpDataGraphRecencyCriteriaOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fieldName = obj.fieldName;
+        const path_fieldName = path + '.fieldName';
+        if (typeof obj_fieldName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fieldName + '" (at "' + path_fieldName + '")');
+        }
+        const obj_value = obj.value;
+        const path_value = path + '.value';
+        if (typeof obj_value !== 'number' || (typeof obj_value === 'number' && Math.floor(obj_value) !== obj_value)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_value + '" (at "' + path_value + '")');
+        }
+        const obj_valueType = obj.valueType;
+        const path_valueType = path + '.valueType';
+        if (typeof obj_valueType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_valueType + '" (at "' + path_valueType + '")');
+        }
+        const obj_valueUnit = obj.valueUnit;
+        const path_valueUnit = path + '.valueUnit';
+        if (typeof obj_valueUnit !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_valueUnit + '" (at "' + path_valueUnit + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$5(obj, path = 'CdpDataGraphRelatedSegmentOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.id !== undefined) {
+            const obj_id = obj.id;
+            const path_id = path + '.id';
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        }
+        const obj_label = obj.label;
+        const path_label = path + '.label';
+        if (typeof obj_label !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
+        }
+        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$4(obj, path = 'CdpDataGraphSourceObjectOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.dependency !== undefined) {
+            const obj_dependency = obj.dependency;
+            const path_dependency = path + '.dependency';
+            if (!ArrayIsArray(obj_dependency)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_dependency + '" (at "' + path_dependency + '")');
+            }
+            for (let i = 0; i < obj_dependency.length; i++) {
+                const obj_dependency_item = obj_dependency[i];
+                const path_dependency_item = path_dependency + '[' + i + ']';
+                const referencepath_dependency_itemValidationError = validate$b(obj_dependency_item, path_dependency_item);
+                if (referencepath_dependency_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match DependencyOutputRepresentation (at "' + path_dependency_item + '")\n';
+                    message += referencepath_dependency_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.devName !== undefined) {
+            const obj_devName = obj.devName;
+            const path_devName = path + '.devName';
+            if (typeof obj_devName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_devName + '" (at "' + path_devName + '")');
+            }
+        }
+        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$a(obj_fields_item, path_fields_item);
+            if (referencepath_fields_itemValidationError !== null) {
+                let message = 'Object doesn\'t match CdpDataGraphFieldOutputRepresentation (at "' + path_fields_item + '")\n';
+                message += referencepath_fields_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.filterCriteria !== undefined) {
+            const obj_filterCriteria = obj.filterCriteria;
+            const path_filterCriteria = path + '.filterCriteria';
+            const referencepath_filterCriteriaValidationError = validate$8(obj_filterCriteria, path_filterCriteria);
+            if (referencepath_filterCriteriaValidationError !== null) {
+                let message = 'Object doesn\'t match CdpDataGraphFilterCriteriaOutputRepresentation (at "' + path_filterCriteria + '")\n';
+                message += referencepath_filterCriteriaValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.fragmentDMOLabel !== undefined) {
+            const obj_fragmentDMOLabel = obj.fragmentDMOLabel;
+            const path_fragmentDMOLabel = path + '.fragmentDMOLabel';
+            if (typeof obj_fragmentDMOLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fragmentDMOLabel + '" (at "' + path_fragmentDMOLabel + '")');
+            }
+        }
+        if (obj.fragmentDMOName !== undefined) {
+            const obj_fragmentDMOName = obj.fragmentDMOName;
+            const path_fragmentDMOName = path + '.fragmentDMOName';
+            if (typeof obj_fragmentDMOName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fragmentDMOName + '" (at "' + path_fragmentDMOName + '")');
+            }
+        }
+        if (obj.jsonPath !== undefined) {
+            const obj_jsonPath = obj.jsonPath;
+            const path_jsonPath = path + '.jsonPath';
+            if (typeof obj_jsonPath !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_jsonPath + '" (at "' + path_jsonPath + '")');
+            }
+        }
+        if (obj.path !== undefined) {
+            const obj_path = obj.path;
+            const path_path = path + '.path';
+            if (!ArrayIsArray(obj_path)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_path + '" (at "' + path_path + '")');
+            }
+            for (let i = 0; i < obj_path.length; i++) {
+                const obj_path_item = obj_path[i];
+                const path_path_item = path_path + '[' + i + ']';
+                const referencepath_path_itemValidationError = validate$7(obj_path_item, path_path_item);
+                if (referencepath_path_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match CdpDataGraphPathToParentOutputRepresentation (at "' + path_path_item + '")\n';
+                    message += referencepath_path_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.recencyCriteria !== undefined) {
+            const obj_recencyCriteria = obj.recencyCriteria;
+            const path_recencyCriteria = path + '.recencyCriteria';
+            if (!ArrayIsArray(obj_recencyCriteria)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_recencyCriteria + '" (at "' + path_recencyCriteria + '")');
+            }
+            for (let i = 0; i < obj_recencyCriteria.length; i++) {
+                const obj_recencyCriteria_item = obj_recencyCriteria[i];
+                const path_recencyCriteria_item = path_recencyCriteria + '[' + i + ']';
+                const referencepath_recencyCriteria_itemValidationError = validate$6(obj_recencyCriteria_item, path_recencyCriteria_item);
+                if (referencepath_recencyCriteria_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match CdpDataGraphRecencyCriteriaOutputRepresentation (at "' + path_recencyCriteria_item + '")\n';
+                    message += referencepath_recencyCriteria_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.referenceDeveloperName !== undefined) {
+            const obj_referenceDeveloperName = obj.referenceDeveloperName;
+            const path_referenceDeveloperName = path + '.referenceDeveloperName';
+            if (typeof obj_referenceDeveloperName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_referenceDeveloperName + '" (at "' + path_referenceDeveloperName + '")');
+            }
+        }
+        const obj_relatedObjects = obj.relatedObjects;
+        const path_relatedObjects = path + '.relatedObjects';
+        if (!ArrayIsArray(obj_relatedObjects)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_relatedObjects + '" (at "' + path_relatedObjects + '")');
+        }
+        for (let i = 0; i < obj_relatedObjects.length; i++) {
+            const obj_relatedObjects_item = obj_relatedObjects[i];
+            const path_relatedObjects_item = path_relatedObjects + '[' + i + ']';
+            if (obj_relatedObjects_item === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_relatedObjects_item + '" (at "' + path_relatedObjects_item + '")');
+            }
+        }
+        if (obj.relatedSegments !== undefined) {
+            const obj_relatedSegments = obj.relatedSegments;
+            const path_relatedSegments = path + '.relatedSegments';
+            if (!ArrayIsArray(obj_relatedSegments)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_relatedSegments + '" (at "' + path_relatedSegments + '")');
+            }
+            for (let i = 0; i < obj_relatedSegments.length; i++) {
+                const obj_relatedSegments_item = obj_relatedSegments[i];
+                const path_relatedSegments_item = path_relatedSegments + '[' + i + ']';
+                const referencepath_relatedSegments_itemValidationError = validate$5(obj_relatedSegments_item, path_relatedSegments_item);
+                if (referencepath_relatedSegments_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match CdpDataGraphRelatedSegmentOutputRepresentation (at "' + path_relatedSegments_item + '")\n';
+                    message += referencepath_relatedSegments_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            }
+        }
+        if (obj.type !== undefined) {
+            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 equals$4(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$3 = "71e8434340c0370a30fb856ebad9a123";
+function validate$3(obj, path = 'CdpDataGraphOutputRepresentation') {
+    const validateCdpObjectBaseOutputRepresentation_validateError = validate$f(obj, path);
+    if (validateCdpObjectBaseOutputRepresentation_validateError !== null) {
+        return validateCdpObjectBaseOutputRepresentation_validateError;
+    }
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.cacheDurationInDays !== undefined) {
+            const obj_cacheDurationInDays = obj.cacheDurationInDays;
+            const path_cacheDurationInDays = path + '.cacheDurationInDays';
+            if (typeof obj_cacheDurationInDays !== 'number' || (typeof obj_cacheDurationInDays === 'number' && Math.floor(obj_cacheDurationInDays) !== obj_cacheDurationInDays)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_cacheDurationInDays + '" (at "' + path_cacheDurationInDays + '")');
+            }
+        }
+        if (obj.dayZeroMappingDevName !== undefined) {
+            const obj_dayZeroMappingDevName = obj.dayZeroMappingDevName;
+            const path_dayZeroMappingDevName = path + '.dayZeroMappingDevName';
+            if (typeof obj_dayZeroMappingDevName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dayZeroMappingDevName + '" (at "' + path_dayZeroMappingDevName + '")');
+            }
+        }
+        if (obj.dayZeroTransformDevName !== undefined) {
+            const obj_dayZeroTransformDevName = obj.dayZeroTransformDevName;
+            const path_dayZeroTransformDevName = path + '.dayZeroTransformDevName';
+            if (typeof obj_dayZeroTransformDevName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_dayZeroTransformDevName + '" (at "' + path_dayZeroTransformDevName + '")');
+            }
+        }
+        const obj_extendedProperties = obj.extendedProperties;
+        const path_extendedProperties = path + '.extendedProperties';
+        if (typeof obj_extendedProperties !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_extendedProperties + '" (at "' + path_extendedProperties + '")');
+        }
+        if (obj.fullRefreshConfig !== undefined) {
+            const obj_fullRefreshConfig = obj.fullRefreshConfig;
+            const path_fullRefreshConfig = path + '.fullRefreshConfig';
+            const referencepath_fullRefreshConfigValidationError = validate$d(obj_fullRefreshConfig, path_fullRefreshConfig);
+            if (referencepath_fullRefreshConfigValidationError !== null) {
+                let message = 'Object doesn\'t match DataGraphFullRefreshConfigOutputRepresentation (at "' + path_fullRefreshConfig + '")\n';
+                message += referencepath_fullRefreshConfigValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.idDmoLabel !== undefined) {
+            const obj_idDmoLabel = obj.idDmoLabel;
+            const path_idDmoLabel = path + '.idDmoLabel';
+            if (typeof obj_idDmoLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_idDmoLabel + '" (at "' + path_idDmoLabel + '")');
+            }
+        }
+        if (obj.idDmoName !== undefined) {
+            const obj_idDmoName = obj.idDmoName;
+            const path_idDmoName = path + '.idDmoName';
+            if (typeof obj_idDmoName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_idDmoName + '" (at "' + path_idDmoName + '")');
+            }
+        }
+        if (obj.incrementalMappingDevName !== undefined) {
+            const obj_incrementalMappingDevName = obj.incrementalMappingDevName;
+            const path_incrementalMappingDevName = path + '.incrementalMappingDevName';
+            if (typeof obj_incrementalMappingDevName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_incrementalMappingDevName + '" (at "' + path_incrementalMappingDevName + '")');
+            }
+        }
+        if (obj.incrementalRefreshConfig !== undefined) {
+            const obj_incrementalRefreshConfig = obj.incrementalRefreshConfig;
+            const path_incrementalRefreshConfig = path + '.incrementalRefreshConfig';
+            const referencepath_incrementalRefreshConfigValidationError = validate$c(obj_incrementalRefreshConfig, path_incrementalRefreshConfig);
+            if (referencepath_incrementalRefreshConfigValidationError !== null) {
+                let message = 'Object doesn\'t match DataGraphIncrementalRefreshConfigOutputRepresentation (at "' + path_incrementalRefreshConfig + '")\n';
+                message += referencepath_incrementalRefreshConfigValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.incrementalTransformDevName !== undefined) {
+            const obj_incrementalTransformDevName = obj.incrementalTransformDevName;
+            const path_incrementalTransformDevName = path + '.incrementalTransformDevName';
+            if (typeof obj_incrementalTransformDevName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_incrementalTransformDevName + '" (at "' + path_incrementalTransformDevName + '")');
+            }
+        }
+        if (obj.isRealTimeToggleEnabled !== undefined) {
+            const obj_isRealTimeToggleEnabled = obj.isRealTimeToggleEnabled;
+            const path_isRealTimeToggleEnabled = path + '.isRealTimeToggleEnabled';
+            if (typeof obj_isRealTimeToggleEnabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isRealTimeToggleEnabled + '" (at "' + path_isRealTimeToggleEnabled + '")');
+            }
+        }
+        if (obj.isRecordCachingDisabled !== undefined) {
+            const obj_isRecordCachingDisabled = obj.isRecordCachingDisabled;
+            const path_isRecordCachingDisabled = path + '.isRecordCachingDisabled';
+            if (typeof obj_isRecordCachingDisabled !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isRecordCachingDisabled + '" (at "' + path_isRecordCachingDisabled + '")');
+            }
+        }
+        if (obj.lastRunStatus !== undefined) {
+            const obj_lastRunStatus = obj.lastRunStatus;
+            const path_lastRunStatus = path + '.lastRunStatus';
+            if (typeof obj_lastRunStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lastRunStatus + '" (at "' + path_lastRunStatus + '")');
+            }
+        }
+        if (obj.maxRecordsCached !== undefined) {
+            const obj_maxRecordsCached = obj.maxRecordsCached;
+            const path_maxRecordsCached = path + '.maxRecordsCached';
+            if (typeof obj_maxRecordsCached !== 'number' || (typeof obj_maxRecordsCached === 'number' && Math.floor(obj_maxRecordsCached) !== obj_maxRecordsCached)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_maxRecordsCached + '" (at "' + path_maxRecordsCached + '")');
+            }
+        }
+        if (obj.primaryObjectLabel !== undefined) {
+            const obj_primaryObjectLabel = obj.primaryObjectLabel;
+            const path_primaryObjectLabel = path + '.primaryObjectLabel';
+            if (typeof obj_primaryObjectLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_primaryObjectLabel + '" (at "' + path_primaryObjectLabel + '")');
+            }
+        }
+        const obj_primaryObjectName = obj.primaryObjectName;
+        const path_primaryObjectName = path + '.primaryObjectName';
+        if (typeof obj_primaryObjectName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_primaryObjectName + '" (at "' + path_primaryObjectName + '")');
+        }
+        if (obj.sessionEnd !== undefined) {
+            const obj_sessionEnd = obj.sessionEnd;
+            const path_sessionEnd = path + '.sessionEnd';
+            if (typeof obj_sessionEnd !== 'number' || (typeof obj_sessionEnd === 'number' && Math.floor(obj_sessionEnd) !== obj_sessionEnd)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_sessionEnd + '" (at "' + path_sessionEnd + '")');
+            }
+        }
+        if (obj.sessionEndTimeUnit !== undefined) {
+            const obj_sessionEndTimeUnit = obj.sessionEndTimeUnit;
+            const path_sessionEndTimeUnit = path + '.sessionEndTimeUnit';
+            if (typeof obj_sessionEndTimeUnit !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sessionEndTimeUnit + '" (at "' + path_sessionEndTimeUnit + '")');
+            }
+        }
+        const obj_sourceObject = obj.sourceObject;
+        const path_sourceObject = path + '.sourceObject';
+        const referencepath_sourceObjectValidationError = validate$4(obj_sourceObject, path_sourceObject);
+        if (referencepath_sourceObjectValidationError !== null) {
+            let message = 'Object doesn\'t match CdpDataGraphSourceObjectOutputRepresentation (at "' + path_sourceObject + '")\n';
+            message += referencepath_sourceObjectValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+        if (obj.type !== undefined) {
+            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 + '")');
+            }
+        }
+        if (obj.valuesDmoLabel !== undefined) {
+            const obj_valuesDmoLabel = obj.valuesDmoLabel;
+            const path_valuesDmoLabel = path + '.valuesDmoLabel';
+            if (typeof obj_valuesDmoLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_valuesDmoLabel + '" (at "' + path_valuesDmoLabel + '")');
+            }
+        }
+        const obj_valuesDmoName = obj.valuesDmoName;
+        const path_valuesDmoName = path + '.valuesDmoName';
+        if (typeof obj_valuesDmoName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_valuesDmoName + '" (at "' + path_valuesDmoName + '")');
+        }
+        const obj_version = obj.version;
+        const path_version = path + '.version';
+        if (typeof obj_version !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_version + '" (at "' + path_version + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$3 = 'CdpDataGraphOutputRepresentation';
+function keyBuilder$a(luvio, config) {
+    return keyBuilder$b(luvio, config);
+}
+function keyBuilderFromType$3(luvio, object) {
+    return keyBuilderFromType$4(luvio, object);
+}
+function normalize$3(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$a = function CdpDataGraphOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        opaque: true
+    };
+};
+function equals$3(existing, incoming) {
+    if (equals$9(existing, incoming) === false) {
+        return false;
+    }
+    const existing_isRealTimeToggleEnabled = existing.isRealTimeToggleEnabled;
+    const incoming_isRealTimeToggleEnabled = incoming.isRealTimeToggleEnabled;
+    // if at least one of these optionals is defined
+    if (existing_isRealTimeToggleEnabled !== undefined || incoming_isRealTimeToggleEnabled !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isRealTimeToggleEnabled === undefined || incoming_isRealTimeToggleEnabled === undefined) {
+            return false;
+        }
+        if (!(existing_isRealTimeToggleEnabled === incoming_isRealTimeToggleEnabled)) {
+            return false;
+        }
+    }
+    const existing_isRecordCachingDisabled = existing.isRecordCachingDisabled;
+    const incoming_isRecordCachingDisabled = incoming.isRecordCachingDisabled;
+    // if at least one of these optionals is defined
+    if (existing_isRecordCachingDisabled !== undefined || incoming_isRecordCachingDisabled !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isRecordCachingDisabled === undefined || incoming_isRecordCachingDisabled === undefined) {
+            return false;
+        }
+        if (!(existing_isRecordCachingDisabled === incoming_isRecordCachingDisabled)) {
+            return false;
+        }
+    }
+    const existing_cacheDurationInDays = existing.cacheDurationInDays;
+    const incoming_cacheDurationInDays = incoming.cacheDurationInDays;
+    // if at least one of these optionals is defined
+    if (existing_cacheDurationInDays !== undefined || incoming_cacheDurationInDays !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_cacheDurationInDays === undefined || incoming_cacheDurationInDays === undefined) {
+            return false;
+        }
+        if (!(existing_cacheDurationInDays === incoming_cacheDurationInDays)) {
+            return false;
+        }
+    }
+    const existing_maxRecordsCached = existing.maxRecordsCached;
+    const incoming_maxRecordsCached = incoming.maxRecordsCached;
+    // if at least one of these optionals is defined
+    if (existing_maxRecordsCached !== undefined || incoming_maxRecordsCached !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_maxRecordsCached === undefined || incoming_maxRecordsCached === undefined) {
+            return false;
+        }
+        if (!(existing_maxRecordsCached === incoming_maxRecordsCached)) {
+            return false;
+        }
+    }
+    const existing_sessionEnd = existing.sessionEnd;
+    const incoming_sessionEnd = incoming.sessionEnd;
+    // if at least one of these optionals is defined
+    if (existing_sessionEnd !== undefined || incoming_sessionEnd !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_sessionEnd === undefined || incoming_sessionEnd === undefined) {
+            return false;
+        }
+        if (!(existing_sessionEnd === incoming_sessionEnd)) {
+            return false;
+        }
+    }
+    const existing_dayZeroMappingDevName = existing.dayZeroMappingDevName;
+    const incoming_dayZeroMappingDevName = incoming.dayZeroMappingDevName;
+    // if at least one of these optionals is defined
+    if (existing_dayZeroMappingDevName !== undefined || incoming_dayZeroMappingDevName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_dayZeroMappingDevName === undefined || incoming_dayZeroMappingDevName === undefined) {
+            return false;
+        }
+        if (!(existing_dayZeroMappingDevName === incoming_dayZeroMappingDevName)) {
+            return false;
+        }
+    }
+    const existing_dayZeroTransformDevName = existing.dayZeroTransformDevName;
+    const incoming_dayZeroTransformDevName = incoming.dayZeroTransformDevName;
+    // if at least one of these optionals is defined
+    if (existing_dayZeroTransformDevName !== undefined || incoming_dayZeroTransformDevName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_dayZeroTransformDevName === undefined || incoming_dayZeroTransformDevName === undefined) {
+            return false;
+        }
+        if (!(existing_dayZeroTransformDevName === incoming_dayZeroTransformDevName)) {
+            return false;
+        }
+    }
+    const existing_extendedProperties = existing.extendedProperties;
+    const incoming_extendedProperties = incoming.extendedProperties;
+    if (!(existing_extendedProperties === incoming_extendedProperties)) {
+        return false;
+    }
+    const existing_idDmoLabel = existing.idDmoLabel;
+    const incoming_idDmoLabel = incoming.idDmoLabel;
+    // if at least one of these optionals is defined
+    if (existing_idDmoLabel !== undefined || incoming_idDmoLabel !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_idDmoLabel === undefined || incoming_idDmoLabel === undefined) {
+            return false;
+        }
+        if (!(existing_idDmoLabel === incoming_idDmoLabel)) {
+            return false;
+        }
+    }
+    const existing_idDmoName = existing.idDmoName;
+    const incoming_idDmoName = incoming.idDmoName;
+    // if at least one of these optionals is defined
+    if (existing_idDmoName !== undefined || incoming_idDmoName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_idDmoName === undefined || incoming_idDmoName === undefined) {
+            return false;
+        }
+        if (!(existing_idDmoName === incoming_idDmoName)) {
+            return false;
+        }
+    }
+    const existing_incrementalMappingDevName = existing.incrementalMappingDevName;
+    const incoming_incrementalMappingDevName = incoming.incrementalMappingDevName;
+    // if at least one of these optionals is defined
+    if (existing_incrementalMappingDevName !== undefined || incoming_incrementalMappingDevName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_incrementalMappingDevName === undefined || incoming_incrementalMappingDevName === undefined) {
+            return false;
+        }
+        if (!(existing_incrementalMappingDevName === incoming_incrementalMappingDevName)) {
+            return false;
+        }
+    }
+    const existing_incrementalTransformDevName = existing.incrementalTransformDevName;
+    const incoming_incrementalTransformDevName = incoming.incrementalTransformDevName;
+    // if at least one of these optionals is defined
+    if (existing_incrementalTransformDevName !== undefined || incoming_incrementalTransformDevName !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_incrementalTransformDevName === undefined || incoming_incrementalTransformDevName === undefined) {
+            return false;
+        }
+        if (!(existing_incrementalTransformDevName === incoming_incrementalTransformDevName)) {
+            return false;
+        }
+    }
+    const existing_lastRunStatus = existing.lastRunStatus;
+    const incoming_lastRunStatus = incoming.lastRunStatus;
+    // if at least one of these optionals is defined
+    if (existing_lastRunStatus !== undefined || incoming_lastRunStatus !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_lastRunStatus === undefined || incoming_lastRunStatus === undefined) {
+            return false;
+        }
+        if (!(existing_lastRunStatus === incoming_lastRunStatus)) {
+            return false;
+        }
+    }
+    const existing_primaryObjectLabel = existing.primaryObjectLabel;
+    const incoming_primaryObjectLabel = incoming.primaryObjectLabel;
+    // if at least one of these optionals is defined
+    if (existing_primaryObjectLabel !== undefined || incoming_primaryObjectLabel !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_primaryObjectLabel === undefined || incoming_primaryObjectLabel === undefined) {
+            return false;
+        }
+        if (!(existing_primaryObjectLabel === incoming_primaryObjectLabel)) {
+            return false;
+        }
+    }
+    const existing_primaryObjectName = existing.primaryObjectName;
+    const incoming_primaryObjectName = incoming.primaryObjectName;
+    if (!(existing_primaryObjectName === incoming_primaryObjectName)) {
+        return false;
+    }
+    const existing_sessionEndTimeUnit = existing.sessionEndTimeUnit;
+    const incoming_sessionEndTimeUnit = incoming.sessionEndTimeUnit;
+    // if at least one of these optionals is defined
+    if (existing_sessionEndTimeUnit !== undefined || incoming_sessionEndTimeUnit !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_sessionEndTimeUnit === undefined || incoming_sessionEndTimeUnit === undefined) {
+            return false;
+        }
+        if (!(existing_sessionEndTimeUnit === incoming_sessionEndTimeUnit)) {
+            return false;
+        }
+    }
+    const existing_status = existing.status;
+    const incoming_status = incoming.status;
+    if (!(existing_status === incoming_status)) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    // if at least one of these optionals is defined
+    if (existing_type !== undefined || incoming_type !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_type === undefined || incoming_type === undefined) {
+            return false;
+        }
+        if (!(existing_type === incoming_type)) {
+            return false;
+        }
+    }
+    const existing_valuesDmoLabel = existing.valuesDmoLabel;
+    const incoming_valuesDmoLabel = incoming.valuesDmoLabel;
+    // if at least one of these optionals is defined
+    if (existing_valuesDmoLabel !== undefined || incoming_valuesDmoLabel !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_valuesDmoLabel === undefined || incoming_valuesDmoLabel === undefined) {
+            return false;
+        }
+        if (!(existing_valuesDmoLabel === incoming_valuesDmoLabel)) {
+            return false;
+        }
+    }
+    const existing_valuesDmoName = existing.valuesDmoName;
+    const incoming_valuesDmoName = incoming.valuesDmoName;
+    if (!(existing_valuesDmoName === incoming_valuesDmoName)) {
+        return false;
+    }
+    const existing_version = existing.version;
+    const incoming_version = incoming.version;
+    if (!(existing_version === incoming_version)) {
+        return false;
+    }
+    const existing_fullRefreshConfig = existing.fullRefreshConfig;
+    const incoming_fullRefreshConfig = incoming.fullRefreshConfig;
+    // if at least one of these optionals is defined
+    if (existing_fullRefreshConfig !== undefined || incoming_fullRefreshConfig !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_fullRefreshConfig === undefined || incoming_fullRefreshConfig === undefined) {
+            return false;
+        }
+        if (!(equals$7(existing_fullRefreshConfig, incoming_fullRefreshConfig))) {
+            return false;
+        }
+    }
+    const existing_incrementalRefreshConfig = existing.incrementalRefreshConfig;
+    const incoming_incrementalRefreshConfig = incoming.incrementalRefreshConfig;
+    // if at least one of these optionals is defined
+    if (existing_incrementalRefreshConfig !== undefined || incoming_incrementalRefreshConfig !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_incrementalRefreshConfig === undefined || incoming_incrementalRefreshConfig === undefined) {
+            return false;
+        }
+        if (!(equals$6(existing_incrementalRefreshConfig, incoming_incrementalRefreshConfig))) {
+            return false;
+        }
+    }
+    const existing_sourceObject = existing.sourceObject;
+    const incoming_sourceObject = incoming.sourceObject;
+    if (!(equals$4(existing_sourceObject, incoming_sourceObject))) {
+        return false;
+    }
+    return true;
+}
+const ingest$3 = function CdpDataGraphOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$3(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$3(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 3000000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "CDP", VERSION$3, RepresentationType$3, equals$3);
+    return createLink(key);
+};
+function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$3(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+}
+
+function select$9(luvio, params) {
+    return select$a();
+}
+function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$6(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$9(),
+        variables: {},
+    });
+    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 createResourceRequest$7(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$7 = 'createDataGraph';
+const createDataGraph_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataspaceName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('dataKitName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('label', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('primaryObjectName', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sourceObject', true, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('templateName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('type', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('isRecordCachingDisabled', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('isRealTimeToggleEnabled', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('cacheDurationInDays', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('maxRecordsCached', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('sessionEnd', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('sessionEndTimeUnit', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('fullRefreshConfig', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('incrementalRefreshConfig', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const createDataGraph_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, createDataGraph_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$8(createDataGraph_ConfigPropertyMetadata);
+function typeCheckConfig$7(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, createDataGraph_ConfigPropertyMetadata);
+    const untrustedConfig_sourceObject = untrustedConfig.sourceObject;
+    config.sourceObject = untrustedConfig_sourceObject;
+    const untrustedConfig_fullRefreshConfig = untrustedConfig.fullRefreshConfig;
+    const referenceDataGraphFullRefreshConfigInputRepresentationValidationError = validate$h(untrustedConfig_fullRefreshConfig);
+    if (referenceDataGraphFullRefreshConfigInputRepresentationValidationError === null) {
+        config.fullRefreshConfig = untrustedConfig_fullRefreshConfig;
+    }
+    const untrustedConfig_incrementalRefreshConfig = untrustedConfig.incrementalRefreshConfig;
+    const referenceDataGraphIncrementalRefreshConfigInputRepresentationValidationError = validate$g(untrustedConfig_incrementalRefreshConfig);
+    if (referenceDataGraphIncrementalRefreshConfigInputRepresentationValidationError === null) {
+        config.incrementalRefreshConfig = untrustedConfig_incrementalRefreshConfig;
+    }
+    return config;
+}
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$7(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createDataGraphAdapterFactory = (luvio) => {
+    return function createDataGraph(untrustedConfig) {
+        const config = validateAdapterConfig$7(untrustedConfig, createDataGraph_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createDataGraph"');
+        }
+        return buildNetworkSnapshot$7(luvio, config);
+    };
+};
+
+function select$8(luvio, params) {
+    return select$a();
+}
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$5(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$8(),
+        variables: {},
+    });
+    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 createResourceRequest$6(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs',
+        method: 'put',
+        body: config.body,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$6 = 'editDataGraph';
+const editDataGraph_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('editScheduleOnly', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('dataspaceName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('dataKitName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('label', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('primaryObjectName', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sourceObject', true, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('templateName', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('type', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('isRecordCachingDisabled', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('isRealTimeToggleEnabled', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('cacheDurationInDays', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('maxRecordsCached', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('sessionEnd', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('sessionEndTimeUnit', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('fullRefreshConfig', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('incrementalRefreshConfig', false, 2 /* Body */, 4 /* Unsupported */),
+];
+const editDataGraph_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, editDataGraph_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$8(editDataGraph_ConfigPropertyMetadata);
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, editDataGraph_ConfigPropertyMetadata);
+    const untrustedConfig_sourceObject = untrustedConfig.sourceObject;
+    config.sourceObject = untrustedConfig_sourceObject;
+    const untrustedConfig_fullRefreshConfig = untrustedConfig.fullRefreshConfig;
+    const referenceDataGraphFullRefreshConfigInputRepresentationValidationError = validate$h(untrustedConfig_fullRefreshConfig);
+    if (referenceDataGraphFullRefreshConfigInputRepresentationValidationError === null) {
+        config.fullRefreshConfig = untrustedConfig_fullRefreshConfig;
+    }
+    const untrustedConfig_incrementalRefreshConfig = untrustedConfig.incrementalRefreshConfig;
+    const referenceDataGraphIncrementalRefreshConfigInputRepresentationValidationError = validate$g(untrustedConfig_incrementalRefreshConfig);
+    if (referenceDataGraphIncrementalRefreshConfigInputRepresentationValidationError === null) {
+        config.incrementalRefreshConfig = untrustedConfig_incrementalRefreshConfig;
+    }
+    return config;
+}
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$6(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$5(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const editDataGraphAdapterFactory = (luvio) => {
+    return function editDataGraph(untrustedConfig) {
+        const config = validateAdapterConfig$6(untrustedConfig, editDataGraph_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "editDataGraph"');
+        }
+        return buildNetworkSnapshot$6(luvio, config);
+    };
+};
+
+function select$7(luvio, params) {
+    return select$a();
+}
+function keyBuilder$9(luvio, params) {
+    return keyBuilder$a(luvio, {
+        name: params.urlParams.dataGraphName
+    });
+}
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$9(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$7(),
+        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$9(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs/' + config.urlParams.dataGraphName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$5 = 'getDataGraph';
+const getDataGraph_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataGraphName', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('includeCIDetails', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('includeSegmentDetails', false, 1 /* QueryParameter */, 1 /* Boolean */),
+];
+const getDataGraph_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getDataGraph_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$8(getDataGraph_ConfigPropertyMetadata);
+function keyBuilder$8(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$9(luvio, resourceParams);
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, getDataGraph_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$5(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$2(luvio, config) {
+    createResourceParams$5(config);
+    return select$7();
+}
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(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$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$8(luvio, config),
+        node: adapterFragment$2(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDataGraphAdapterFactory = (luvio) => function CDP__getDataGraph(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$5(untrustedConfig, getDataGraph_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+};
+
+function keyBuilder$7(luvio, params) {
+    return keyBuilder$a(luvio, {
+        name: params.urlParams.dataGraphName
+    });
+}
+function getResponseCacheKeys$4(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$7(luvio, resourceParams);
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$7(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs/' + config.urlParams.dataGraphName + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$4 = 'deleteDataGraph';
+const deleteDataGraph_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataGraphName', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const deleteDataGraph_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, deleteDataGraph_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$8(deleteDataGraph_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, deleteDataGraph_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$4(cache, luvio, resourceParams);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const deleteDataGraphAdapterFactory = (luvio) => {
+    return function CDPdeleteDataGraph(untrustedConfig) {
+        const config = validateAdapterConfig$4(untrustedConfig, deleteDataGraph_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$4}"`);
+        }
+        return buildNetworkSnapshot$4(luvio, config);
+    };
+};
+
+const VERSION$2 = "0c1f279e921d51f73cd64db1eaef780c";
+function validate$2(obj, path = 'CdpDataGraphRetryOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_dataGraphName = obj.dataGraphName;
+        const path_dataGraphName = path + '.dataGraphName';
+        if (typeof obj_dataGraphName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_dataGraphName + '" (at "' + path_dataGraphName + '")');
+        }
+        const obj_lastRunStatus = obj.lastRunStatus;
+        const path_lastRunStatus = path + '.lastRunStatus';
+        if (typeof obj_lastRunStatus !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_lastRunStatus + '" (at "' + path_lastRunStatus + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'CdpDataGraphRetryOutputRepresentation';
+function keyBuilder$6(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.name;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        name: object.dataGraphName
+    };
+    return keyBuilder$6(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$6 = function CdpDataGraphRetryOutputRepresentationSelect() {
+    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 CdpDataGraphRetryOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$2(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 3000000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "CDP", VERSION$2, RepresentationType$2, equals$2);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+}
+
+function select$5(luvio, params) {
+    return select$6();
+}
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        variables: {},
+    });
+    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 createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs/retry',
+        method: 'put',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$3 = 'retryDataGraph';
+const retryDataGraph_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataGraphName', true, 2 /* Body */, 0 /* String */),
+];
+const retryDataGraph_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, retryDataGraph_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$8(retryDataGraph_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, retryDataGraph_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const retryDataGraphAdapterFactory = (luvio) => {
+    return function retryDataGraph(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, retryDataGraph_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "retryDataGraph"');
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+const VERSION$1 = "0c15cc932d3ea4f07bf6a3b0429e3520";
+function validate$1(obj, path = 'CdpDataGraphDependencyOutputRepresentation') {
+    const validateCdpObjectBaseOutputRepresentation_validateError = validate$f(obj, path);
+    if (validateCdpObjectBaseOutputRepresentation_validateError !== null) {
+        return validateCdpObjectBaseOutputRepresentation_validateError;
+    }
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_dependency = obj.dependency;
+        const path_dependency = path + '.dependency';
+        if (!ArrayIsArray(obj_dependency)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_dependency + '" (at "' + path_dependency + '")');
+        }
+        for (let i = 0; i < obj_dependency.length; i++) {
+            const obj_dependency_item = obj_dependency[i];
+            const path_dependency_item = path_dependency + '[' + i + ']';
+            const referencepath_dependency_itemValidationError = validate$b(obj_dependency_item, path_dependency_item);
+            if (referencepath_dependency_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DependencyOutputRepresentation (at "' + path_dependency_item + '")\n';
+                message += referencepath_dependency_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'CdpDataGraphDependencyOutputRepresentation';
+function keyBuilder$5(luvio, config) {
+    return keyBuilder$b(luvio, config);
+}
+function keyBuilderFromType$1(luvio, object) {
+    return keyBuilderFromType$4(luvio, object);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$4 = function CdpDataGraphDependencyOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        opaque: true
+    };
+};
+function equals$1(existing, incoming) {
+    if (equals$9(existing, incoming) === false) {
+        return false;
+    }
+    const existing_dependency = existing.dependency;
+    const incoming_dependency = incoming.dependency;
+    const equals_dependency_items = equalsArray(existing_dependency, incoming_dependency, (existing_dependency_item, incoming_dependency_item) => {
+        if (!(equals$5(existing_dependency_item, incoming_dependency_item))) {
+            return false;
+        }
+    });
+    if (equals_dependency_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$1 = function CdpDataGraphDependencyOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 3000000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "CDP", VERSION$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+}
+
+function select$3(luvio, params) {
+    return select$4();
+}
+function keyBuilder$4(luvio, params) {
+    return keyBuilder$5(luvio, {
+        name: params.urlParams.dataGraphName
+    });
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$4(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        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$1(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$4(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs/dependency/' + config.urlParams.dataGraphName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'getDataGraphDependency';
+const getDataGraphDependency_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataGraphName', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getDataGraphDependency_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getDataGraphDependency_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$8(getDataGraphDependency_ConfigPropertyMetadata);
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$4(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, getDataGraphDependency_ConfigPropertyMetadata);
+    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$1(luvio, config) {
+    createResourceParams$2(config);
+    return select$3();
+}
+function onFetchResponseSuccess$1(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$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(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$1(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$3(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDataGraphDependencyAdapterFactory = (luvio) => function CDP__getDataGraphDependency(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getDataGraphDependency_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+
+const VERSION = "f772ba42e8976d22b7d5bfc77460f241";
+function validate(obj, path = 'CdpDataGraphDraftOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_outputRepresentation = obj.outputRepresentation;
+        const path_outputRepresentation = path + '.outputRepresentation';
+        const referencepath_outputRepresentationValidationError = validate$3(obj_outputRepresentation, path_outputRepresentation);
+        if (referencepath_outputRepresentationValidationError !== null) {
+            let message = 'Object doesn\'t match CdpDataGraphOutputRepresentation (at "' + path_outputRepresentation + '")\n';
+            message += referencepath_outputRepresentationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'CdpDataGraphDraftOutputRepresentation';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.name;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        name: object.outputRepresentation.name
+    };
+    return keyBuilder$2(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$2 = function CdpDataGraphDraftOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function CdpDataGraphDraftOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 3000000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "CDP", VERSION, RepresentationType, equals);
+    return createLink(key);
+};
+function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+}
+
+function select$1(luvio, params) {
+    return select$2();
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess$1(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$1(),
+        variables: {},
+    });
+    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 createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs/draft',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$1 = 'saveDataGraphDraft';
+const saveDataGraphDraft_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataGraphName', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('jsonSchema', true, 2 /* Body */, 0 /* String */),
+];
+const saveDataGraphDraft_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, saveDataGraphDraft_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$8(saveDataGraphDraft_ConfigPropertyMetadata);
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, saveDataGraphDraft_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const saveDataGraphDraftAdapterFactory = (luvio) => {
+    return function saveDataGraphDraft(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, saveDataGraphDraft_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "saveDataGraphDraft"');
+        }
+        return buildNetworkSnapshot$1(luvio, config);
+    };
+};
+
+function select(luvio, params) {
+    return select$2();
+}
+function keyBuilder$1(luvio, params) {
+    return keyBuilder$2(luvio, {
+        name: params.urlParams.dataGraphName
+    });
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$1(luvio, resourceParams);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        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(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/ssot/data-graphs/draft/' + config.urlParams.dataGraphName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'getDataGraphDraft';
+const getDataGraphDraft_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('dataGraphName', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getDataGraphDraft_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getDataGraphDraft_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$8(getDataGraphDraft_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$8(untrustedConfig, config, getDataGraphDraft_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDataGraphDraftAdapterFactory = (luvio) => function CDP__getDataGraphDraft(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getDataGraphDraft_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+export { createDataGraphAdapterFactory, deleteDataGraphAdapterFactory, editDataGraphAdapterFactory, getDataGraphAdapterFactory, getDataGraphDependencyAdapterFactory, getDataGraphDraftAdapterFactory, retryDataGraphAdapterFactory, saveDataGraphDraftAdapterFactory };