@salesforce/lds-adapters-platform-files 1.305.0 → 1.306.0

package/dist/es/es2018/platform-files.js

@@ -4,10 +4,10 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1, StoreKeyMap, createResourceParams as createResourceParams$1 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1, StoreKeyMap, createResourceParams as createResourceParams$2, typeCheckConfig as typeCheckConfig$2 } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
-const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
 const { isArray: ArrayIsArray$1 } = Array;
 /**
  * Validates an adapter config is well-formed.
@@ -31,7 +31,7 @@ function validateConfig(config, adapter, oneOf) {
         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))) {
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
         throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
     }
 }
@@ -48,6 +48,16 @@ const snapshotRefreshOptions = {
         },
     }
 };
+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);
@@ -61,16 +71,49 @@ function buildAdapterValidationConfig(displayName, paramsMeta) {
 }
 const keyPrefix = 'files';
 
+const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
 const { isArray: ArrayIsArray } = Array;
+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 equalsObject(a, b, equalsProp) {
+    const aKeys = ObjectKeys(a).sort();
+    const bKeys = ObjectKeys(b).sort();
+    const aKeysLength = aKeys.length;
+    const bKeysLength = bKeys.length;
+    if (aKeysLength !== bKeysLength) {
+        return false;
+    }
+    for (let i = 0; i < aKeys.length; i++) {
+        const key = aKeys[i];
+        if (key !== bKeys[i]) {
+            return false;
+        }
+        if (equalsProp(a[key], b[key]) === false) {
+            return false;
+        }
+    }
+    return true;
+}
 function createLink(ref) {
     return {
         __ref: serializeStructuredKey(ref),
     };
 }
 
-const TTL = 100;
-const VERSION = "0ebfcb4004619c58d2d8352ba253d6c1";
-function validate(obj, path = 'FileUploadConfigRepresentation') {
+const TTL$1 = 100;
+const VERSION$m = "0ebfcb4004619c58d2d8352ba253d6c1";
+function validate$m(obj, path = 'FileUploadConfigRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -98,14 +141,14 @@ function validate(obj, path = 'FileUploadConfigRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType = 'FileUploadConfigRepresentation';
-function normalize(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$1 = 'FileUploadConfigRepresentation';
+function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$1 = function FileUploadConfigRepresentationSelect() {
+const select$o = function FileUploadConfigRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION,
+        version: VERSION$m,
         private: [],
         selections: [
             {
@@ -127,7 +170,7 @@ const select$1 = function FileUploadConfigRepresentationSelect() {
         ]
     };
 };
-function equals(existing, incoming) {
+function equals$m(existing, incoming) {
     const existing_hasCustomRecordTypes = existing.hasCustomRecordTypes;
     const incoming_hasCustomRecordTypes = incoming.hasCustomRecordTypes;
     if (!(existing_hasCustomRecordTypes === incoming_hasCustomRecordTypes)) {
@@ -150,44 +193,44 @@ function equals(existing, incoming) {
     }
     return true;
 }
-const ingest = function FileUploadConfigRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$1 = function FileUploadConfigRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate(input);
+        const validateError = validate$m(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "files", VERSION, RepresentationType, equals);
+    const ttlToUse = TTL$1;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "files", VERSION$m, RepresentationType$1, equals$m);
     return createLink(key);
 };
-function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType,
+        representationName: RepresentationType$1,
         mergeable: false
     });
 }
 
-function select(luvio, params) {
-    return select$1();
+function select$n(luvio, params) {
+    return select$o();
 }
-function keyBuilder$1(luvio, params) {
+function keyBuilder$2(luvio, params) {
     return keyPrefix + '::FileUploadConfigRepresentation:(' + ')';
 }
-function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1());
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$2());
 }
-function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$1();
-    luvio.storeIngest(key, ingest, body);
+    const key = keyBuilder$2();
+    luvio.storeIngest(key, ingest$1, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select(),
+        node: select$n(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -199,18 +242,18 @@ function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$1();
+    const key = keyBuilder$2();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL,
+        ttl: TTL$1,
         namespace: keyPrefix,
-        version: VERSION,
-        representationName: RepresentationType
+        version: VERSION$m,
+        representationName: RepresentationType$1
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest(config) {
+function createResourceRequest$1(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -224,57 +267,57 @@ function createResourceRequest(config) {
     };
 }
 
-const adapterName = 'getFileUploadConfig';
+const adapterName$1 = 'getFileUploadConfig';
 const getFileUploadConfig_ConfigPropertyMetadata = [];
-const getFileUploadConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getFileUploadConfig_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$1(getFileUploadConfig_ConfigPropertyMetadata);
-function keyBuilder(luvio, config) {
-    createResourceParams(config);
-    return keyBuilder$1();
+const getFileUploadConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getFileUploadConfig_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$2(getFileUploadConfig_ConfigPropertyMetadata);
+function keyBuilder$1(luvio, config) {
+    createResourceParams$1(config);
+    return keyBuilder$2();
 }
-function typeCheckConfig(untrustedConfig) {
+function typeCheckConfig$1(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig();
+    const config = typeCheckConfig$1();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment(luvio, config) {
-    createResourceParams(config);
-    return select();
+    createResourceParams$1(config);
+    return select$n();
 }
 function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1(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)
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot(luvio, config, options) {
-    const resourceParams = createResourceParams(config);
-    const request = createResourceRequest();
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1();
     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);
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -282,23 +325,23 @@ function buildNetworkSnapshot(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder(luvio, config),
+        recordId: keyBuilder$1(luvio, config),
         node: adapterFragment(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getFileUploadConfigAdapterFactory = (luvio) => function files__getFileUploadConfig(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig(untrustedConfig, getFileUploadConfig_ConfigPropertyNames);
+    const config = validateAdapterConfig$1(untrustedConfig, getFileUploadConfig_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -307,4 +350,4418 @@ const getFileUploadConfigAdapterFactory = (luvio) => function files__getFileUplo
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { getFileUploadConfigAdapterFactory };
+const VERSION$l = "1544350e7c5b999113ef125ff9c46f64";
+function validate$l(obj, path = 'ContentHubRepositoryAuthenticationRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_authFlowUrl = obj.authFlowUrl;
+        const path_authFlowUrl = path + '.authFlowUrl';
+        if (typeof obj_authFlowUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_authFlowUrl + '" (at "' + path_authFlowUrl + '")');
+        }
+        const obj_authProtocol = obj.authProtocol;
+        const path_authProtocol = path + '.authProtocol';
+        if (typeof obj_authProtocol !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_authProtocol + '" (at "' + path_authProtocol + '")');
+        }
+        const obj_userHasAuthSettings = obj.userHasAuthSettings;
+        const path_userHasAuthSettings = path + '.userHasAuthSettings';
+        if (typeof obj_userHasAuthSettings !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_userHasAuthSettings + '" (at "' + path_userHasAuthSettings + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$m = function ContentHubRepositoryAuthenticationRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$l,
+        private: [],
+        selections: [
+            {
+                name: 'authFlowUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'authProtocol',
+                kind: 'Scalar'
+            },
+            {
+                name: 'userHasAuthSettings',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$l(existing, incoming) {
+    const existing_userHasAuthSettings = existing.userHasAuthSettings;
+    const incoming_userHasAuthSettings = incoming.userHasAuthSettings;
+    if (!(existing_userHasAuthSettings === incoming_userHasAuthSettings)) {
+        return false;
+    }
+    const existing_authFlowUrl = existing.authFlowUrl;
+    const incoming_authFlowUrl = incoming.authFlowUrl;
+    if (!(existing_authFlowUrl === incoming_authFlowUrl)) {
+        return false;
+    }
+    const existing_authProtocol = existing.authProtocol;
+    const incoming_authProtocol = incoming.authProtocol;
+    if (!(existing_authProtocol === incoming_authProtocol)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$k = "fa4f55b364524f360d9f3b8b10aaf137";
+function validate$k(obj, path = 'ContentHubRepositoryFeaturesRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_canBrowse = obj.canBrowse;
+        const path_canBrowse = path + '.canBrowse';
+        if (typeof obj_canBrowse !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_canBrowse + '" (at "' + path_canBrowse + '")');
+        }
+        const obj_canSearch = obj.canSearch;
+        const path_canSearch = path + '.canSearch';
+        if (typeof obj_canSearch !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_canSearch + '" (at "' + path_canSearch + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$l = function ContentHubRepositoryFeaturesRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$k,
+        private: [],
+        selections: [
+            {
+                name: 'canBrowse',
+                kind: 'Scalar'
+            },
+            {
+                name: 'canSearch',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$k(existing, incoming) {
+    const existing_canBrowse = existing.canBrowse;
+    const incoming_canBrowse = incoming.canBrowse;
+    if (!(existing_canBrowse === incoming_canBrowse)) {
+        return false;
+    }
+    const existing_canSearch = existing.canSearch;
+    const incoming_canSearch = incoming.canSearch;
+    if (!(existing_canSearch === incoming_canSearch)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$j = "0c0c85c97f540c4a8883d7fa795e7e0e";
+function validate$j(obj, path = 'ReferenceRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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_url = obj.url;
+        const path_url = path + '.url';
+        if (typeof obj_url !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$k = function ReferenceRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$j,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$j(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$i = "646fd171ffd555ff1aa0bca29f4112d0";
+function validate$i(obj, path = 'ContentHubProviderTypeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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_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;
+}
+const select$j = function ContentHubProviderTypeRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$i,
+        private: [],
+        selections: [
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$i(existing, incoming) {
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$h = "23ecddf405537e254437ac17ca260211";
+function validate$h(obj, path = 'ContentHubRepositoryRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_additionalLabel = obj.additionalLabel;
+        const path_additionalLabel = path + '.additionalLabel';
+        let obj_additionalLabel_union0 = null;
+        const obj_additionalLabel_union0_error = (() => {
+            if (typeof obj_additionalLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_additionalLabel + '" (at "' + path_additionalLabel + '")');
+            }
+        })();
+        if (obj_additionalLabel_union0_error != null) {
+            obj_additionalLabel_union0 = obj_additionalLabel_union0_error.message;
+        }
+        let obj_additionalLabel_union1 = null;
+        const obj_additionalLabel_union1_error = (() => {
+            if (obj_additionalLabel !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_additionalLabel + '" (at "' + path_additionalLabel + '")');
+            }
+        })();
+        if (obj_additionalLabel_union1_error != null) {
+            obj_additionalLabel_union1 = obj_additionalLabel_union1_error.message;
+        }
+        if (obj_additionalLabel_union0 && obj_additionalLabel_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_additionalLabel + '")';
+            message += '\n' + obj_additionalLabel_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_additionalLabel_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_authentication = obj.authentication;
+        const path_authentication = path + '.authentication';
+        const referencepath_authenticationValidationError = validate$l(obj_authentication, path_authentication);
+        if (referencepath_authenticationValidationError !== null) {
+            let message = 'Object doesn\'t match ContentHubRepositoryAuthenticationRepresentation (at "' + path_authentication + '")\n';
+            message += referencepath_authenticationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_communityNickname = obj.communityNickname;
+        const path_communityNickname = path + '.communityNickname';
+        if (typeof obj_communityNickname !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_communityNickname + '" (at "' + path_communityNickname + '")');
+        }
+        const obj_companyName = obj.companyName;
+        const path_companyName = path + '.companyName';
+        if (typeof obj_companyName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_companyName + '" (at "' + path_companyName + '")');
+        }
+        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_features = obj.features;
+        const path_features = path + '.features';
+        const referencepath_featuresValidationError = validate$k(obj_features, path_features);
+        if (referencepath_featuresValidationError !== null) {
+            let message = 'Object doesn\'t match ContentHubRepositoryFeaturesRepresentation (at "' + path_features + '")\n';
+            message += referencepath_featuresValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_firstName = obj.firstName;
+        const path_firstName = path + '.firstName';
+        if (typeof obj_firstName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_firstName + '" (at "' + path_firstName + '")');
+        }
+        const obj_isInThisCommunity = obj.isInThisCommunity;
+        const path_isInThisCommunity = path + '.isInThisCommunity';
+        if (typeof obj_isInThisCommunity !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isInThisCommunity + '" (at "' + path_isInThisCommunity + '")');
+        }
+        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_lastName = obj.lastName;
+        const path_lastName = path + '.lastName';
+        if (typeof obj_lastName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_lastName + '" (at "' + path_lastName + '")');
+        }
+        const obj_mySubscription = obj.mySubscription;
+        const path_mySubscription = path + '.mySubscription';
+        const referencepath_mySubscriptionValidationError = validate$j(obj_mySubscription, path_mySubscription);
+        if (referencepath_mySubscriptionValidationError !== null) {
+            let message = 'Object doesn\'t match ReferenceRepresentation (at "' + path_mySubscription + '")\n';
+            message += referencepath_mySubscriptionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_providerType = obj.providerType;
+        const path_providerType = path + '.providerType';
+        const referencepath_providerTypeValidationError = validate$i(obj_providerType, path_providerType);
+        if (referencepath_providerTypeValidationError !== null) {
+            let message = 'Object doesn\'t match ContentHubProviderTypeRepresentation (at "' + path_providerType + '")\n';
+            message += referencepath_providerTypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_rootFolderItemsUrl = obj.rootFolderItemsUrl;
+        const path_rootFolderItemsUrl = path + '.rootFolderItemsUrl';
+        if (typeof obj_rootFolderItemsUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_rootFolderItemsUrl + '" (at "' + path_rootFolderItemsUrl + '")');
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        if (typeof obj_title !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+        }
+        const obj_userType = obj.userType;
+        const path_userType = path + '.userType';
+        if (typeof obj_userType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_userType + '" (at "' + path_userType + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$i = function ContentHubRepositoryRepresentationSelect() {
+    const { selections: ContentHubRepositoryAuthenticationRepresentation__selections, opaque: ContentHubRepositoryAuthenticationRepresentation__opaque, } = select$m();
+    const { selections: ContentHubRepositoryFeaturesRepresentation__selections, opaque: ContentHubRepositoryFeaturesRepresentation__opaque, } = select$l();
+    const { selections: ReferenceRepresentation__selections, opaque: ReferenceRepresentation__opaque, } = select$k();
+    const { selections: ContentHubProviderTypeRepresentation__selections, opaque: ContentHubProviderTypeRepresentation__opaque, } = select$j();
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        selections: [
+            {
+                name: 'additionalLabel',
+                kind: 'Scalar'
+            },
+            {
+                name: 'authentication',
+                kind: 'Object',
+                selections: ContentHubRepositoryAuthenticationRepresentation__selections
+            },
+            {
+                name: 'communityNickname',
+                kind: 'Scalar'
+            },
+            {
+                name: 'companyName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'displayName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'features',
+                kind: 'Object',
+                selections: ContentHubRepositoryFeaturesRepresentation__selections
+            },
+            {
+                name: 'firstName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isInThisCommunity',
+                kind: 'Scalar'
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'lastName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'mySubscription',
+                kind: 'Object',
+                selections: ReferenceRepresentation__selections
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'providerType',
+                kind: 'Object',
+                selections: ContentHubProviderTypeRepresentation__selections
+            },
+            {
+                name: 'rootFolderItemsUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'title',
+                kind: 'Scalar'
+            },
+            {
+                name: 'userType',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$h(existing, incoming) {
+    const existing_isInThisCommunity = existing.isInThisCommunity;
+    const incoming_isInThisCommunity = incoming.isInThisCommunity;
+    if (!(existing_isInThisCommunity === incoming_isInThisCommunity)) {
+        return false;
+    }
+    const existing_communityNickname = existing.communityNickname;
+    const incoming_communityNickname = incoming.communityNickname;
+    if (!(existing_communityNickname === incoming_communityNickname)) {
+        return false;
+    }
+    const existing_companyName = existing.companyName;
+    const incoming_companyName = incoming.companyName;
+    if (!(existing_companyName === incoming_companyName)) {
+        return false;
+    }
+    const existing_displayName = existing.displayName;
+    const incoming_displayName = incoming.displayName;
+    if (!(existing_displayName === incoming_displayName)) {
+        return false;
+    }
+    const existing_firstName = existing.firstName;
+    const incoming_firstName = incoming.firstName;
+    if (!(existing_firstName === incoming_firstName)) {
+        return false;
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    const existing_lastName = existing.lastName;
+    const incoming_lastName = incoming.lastName;
+    if (!(existing_lastName === incoming_lastName)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_rootFolderItemsUrl = existing.rootFolderItemsUrl;
+    const incoming_rootFolderItemsUrl = incoming.rootFolderItemsUrl;
+    if (!(existing_rootFolderItemsUrl === incoming_rootFolderItemsUrl)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_userType = existing.userType;
+    const incoming_userType = incoming.userType;
+    if (!(existing_userType === incoming_userType)) {
+        return false;
+    }
+    const existing_additionalLabel = existing.additionalLabel;
+    const incoming_additionalLabel = incoming.additionalLabel;
+    if (!(existing_additionalLabel === incoming_additionalLabel)) {
+        return false;
+    }
+    const existing_authentication = existing.authentication;
+    const incoming_authentication = incoming.authentication;
+    if (!(equals$l(existing_authentication, incoming_authentication))) {
+        return false;
+    }
+    const existing_features = existing.features;
+    const incoming_features = incoming.features;
+    if (!(equals$k(existing_features, incoming_features))) {
+        return false;
+    }
+    const existing_mySubscription = existing.mySubscription;
+    const incoming_mySubscription = incoming.mySubscription;
+    if (!(equals$j(existing_mySubscription, incoming_mySubscription))) {
+        return false;
+    }
+    const existing_providerType = existing.providerType;
+    const incoming_providerType = incoming.providerType;
+    if (!(equals$i(existing_providerType, incoming_providerType))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$g = "24b4f4dd2754010fe3991590a16b4503";
+function validate$g(obj, path = 'ContentHubPermissionTypeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$h = function ContentHubPermissionTypeRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$g,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$g(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_label = existing.label;
+    const incoming_label = incoming.label;
+    if (!(existing_label === incoming_label)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$f = "6258b354c4a672a25f319b56e2444396";
+function validate$f(obj, path = 'RepositoryGroupSummaryRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_domain = obj.domain;
+        const path_domain = path + '.domain';
+        if (typeof obj_domain !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_domain + '" (at "' + path_domain + '")');
+        }
+        const obj_email = obj.email;
+        const path_email = path + '.email';
+        if (typeof obj_email !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_email + '" (at "' + path_email + '")');
+        }
+        const obj_groupType = obj.groupType;
+        const path_groupType = path + '.groupType';
+        if (typeof obj_groupType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_groupType + '" (at "' + path_groupType + '")');
+        }
+        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_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        if (typeof obj_type !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$g = function RepositoryGroupSummaryRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$f,
+        private: [],
+        selections: [
+            {
+                name: 'domain',
+                kind: 'Scalar'
+            },
+            {
+                name: 'email',
+                kind: 'Scalar'
+            },
+            {
+                name: 'groupType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$f(existing, incoming) {
+    const existing_domain = existing.domain;
+    const incoming_domain = incoming.domain;
+    if (!(existing_domain === incoming_domain)) {
+        return false;
+    }
+    const existing_email = existing.email;
+    const incoming_email = incoming.email;
+    if (!(existing_email === incoming_email)) {
+        return false;
+    }
+    const existing_groupType = existing.groupType;
+    const incoming_groupType = incoming.groupType;
+    if (!(existing_groupType === incoming_groupType)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$e = "7bd621fa4165317ed863d0da2921b955";
+function validate$e(obj, path = 'ExternalFilePermissionInformationRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_externalFilePermissionTypes = obj.externalFilePermissionTypes;
+        const path_externalFilePermissionTypes = path + '.externalFilePermissionTypes';
+        if (!ArrayIsArray(obj_externalFilePermissionTypes)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_externalFilePermissionTypes + '" (at "' + path_externalFilePermissionTypes + '")');
+        }
+        for (let i = 0; i < obj_externalFilePermissionTypes.length; i++) {
+            const obj_externalFilePermissionTypes_item = obj_externalFilePermissionTypes[i];
+            const path_externalFilePermissionTypes_item = path_externalFilePermissionTypes + '[' + i + ']';
+            const referencepath_externalFilePermissionTypes_itemValidationError = validate$g(obj_externalFilePermissionTypes_item, path_externalFilePermissionTypes_item);
+            if (referencepath_externalFilePermissionTypes_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ContentHubPermissionTypeRepresentation (at "' + path_externalFilePermissionTypes_item + '")\n';
+                message += referencepath_externalFilePermissionTypes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_externalFilePermissionsFailure = obj.externalFilePermissionsFailure;
+        const path_externalFilePermissionsFailure = path + '.externalFilePermissionsFailure';
+        if (typeof obj_externalFilePermissionsFailure !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_externalFilePermissionsFailure + '" (at "' + path_externalFilePermissionsFailure + '")');
+        }
+        const obj_externalFilePermissionsInfoFailureReason = obj.externalFilePermissionsInfoFailureReason;
+        const path_externalFilePermissionsInfoFailureReason = path + '.externalFilePermissionsInfoFailureReason';
+        if (typeof obj_externalFilePermissionsInfoFailureReason !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_externalFilePermissionsInfoFailureReason + '" (at "' + path_externalFilePermissionsInfoFailureReason + '")');
+        }
+        const obj_externalFileSharingStatus = obj.externalFileSharingStatus;
+        const path_externalFileSharingStatus = path + '.externalFileSharingStatus';
+        if (typeof obj_externalFileSharingStatus !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_externalFileSharingStatus + '" (at "' + path_externalFileSharingStatus + '")');
+        }
+        const obj_repositoryPublicGroups = obj.repositoryPublicGroups;
+        const path_repositoryPublicGroups = path + '.repositoryPublicGroups';
+        if (!ArrayIsArray(obj_repositoryPublicGroups)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_repositoryPublicGroups + '" (at "' + path_repositoryPublicGroups + '")');
+        }
+        for (let i = 0; i < obj_repositoryPublicGroups.length; i++) {
+            const obj_repositoryPublicGroups_item = obj_repositoryPublicGroups[i];
+            const path_repositoryPublicGroups_item = path_repositoryPublicGroups + '[' + i + ']';
+            const referencepath_repositoryPublicGroups_itemValidationError = validate$f(obj_repositoryPublicGroups_item, path_repositoryPublicGroups_item);
+            if (referencepath_repositoryPublicGroups_itemValidationError !== null) {
+                let message = 'Object doesn\'t match RepositoryGroupSummaryRepresentation (at "' + path_repositoryPublicGroups_item + '")\n';
+                message += referencepath_repositoryPublicGroups_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$f = function ExternalFilePermissionInformationRepresentationSelect() {
+    const { selections: ContentHubPermissionTypeRepresentation__selections, opaque: ContentHubPermissionTypeRepresentation__opaque, } = select$h();
+    const { selections: RepositoryGroupSummaryRepresentation__selections, opaque: RepositoryGroupSummaryRepresentation__opaque, } = select$g();
+    return {
+        kind: 'Fragment',
+        version: VERSION$e,
+        private: [],
+        selections: [
+            {
+                name: 'externalFilePermissionTypes',
+                kind: 'Object',
+                plural: true,
+                selections: ContentHubPermissionTypeRepresentation__selections
+            },
+            {
+                name: 'externalFilePermissionsFailure',
+                kind: 'Scalar'
+            },
+            {
+                name: 'externalFilePermissionsInfoFailureReason',
+                kind: 'Scalar'
+            },
+            {
+                name: 'externalFileSharingStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'repositoryPublicGroups',
+                kind: 'Object',
+                plural: true,
+                selections: RepositoryGroupSummaryRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$e(existing, incoming) {
+    const existing_externalFilePermissionsFailure = existing.externalFilePermissionsFailure;
+    const incoming_externalFilePermissionsFailure = incoming.externalFilePermissionsFailure;
+    if (!(existing_externalFilePermissionsFailure === incoming_externalFilePermissionsFailure)) {
+        return false;
+    }
+    const existing_externalFilePermissionsInfoFailureReason = existing.externalFilePermissionsInfoFailureReason;
+    const incoming_externalFilePermissionsInfoFailureReason = incoming.externalFilePermissionsInfoFailureReason;
+    if (!(existing_externalFilePermissionsInfoFailureReason === incoming_externalFilePermissionsInfoFailureReason)) {
+        return false;
+    }
+    const existing_externalFileSharingStatus = existing.externalFileSharingStatus;
+    const incoming_externalFileSharingStatus = incoming.externalFileSharingStatus;
+    if (!(existing_externalFileSharingStatus === incoming_externalFileSharingStatus)) {
+        return false;
+    }
+    const existing_externalFilePermissionTypes = existing.externalFilePermissionTypes;
+    const incoming_externalFilePermissionTypes = incoming.externalFilePermissionTypes;
+    const equals_externalFilePermissionTypes_items = equalsArray(existing_externalFilePermissionTypes, incoming_externalFilePermissionTypes, (existing_externalFilePermissionTypes_item, incoming_externalFilePermissionTypes_item) => {
+        if (!(equals$g(existing_externalFilePermissionTypes_item, incoming_externalFilePermissionTypes_item))) {
+            return false;
+        }
+    });
+    if (equals_externalFilePermissionTypes_items === false) {
+        return false;
+    }
+    const existing_repositoryPublicGroups = existing.repositoryPublicGroups;
+    const incoming_repositoryPublicGroups = incoming.repositoryPublicGroups;
+    const equals_repositoryPublicGroups_items = equalsArray(existing_repositoryPublicGroups, incoming_repositoryPublicGroups, (existing_repositoryPublicGroups_item, incoming_repositoryPublicGroups_item) => {
+        if (!(equals$f(existing_repositoryPublicGroups_item, incoming_repositoryPublicGroups_item))) {
+            return false;
+        }
+    });
+    if (equals_repositoryPublicGroups_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$d = "4ffe76c088b0010d6c07321f8fc71413";
+function validate$d(obj, path = 'FileAssetRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_baseAssetUrl = obj.baseAssetUrl;
+        const path_baseAssetUrl = path + '.baseAssetUrl';
+        if (typeof obj_baseAssetUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_baseAssetUrl + '" (at "' + path_baseAssetUrl + '")');
+        }
+        const obj_baseUnauthenticatedAssetUrl = obj.baseUnauthenticatedAssetUrl;
+        const path_baseUnauthenticatedAssetUrl = path + '.baseUnauthenticatedAssetUrl';
+        if (typeof obj_baseUnauthenticatedAssetUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_baseUnauthenticatedAssetUrl + '" (at "' + path_baseUnauthenticatedAssetUrl + '")');
+        }
+        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_isVisibleByExternalUsers = obj.isVisibleByExternalUsers;
+        const path_isVisibleByExternalUsers = path + '.isVisibleByExternalUsers';
+        if (typeof obj_isVisibleByExternalUsers !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isVisibleByExternalUsers + '" (at "' + path_isVisibleByExternalUsers + '")');
+        }
+        const obj_masterLabel = obj.masterLabel;
+        const path_masterLabel = path + '.masterLabel';
+        if (typeof obj_masterLabel !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_masterLabel + '" (at "' + path_masterLabel + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_namespacePrefix = obj.namespacePrefix;
+        const path_namespacePrefix = path + '.namespacePrefix';
+        if (typeof obj_namespacePrefix !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_namespacePrefix + '" (at "' + path_namespacePrefix + '")');
+        }
+        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;
+}
+const select$e = function FileAssetRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$d,
+        private: [],
+        selections: [
+            {
+                name: 'baseAssetUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'baseUnauthenticatedAssetUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isVisibleByExternalUsers',
+                kind: 'Scalar'
+            },
+            {
+                name: 'masterLabel',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'namespacePrefix',
+                kind: 'Scalar'
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$d(existing, incoming) {
+    const existing_isVisibleByExternalUsers = existing.isVisibleByExternalUsers;
+    const incoming_isVisibleByExternalUsers = incoming.isVisibleByExternalUsers;
+    if (!(existing_isVisibleByExternalUsers === incoming_isVisibleByExternalUsers)) {
+        return false;
+    }
+    const existing_baseAssetUrl = existing.baseAssetUrl;
+    const incoming_baseAssetUrl = incoming.baseAssetUrl;
+    if (!(existing_baseAssetUrl === incoming_baseAssetUrl)) {
+        return false;
+    }
+    const existing_baseUnauthenticatedAssetUrl = existing.baseUnauthenticatedAssetUrl;
+    const incoming_baseUnauthenticatedAssetUrl = incoming.baseUnauthenticatedAssetUrl;
+    if (!(existing_baseUnauthenticatedAssetUrl === incoming_baseUnauthenticatedAssetUrl)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_masterLabel = existing.masterLabel;
+    const incoming_masterLabel = incoming.masterLabel;
+    if (!(existing_masterLabel === incoming_masterLabel)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_namespacePrefix = existing.namespacePrefix;
+    const incoming_namespacePrefix = incoming.namespacePrefix;
+    if (!(existing_namespacePrefix === incoming_namespacePrefix)) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$c = "33984440af1a8d58f347ad7f777f3599";
+function validate$c(obj, path = 'ModerationFlagItemRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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 + '")');
+        }
+        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 + '")');
+        }
+        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_moderationType = obj.moderationType;
+        const path_moderationType = path + '.moderationType';
+        if (typeof obj_moderationType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_moderationType + '" (at "' + path_moderationType + '")');
+        }
+        const obj_note = obj.note;
+        const path_note = path + '.note';
+        if (typeof obj_note !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_note + '" (at "' + path_note + '")');
+        }
+        const obj_visibility = obj.visibility;
+        const path_visibility = path + '.visibility';
+        if (typeof obj_visibility !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_visibility + '" (at "' + path_visibility + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$d = function ModerationFlagItemRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$c,
+        private: [],
+        selections: [
+            {
+                name: 'createdBy',
+                kind: 'Scalar'
+            },
+            {
+                name: 'createdDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'moderationType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'note',
+                kind: 'Scalar'
+            },
+            {
+                name: 'visibility',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$c(existing, incoming) {
+    const existing_createdBy = existing.createdBy;
+    const incoming_createdBy = incoming.createdBy;
+    if (!(existing_createdBy === incoming_createdBy)) {
+        return false;
+    }
+    const existing_createdDate = existing.createdDate;
+    const incoming_createdDate = incoming.createdDate;
+    if (!(existing_createdDate === incoming_createdDate)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_moderationType = existing.moderationType;
+    const incoming_moderationType = incoming.moderationType;
+    if (!(existing_moderationType === incoming_moderationType)) {
+        return false;
+    }
+    const existing_note = existing.note;
+    const incoming_note = incoming.note;
+    if (!(existing_note === incoming_note)) {
+        return false;
+    }
+    const existing_visibility = existing.visibility;
+    const incoming_visibility = incoming.visibility;
+    if (!(existing_visibility === incoming_visibility)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$b = "352260f98bea3d1c4691d37f0a76a0b9";
+function validate$b(obj, path = 'ModerationFlagsCollectionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_currentPageToken = obj.currentPageToken;
+        const path_currentPageToken = path + '.currentPageToken';
+        if (typeof obj_currentPageToken !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_currentPageToken + '" (at "' + path_currentPageToken + '")');
+        }
+        const obj_currentPageUrl = obj.currentPageUrl;
+        const path_currentPageUrl = path + '.currentPageUrl';
+        if (typeof obj_currentPageUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_currentPageUrl + '" (at "' + path_currentPageUrl + '")');
+        }
+        const obj_flags = obj.flags;
+        const path_flags = path + '.flags';
+        if (!ArrayIsArray(obj_flags)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_flags + '" (at "' + path_flags + '")');
+        }
+        for (let i = 0; i < obj_flags.length; i++) {
+            const obj_flags_item = obj_flags[i];
+            const path_flags_item = path_flags + '[' + i + ']';
+            const referencepath_flags_itemValidationError = validate$c(obj_flags_item, path_flags_item);
+            if (referencepath_flags_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ModerationFlagItemRepresentation (at "' + path_flags_item + '")\n';
+                message += referencepath_flags_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_nextPageToken = obj.nextPageToken;
+        const path_nextPageToken = path + '.nextPageToken';
+        if (typeof obj_nextPageToken !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_nextPageToken + '" (at "' + path_nextPageToken + '")');
+        }
+        const obj_nextPageUrl = obj.nextPageUrl;
+        const path_nextPageUrl = path + '.nextPageUrl';
+        if (typeof obj_nextPageUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_nextPageUrl + '" (at "' + path_nextPageUrl + '")');
+        }
+        const obj_pageSize = obj.pageSize;
+        const path_pageSize = path + '.pageSize';
+        if (typeof obj_pageSize !== 'number' || (typeof obj_pageSize === 'number' && Math.floor(obj_pageSize) !== obj_pageSize)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_pageSize + '" (at "' + path_pageSize + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$c = function ModerationFlagsCollectionRepresentationSelect() {
+    const { selections: ModerationFlagItemRepresentation__selections, opaque: ModerationFlagItemRepresentation__opaque, } = select$d();
+    return {
+        kind: 'Fragment',
+        version: VERSION$b,
+        private: [],
+        selections: [
+            {
+                name: 'currentPageToken',
+                kind: 'Scalar'
+            },
+            {
+                name: 'currentPageUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'flags',
+                kind: 'Object',
+                plural: true,
+                selections: ModerationFlagItemRepresentation__selections
+            },
+            {
+                name: 'nextPageToken',
+                kind: 'Scalar'
+            },
+            {
+                name: 'nextPageUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'pageSize',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$b(existing, incoming) {
+    const existing_pageSize = existing.pageSize;
+    const incoming_pageSize = incoming.pageSize;
+    if (!(existing_pageSize === incoming_pageSize)) {
+        return false;
+    }
+    const existing_currentPageToken = existing.currentPageToken;
+    const incoming_currentPageToken = incoming.currentPageToken;
+    if (!(existing_currentPageToken === incoming_currentPageToken)) {
+        return false;
+    }
+    const existing_currentPageUrl = existing.currentPageUrl;
+    const incoming_currentPageUrl = incoming.currentPageUrl;
+    if (!(existing_currentPageUrl === incoming_currentPageUrl)) {
+        return false;
+    }
+    const existing_nextPageToken = existing.nextPageToken;
+    const incoming_nextPageToken = incoming.nextPageToken;
+    if (!(existing_nextPageToken === incoming_nextPageToken)) {
+        return false;
+    }
+    const existing_nextPageUrl = existing.nextPageUrl;
+    const incoming_nextPageUrl = incoming.nextPageUrl;
+    if (!(existing_nextPageUrl === incoming_nextPageUrl)) {
+        return false;
+    }
+    const existing_flags = existing.flags;
+    const incoming_flags = incoming.flags;
+    const equals_flags_items = equalsArray(existing_flags, incoming_flags, (existing_flags_item, incoming_flags_item) => {
+        if (!(equals$c(existing_flags_item, incoming_flags_item))) {
+            return false;
+        }
+    });
+    if (equals_flags_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$a = "13562eb8ff78d5886789a53d2bd5a8a4";
+function validate$a(obj, path = 'ModerationFlagsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_flagCount = obj.flagCount;
+        const path_flagCount = path + '.flagCount';
+        if (typeof obj_flagCount !== 'number' || (typeof obj_flagCount === 'number' && Math.floor(obj_flagCount) !== obj_flagCount)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_flagCount + '" (at "' + path_flagCount + '")');
+        }
+        const obj_flagCountByReason = obj.flagCountByReason;
+        const path_flagCountByReason = path + '.flagCountByReason';
+        if (typeof obj_flagCountByReason !== 'object' || ArrayIsArray(obj_flagCountByReason) || obj_flagCountByReason === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj_flagCountByReason + '" (at "' + path_flagCountByReason + '")');
+        }
+        const obj_flagCountByReason_keys = ObjectKeys(obj_flagCountByReason);
+        for (let i = 0; i < obj_flagCountByReason_keys.length; i++) {
+            const key = obj_flagCountByReason_keys[i];
+            const obj_flagCountByReason_prop = obj_flagCountByReason[key];
+            const path_flagCountByReason_prop = path_flagCountByReason + '["' + key + '"]';
+            if (typeof obj_flagCountByReason_prop !== 'number' || (typeof obj_flagCountByReason_prop === 'number' && Math.floor(obj_flagCountByReason_prop) !== obj_flagCountByReason_prop)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_flagCountByReason_prop + '" (at "' + path_flagCountByReason_prop + '")');
+            }
+        }
+        const obj_flaggedByMe = obj.flaggedByMe;
+        const path_flaggedByMe = path + '.flaggedByMe';
+        if (typeof obj_flaggedByMe !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_flaggedByMe + '" (at "' + path_flaggedByMe + '")');
+        }
+        const obj_flags = obj.flags;
+        const path_flags = path + '.flags';
+        const referencepath_flagsValidationError = validate$b(obj_flags, path_flags);
+        if (referencepath_flagsValidationError !== null) {
+            let message = 'Object doesn\'t match ModerationFlagsCollectionRepresentation (at "' + path_flags + '")\n';
+            message += referencepath_flagsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$b = function ModerationFlagsRepresentationSelect() {
+    const { selections: ModerationFlagsCollectionRepresentation__selections, opaque: ModerationFlagsCollectionRepresentation__opaque, } = select$c();
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'flagCount',
+                kind: 'Scalar'
+            },
+            {
+                name: 'flagCountByReason',
+                kind: 'Scalar',
+                map: true
+            },
+            {
+                name: 'flaggedByMe',
+                kind: 'Scalar'
+            },
+            {
+                name: 'flags',
+                kind: 'Object',
+                selections: ModerationFlagsCollectionRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$a(existing, incoming) {
+    const existing_flaggedByMe = existing.flaggedByMe;
+    const incoming_flaggedByMe = incoming.flaggedByMe;
+    if (!(existing_flaggedByMe === incoming_flaggedByMe)) {
+        return false;
+    }
+    const existing_flagCount = existing.flagCount;
+    const incoming_flagCount = incoming.flagCount;
+    if (!(existing_flagCount === incoming_flagCount)) {
+        return false;
+    }
+    const existing_flagCountByReason = existing.flagCountByReason;
+    const incoming_flagCountByReason = incoming.flagCountByReason;
+    const equals_flagCountByReason_props = equalsObject(existing_flagCountByReason, incoming_flagCountByReason, (existing_flagCountByReason_prop, incoming_flagCountByReason_prop) => {
+        if (!(existing_flagCountByReason_prop === incoming_flagCountByReason_prop)) {
+            return false;
+        }
+    });
+    if (equals_flagCountByReason_props === false) {
+        return false;
+    }
+    const existing_flags = existing.flags;
+    const incoming_flags = incoming.flags;
+    if (!(equals$b(existing_flags, incoming_flags))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$9 = "ea2628b3acfa34a5fb973e3cdc2dcbe0";
+function validate$9(obj, path = 'MotifRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_color = obj.color;
+        const path_color = path + '.color';
+        if (typeof obj_color !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_color + '" (at "' + path_color + '")');
+        }
+        const obj_largeIconUrl = obj.largeIconUrl;
+        const path_largeIconUrl = path + '.largeIconUrl';
+        if (typeof obj_largeIconUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_largeIconUrl + '" (at "' + path_largeIconUrl + '")');
+        }
+        const obj_mediumIconUrl = obj.mediumIconUrl;
+        const path_mediumIconUrl = path + '.mediumIconUrl';
+        if (typeof obj_mediumIconUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mediumIconUrl + '" (at "' + path_mediumIconUrl + '")');
+        }
+        const obj_smallIconUrl = obj.smallIconUrl;
+        const path_smallIconUrl = path + '.smallIconUrl';
+        if (typeof obj_smallIconUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_smallIconUrl + '" (at "' + path_smallIconUrl + '")');
+        }
+        const obj_svgIconUrl = obj.svgIconUrl;
+        const path_svgIconUrl = path + '.svgIconUrl';
+        let obj_svgIconUrl_union0 = null;
+        const obj_svgIconUrl_union0_error = (() => {
+            if (typeof obj_svgIconUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_svgIconUrl + '" (at "' + path_svgIconUrl + '")');
+            }
+        })();
+        if (obj_svgIconUrl_union0_error != null) {
+            obj_svgIconUrl_union0 = obj_svgIconUrl_union0_error.message;
+        }
+        let obj_svgIconUrl_union1 = null;
+        const obj_svgIconUrl_union1_error = (() => {
+            if (obj_svgIconUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_svgIconUrl + '" (at "' + path_svgIconUrl + '")');
+            }
+        })();
+        if (obj_svgIconUrl_union1_error != null) {
+            obj_svgIconUrl_union1 = obj_svgIconUrl_union1_error.message;
+        }
+        if (obj_svgIconUrl_union0 && obj_svgIconUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_svgIconUrl + '")';
+            message += '\n' + obj_svgIconUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_svgIconUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$a = function MotifRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$9,
+        private: [],
+        selections: [
+            {
+                name: 'color',
+                kind: 'Scalar'
+            },
+            {
+                name: 'largeIconUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'mediumIconUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'smallIconUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'svgIconUrl',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$9(existing, incoming) {
+    const existing_color = existing.color;
+    const incoming_color = incoming.color;
+    if (!(existing_color === incoming_color)) {
+        return false;
+    }
+    const existing_largeIconUrl = existing.largeIconUrl;
+    const incoming_largeIconUrl = incoming.largeIconUrl;
+    if (!(existing_largeIconUrl === incoming_largeIconUrl)) {
+        return false;
+    }
+    const existing_mediumIconUrl = existing.mediumIconUrl;
+    const incoming_mediumIconUrl = incoming.mediumIconUrl;
+    if (!(existing_mediumIconUrl === incoming_mediumIconUrl)) {
+        return false;
+    }
+    const existing_smallIconUrl = existing.smallIconUrl;
+    const incoming_smallIconUrl = incoming.smallIconUrl;
+    if (!(existing_smallIconUrl === incoming_smallIconUrl)) {
+        return false;
+    }
+    const existing_svgIconUrl = existing.svgIconUrl;
+    const incoming_svgIconUrl = incoming.svgIconUrl;
+    if (!(existing_svgIconUrl === incoming_svgIconUrl)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$8 = "05d2b9c24b3e86c43f4585b49253d98e";
+function validate$8(obj, path = 'OutOfOfficeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_message = obj.message;
+        const path_message = path + '.message';
+        if (typeof obj_message !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$9 = function OutOfOfficeRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$8,
+        private: [],
+        selections: [
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$8(existing, incoming) {
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$7 = "04f9649781446a4380f18667d5951641";
+function validate$7(obj, path = 'PhotoRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_fullEmailPhotoUrl = obj.fullEmailPhotoUrl;
+        const path_fullEmailPhotoUrl = path + '.fullEmailPhotoUrl';
+        if (typeof obj_fullEmailPhotoUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_fullEmailPhotoUrl + '" (at "' + path_fullEmailPhotoUrl + '")');
+        }
+        const obj_largePhotoUrl = obj.largePhotoUrl;
+        const path_largePhotoUrl = path + '.largePhotoUrl';
+        if (typeof obj_largePhotoUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_largePhotoUrl + '" (at "' + path_largePhotoUrl + '")');
+        }
+        const obj_mediumPhotoUrl = obj.mediumPhotoUrl;
+        const path_mediumPhotoUrl = path + '.mediumPhotoUrl';
+        if (typeof obj_mediumPhotoUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_mediumPhotoUrl + '" (at "' + path_mediumPhotoUrl + '")');
+        }
+        const obj_photoVersionId = obj.photoVersionId;
+        const path_photoVersionId = path + '.photoVersionId';
+        let obj_photoVersionId_union0 = null;
+        const obj_photoVersionId_union0_error = (() => {
+            if (typeof obj_photoVersionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_photoVersionId + '" (at "' + path_photoVersionId + '")');
+            }
+        })();
+        if (obj_photoVersionId_union0_error != null) {
+            obj_photoVersionId_union0 = obj_photoVersionId_union0_error.message;
+        }
+        let obj_photoVersionId_union1 = null;
+        const obj_photoVersionId_union1_error = (() => {
+            if (obj_photoVersionId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_photoVersionId + '" (at "' + path_photoVersionId + '")');
+            }
+        })();
+        if (obj_photoVersionId_union1_error != null) {
+            obj_photoVersionId_union1 = obj_photoVersionId_union1_error.message;
+        }
+        if (obj_photoVersionId_union0 && obj_photoVersionId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_photoVersionId + '")';
+            message += '\n' + obj_photoVersionId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_photoVersionId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_smallPhotoUrl = obj.smallPhotoUrl;
+        const path_smallPhotoUrl = path + '.smallPhotoUrl';
+        if (typeof obj_smallPhotoUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_smallPhotoUrl + '" (at "' + path_smallPhotoUrl + '")');
+        }
+        const obj_standardEmailPhotoUrl = obj.standardEmailPhotoUrl;
+        const path_standardEmailPhotoUrl = path + '.standardEmailPhotoUrl';
+        if (typeof obj_standardEmailPhotoUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_standardEmailPhotoUrl + '" (at "' + path_standardEmailPhotoUrl + '")');
+        }
+        const obj_url = obj.url;
+        const path_url = path + '.url';
+        if (typeof obj_url !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$8 = function PhotoRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$7,
+        private: [],
+        selections: [
+            {
+                name: 'fullEmailPhotoUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'largePhotoUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'mediumPhotoUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'photoVersionId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'smallPhotoUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'standardEmailPhotoUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$7(existing, incoming) {
+    const existing_fullEmailPhotoUrl = existing.fullEmailPhotoUrl;
+    const incoming_fullEmailPhotoUrl = incoming.fullEmailPhotoUrl;
+    if (!(existing_fullEmailPhotoUrl === incoming_fullEmailPhotoUrl)) {
+        return false;
+    }
+    const existing_largePhotoUrl = existing.largePhotoUrl;
+    const incoming_largePhotoUrl = incoming.largePhotoUrl;
+    if (!(existing_largePhotoUrl === incoming_largePhotoUrl)) {
+        return false;
+    }
+    const existing_mediumPhotoUrl = existing.mediumPhotoUrl;
+    const incoming_mediumPhotoUrl = incoming.mediumPhotoUrl;
+    if (!(existing_mediumPhotoUrl === incoming_mediumPhotoUrl)) {
+        return false;
+    }
+    const existing_smallPhotoUrl = existing.smallPhotoUrl;
+    const incoming_smallPhotoUrl = incoming.smallPhotoUrl;
+    if (!(existing_smallPhotoUrl === incoming_smallPhotoUrl)) {
+        return false;
+    }
+    const existing_standardEmailPhotoUrl = existing.standardEmailPhotoUrl;
+    const incoming_standardEmailPhotoUrl = incoming.standardEmailPhotoUrl;
+    if (!(existing_standardEmailPhotoUrl === incoming_standardEmailPhotoUrl)) {
+        return false;
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    const existing_photoVersionId = existing.photoVersionId;
+    const incoming_photoVersionId = incoming.photoVersionId;
+    if (!(existing_photoVersionId === incoming_photoVersionId)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$6 = "b95277d84efb4e17fd50b8682527adaf";
+function validate$6(obj, path = 'ReputationLevelRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_levelImageUrl = obj.levelImageUrl;
+        const path_levelImageUrl = path + '.levelImageUrl';
+        if (typeof obj_levelImageUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_levelImageUrl + '" (at "' + path_levelImageUrl + '")');
+        }
+        const obj_levelName = obj.levelName;
+        const path_levelName = path + '.levelName';
+        if (typeof obj_levelName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_levelName + '" (at "' + path_levelName + '")');
+        }
+        const obj_levelNumber = obj.levelNumber;
+        const path_levelNumber = path + '.levelNumber';
+        if (typeof obj_levelNumber !== 'number' || (typeof obj_levelNumber === 'number' && Math.floor(obj_levelNumber) !== obj_levelNumber)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_levelNumber + '" (at "' + path_levelNumber + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$7 = function ReputationLevelRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$6,
+        private: [],
+        selections: [
+            {
+                name: 'levelImageUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'levelName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'levelNumber',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$6(existing, incoming) {
+    const existing_levelNumber = existing.levelNumber;
+    const incoming_levelNumber = incoming.levelNumber;
+    if (!(existing_levelNumber === incoming_levelNumber)) {
+        return false;
+    }
+    const existing_levelImageUrl = existing.levelImageUrl;
+    const incoming_levelImageUrl = incoming.levelImageUrl;
+    if (!(existing_levelImageUrl === incoming_levelImageUrl)) {
+        return false;
+    }
+    const existing_levelName = existing.levelName;
+    const incoming_levelName = incoming.levelName;
+    if (!(existing_levelName === incoming_levelName)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$5 = "f176d65dfc0ee669db9c0f1a1d25d53b";
+function validate$5(obj, path = 'ReputationRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_reputationLevel = obj.reputationLevel;
+        const path_reputationLevel = path + '.reputationLevel';
+        const referencepath_reputationLevelValidationError = validate$6(obj_reputationLevel, path_reputationLevel);
+        if (referencepath_reputationLevelValidationError !== null) {
+            let message = 'Object doesn\'t match ReputationLevelRepresentation (at "' + path_reputationLevel + '")\n';
+            message += referencepath_reputationLevelValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        obj.reputationPoints;
+        const obj_url = obj.url;
+        const path_url = path + '.url';
+        if (typeof obj_url !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$6 = function ReputationRepresentationSelect() {
+    const { selections: ReputationLevelRepresentation__selections, opaque: ReputationLevelRepresentation__opaque, } = select$7();
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'reputationLevel',
+                kind: 'Object',
+                selections: ReputationLevelRepresentation__selections
+            },
+            {
+                name: 'reputationPoints',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    const existing_reputationPoints = existing.reputationPoints;
+    const incoming_reputationPoints = incoming.reputationPoints;
+    if (!(existing_reputationPoints === incoming_reputationPoints)) {
+        return false;
+    }
+    const existing_reputationLevel = existing.reputationLevel;
+    const incoming_reputationLevel = incoming.reputationLevel;
+    if (!(equals$6(existing_reputationLevel, incoming_reputationLevel))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$4 = "a902c1345fece0b23591fc79dea8e8b0";
+function validate$4(obj, path = 'UserSummaryRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_additionalLabel = obj.additionalLabel;
+        const path_additionalLabel = path + '.additionalLabel';
+        let obj_additionalLabel_union0 = null;
+        const obj_additionalLabel_union0_error = (() => {
+            if (typeof obj_additionalLabel !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_additionalLabel + '" (at "' + path_additionalLabel + '")');
+            }
+        })();
+        if (obj_additionalLabel_union0_error != null) {
+            obj_additionalLabel_union0 = obj_additionalLabel_union0_error.message;
+        }
+        let obj_additionalLabel_union1 = null;
+        const obj_additionalLabel_union1_error = (() => {
+            if (obj_additionalLabel !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_additionalLabel + '" (at "' + path_additionalLabel + '")');
+            }
+        })();
+        if (obj_additionalLabel_union1_error != null) {
+            obj_additionalLabel_union1 = obj_additionalLabel_union1_error.message;
+        }
+        if (obj_additionalLabel_union0 && obj_additionalLabel_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_additionalLabel + '")';
+            message += '\n' + obj_additionalLabel_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_additionalLabel_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        if (obj.communityNickname !== undefined) {
+            const obj_communityNickname = obj.communityNickname;
+            const path_communityNickname = path + '.communityNickname';
+            if (typeof obj_communityNickname !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_communityNickname + '" (at "' + path_communityNickname + '")');
+            }
+        }
+        const obj_companyName = obj.companyName;
+        const path_companyName = path + '.companyName';
+        if (typeof obj_companyName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_companyName + '" (at "' + path_companyName + '")');
+        }
+        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_firstName = obj.firstName;
+        const path_firstName = path + '.firstName';
+        if (typeof obj_firstName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_firstName + '" (at "' + path_firstName + '")');
+        }
+        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_isActive = obj.isActive;
+        const path_isActive = path + '.isActive';
+        if (typeof obj_isActive !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isActive + '" (at "' + path_isActive + '")');
+        }
+        const obj_isInThisCommunity = obj.isInThisCommunity;
+        const path_isInThisCommunity = path + '.isInThisCommunity';
+        if (typeof obj_isInThisCommunity !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isInThisCommunity + '" (at "' + path_isInThisCommunity + '")');
+        }
+        const obj_lastName = obj.lastName;
+        const path_lastName = path + '.lastName';
+        if (typeof obj_lastName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_lastName + '" (at "' + path_lastName + '")');
+        }
+        const obj_motif = obj.motif;
+        const path_motif = path + '.motif';
+        const referencepath_motifValidationError = validate$9(obj_motif, path_motif);
+        if (referencepath_motifValidationError !== null) {
+            let message = 'Object doesn\'t match MotifRepresentation (at "' + path_motif + '")\n';
+            message += referencepath_motifValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_mySubscription = obj.mySubscription;
+        const path_mySubscription = path + '.mySubscription';
+        let obj_mySubscription_union0 = null;
+        const obj_mySubscription_union0_error = (() => {
+            const referencepath_mySubscriptionValidationError = validate$j(obj_mySubscription, path_mySubscription);
+            if (referencepath_mySubscriptionValidationError !== null) {
+                let message = 'Object doesn\'t match ReferenceRepresentation (at "' + path_mySubscription + '")\n';
+                message += referencepath_mySubscriptionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_mySubscription_union0_error != null) {
+            obj_mySubscription_union0 = obj_mySubscription_union0_error.message;
+        }
+        let obj_mySubscription_union1 = null;
+        const obj_mySubscription_union1_error = (() => {
+            if (obj_mySubscription !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_mySubscription + '" (at "' + path_mySubscription + '")');
+            }
+        })();
+        if (obj_mySubscription_union1_error != null) {
+            obj_mySubscription_union1 = obj_mySubscription_union1_error.message;
+        }
+        if (obj_mySubscription_union0 && obj_mySubscription_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_mySubscription + '")';
+            message += '\n' + obj_mySubscription_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_mySubscription_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_outOfOffice = obj.outOfOffice;
+        const path_outOfOffice = path + '.outOfOffice';
+        const referencepath_outOfOfficeValidationError = validate$8(obj_outOfOffice, path_outOfOffice);
+        if (referencepath_outOfOfficeValidationError !== null) {
+            let message = 'Object doesn\'t match OutOfOfficeRepresentation (at "' + path_outOfOffice + '")\n';
+            message += referencepath_outOfOfficeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_photo = obj.photo;
+        const path_photo = path + '.photo';
+        const referencepath_photoValidationError = validate$7(obj_photo, path_photo);
+        if (referencepath_photoValidationError !== null) {
+            let message = 'Object doesn\'t match PhotoRepresentation (at "' + path_photo + '")\n';
+            message += referencepath_photoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_reputation = obj.reputation;
+        const path_reputation = path + '.reputation';
+        let obj_reputation_union0 = null;
+        const obj_reputation_union0_error = (() => {
+            const referencepath_reputationValidationError = validate$5(obj_reputation, path_reputation);
+            if (referencepath_reputationValidationError !== null) {
+                let message = 'Object doesn\'t match ReputationRepresentation (at "' + path_reputation + '")\n';
+                message += referencepath_reputationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_reputation_union0_error != null) {
+            obj_reputation_union0 = obj_reputation_union0_error.message;
+        }
+        let obj_reputation_union1 = null;
+        const obj_reputation_union1_error = (() => {
+            if (obj_reputation !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_reputation + '" (at "' + path_reputation + '")');
+            }
+        })();
+        if (obj_reputation_union1_error != null) {
+            obj_reputation_union1 = obj_reputation_union1_error.message;
+        }
+        if (obj_reputation_union0 && obj_reputation_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_reputation + '")';
+            message += '\n' + obj_reputation_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_reputation_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        let obj_title_union0 = null;
+        const obj_title_union0_error = (() => {
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        if (obj_title_union0_error != null) {
+            obj_title_union0 = obj_title_union0_error.message;
+        }
+        let obj_title_union1 = null;
+        const obj_title_union1_error = (() => {
+            if (obj_title !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        if (obj_title_union1_error != null) {
+            obj_title_union1 = obj_title_union1_error.message;
+        }
+        if (obj_title_union0 && obj_title_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_title + '")';
+            message += '\n' + obj_title_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_title_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        let obj_type_union0 = null;
+        const obj_type_union0_error = (() => {
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        })();
+        if (obj_type_union0_error != null) {
+            obj_type_union0 = obj_type_union0_error.message;
+        }
+        let obj_type_union1 = null;
+        const obj_type_union1_error = (() => {
+            if (obj_type !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        })();
+        if (obj_type_union1_error != null) {
+            obj_type_union1 = obj_type_union1_error.message;
+        }
+        if (obj_type_union0 && obj_type_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_type + '")';
+            message += '\n' + obj_type_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_type_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_url = obj.url;
+        const path_url = path + '.url';
+        if (typeof obj_url !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+        }
+        const obj_userType = obj.userType;
+        const path_userType = path + '.userType';
+        if (typeof obj_userType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_userType + '" (at "' + path_userType + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$5 = function UserSummaryRepresentationSelect() {
+    const { selections: MotifRepresentation__selections, opaque: MotifRepresentation__opaque, } = select$a();
+    const { selections: ReferenceRepresentation__selections, opaque: ReferenceRepresentation__opaque, } = select$k();
+    const { selections: OutOfOfficeRepresentation__selections, opaque: OutOfOfficeRepresentation__opaque, } = select$9();
+    const { selections: PhotoRepresentation__selections, opaque: PhotoRepresentation__opaque, } = select$8();
+    const { selections: ReputationRepresentation__selections, opaque: ReputationRepresentation__opaque, } = select$6();
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'additionalLabel',
+                kind: 'Scalar'
+            },
+            {
+                name: 'communityNickname',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'companyName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'displayName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'firstName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isActive',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isInThisCommunity',
+                kind: 'Scalar'
+            },
+            {
+                name: 'lastName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'motif',
+                kind: 'Object',
+                selections: MotifRepresentation__selections
+            },
+            {
+                name: 'mySubscription',
+                kind: 'Object',
+                nullable: true,
+                selections: ReferenceRepresentation__selections
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'outOfOffice',
+                kind: 'Object',
+                selections: OutOfOfficeRepresentation__selections
+            },
+            {
+                name: 'photo',
+                kind: 'Object',
+                selections: PhotoRepresentation__selections
+            },
+            {
+                name: 'reputation',
+                kind: 'Object',
+                nullable: true,
+                selections: ReputationRepresentation__selections
+            },
+            {
+                name: 'title',
+                kind: 'Scalar'
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            },
+            {
+                name: 'userType',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_isActive = existing.isActive;
+    const incoming_isActive = incoming.isActive;
+    if (!(existing_isActive === incoming_isActive)) {
+        return false;
+    }
+    const existing_isInThisCommunity = existing.isInThisCommunity;
+    const incoming_isInThisCommunity = incoming.isInThisCommunity;
+    if (!(existing_isInThisCommunity === incoming_isInThisCommunity)) {
+        return false;
+    }
+    const existing_communityNickname = existing.communityNickname;
+    const incoming_communityNickname = incoming.communityNickname;
+    // if at least one of these optionals is defined
+    if (existing_communityNickname !== undefined || incoming_communityNickname !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_communityNickname === undefined || incoming_communityNickname === undefined) {
+            return false;
+        }
+        if (!(existing_communityNickname === incoming_communityNickname)) {
+            return false;
+        }
+    }
+    const existing_companyName = existing.companyName;
+    const incoming_companyName = incoming.companyName;
+    if (!(existing_companyName === incoming_companyName)) {
+        return false;
+    }
+    const existing_displayName = existing.displayName;
+    const incoming_displayName = incoming.displayName;
+    if (!(existing_displayName === incoming_displayName)) {
+        return false;
+    }
+    const existing_firstName = existing.firstName;
+    const incoming_firstName = incoming.firstName;
+    if (!(existing_firstName === incoming_firstName)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_lastName = existing.lastName;
+    const incoming_lastName = incoming.lastName;
+    if (!(existing_lastName === incoming_lastName)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    const existing_userType = existing.userType;
+    const incoming_userType = incoming.userType;
+    if (!(existing_userType === incoming_userType)) {
+        return false;
+    }
+    const existing_additionalLabel = existing.additionalLabel;
+    const incoming_additionalLabel = incoming.additionalLabel;
+    if (!(existing_additionalLabel === incoming_additionalLabel)) {
+        return false;
+    }
+    const existing_motif = existing.motif;
+    const incoming_motif = incoming.motif;
+    if (!(equals$9(existing_motif, incoming_motif))) {
+        return false;
+    }
+    const existing_mySubscription = existing.mySubscription;
+    const incoming_mySubscription = incoming.mySubscription;
+    if (!(existing_mySubscription === incoming_mySubscription
+        || (existing_mySubscription != null &&
+            incoming_mySubscription != null &&
+            equals$j(existing_mySubscription, incoming_mySubscription)))) {
+        return false;
+    }
+    const existing_outOfOffice = existing.outOfOffice;
+    const incoming_outOfOffice = incoming.outOfOffice;
+    if (!(equals$8(existing_outOfOffice, incoming_outOfOffice))) {
+        return false;
+    }
+    const existing_photo = existing.photo;
+    const incoming_photo = incoming.photo;
+    if (!(equals$7(existing_photo, incoming_photo))) {
+        return false;
+    }
+    const existing_reputation = existing.reputation;
+    const incoming_reputation = incoming.reputation;
+    if (!(existing_reputation === incoming_reputation
+        || (existing_reputation != null &&
+            incoming_reputation != null &&
+            equals$5(existing_reputation, incoming_reputation)))) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$3 = "2ec7dbb6937db8bdecf67aaf4acfef8a";
+function validate$3(obj, path = 'TopicImagesRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_coverImageUrl = obj.coverImageUrl;
+        const path_coverImageUrl = path + '.coverImageUrl';
+        if (typeof obj_coverImageUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_coverImageUrl + '" (at "' + path_coverImageUrl + '")');
+        }
+        const obj_featuredImageUrl = obj.featuredImageUrl;
+        const path_featuredImageUrl = path + '.featuredImageUrl';
+        if (typeof obj_featuredImageUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_featuredImageUrl + '" (at "' + path_featuredImageUrl + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$4 = function TopicImagesRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'coverImageUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'featuredImageUrl',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_coverImageUrl = existing.coverImageUrl;
+    const incoming_coverImageUrl = incoming.coverImageUrl;
+    if (!(existing_coverImageUrl === incoming_coverImageUrl)) {
+        return false;
+    }
+    const existing_featuredImageUrl = existing.featuredImageUrl;
+    const incoming_featuredImageUrl = incoming.featuredImageUrl;
+    if (!(existing_featuredImageUrl === incoming_featuredImageUrl)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$2 = "626ba3f153e360df401492195cb56f42";
+function validate$2(obj, path = 'TopicRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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 + '")');
+        }
+        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 + '")');
+        }
+        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_images = obj.images;
+        const path_images = path + '.images';
+        const referencepath_imagesValidationError = validate$3(obj_images, path_images);
+        if (referencepath_imagesValidationError !== null) {
+            let message = 'Object doesn\'t match TopicImagesRepresentation (at "' + path_images + '")\n';
+            message += referencepath_imagesValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_isBeingDeleted = obj.isBeingDeleted;
+        const path_isBeingDeleted = path + '.isBeingDeleted';
+        if (typeof obj_isBeingDeleted !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isBeingDeleted + '" (at "' + path_isBeingDeleted + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_nonLocalizedName = obj.nonLocalizedName;
+        const path_nonLocalizedName = path + '.nonLocalizedName';
+        if (typeof obj_nonLocalizedName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_nonLocalizedName + '" (at "' + path_nonLocalizedName + '")');
+        }
+        const obj_talkingAbout = obj.talkingAbout;
+        const path_talkingAbout = path + '.talkingAbout';
+        if (typeof obj_talkingAbout !== 'number' || (typeof obj_talkingAbout === 'number' && Math.floor(obj_talkingAbout) !== obj_talkingAbout)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_talkingAbout + '" (at "' + path_talkingAbout + '")');
+        }
+        const obj_url = obj.url;
+        const path_url = path + '.url';
+        if (typeof obj_url !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$3 = function TopicRepresentationSelect() {
+    const { selections: TopicImagesRepresentation__selections, opaque: TopicImagesRepresentation__opaque, } = select$4();
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'createdDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'images',
+                kind: 'Object',
+                selections: TopicImagesRepresentation__selections
+            },
+            {
+                name: 'isBeingDeleted',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'nonLocalizedName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'talkingAbout',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_isBeingDeleted = existing.isBeingDeleted;
+    const incoming_isBeingDeleted = incoming.isBeingDeleted;
+    if (!(existing_isBeingDeleted === incoming_isBeingDeleted)) {
+        return false;
+    }
+    const existing_talkingAbout = existing.talkingAbout;
+    const incoming_talkingAbout = incoming.talkingAbout;
+    if (!(existing_talkingAbout === incoming_talkingAbout)) {
+        return false;
+    }
+    const existing_createdDate = existing.createdDate;
+    const incoming_createdDate = incoming.createdDate;
+    if (!(existing_createdDate === incoming_createdDate)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_nonLocalizedName = existing.nonLocalizedName;
+    const incoming_nonLocalizedName = incoming.nonLocalizedName;
+    if (!(existing_nonLocalizedName === incoming_nonLocalizedName)) {
+        return false;
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    const existing_images = existing.images;
+    const incoming_images = incoming.images;
+    if (!(equals$3(existing_images, incoming_images))) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$1 = "c049f45670ae38f19bfc0c1ee3406cb7";
+function validate$1(obj, path = 'TopicCollectionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_currentPageUrl = obj.currentPageUrl;
+        const path_currentPageUrl = path + '.currentPageUrl';
+        let obj_currentPageUrl_union0 = null;
+        const obj_currentPageUrl_union0_error = (() => {
+            if (typeof obj_currentPageUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_currentPageUrl + '" (at "' + path_currentPageUrl + '")');
+            }
+        })();
+        if (obj_currentPageUrl_union0_error != null) {
+            obj_currentPageUrl_union0 = obj_currentPageUrl_union0_error.message;
+        }
+        let obj_currentPageUrl_union1 = null;
+        const obj_currentPageUrl_union1_error = (() => {
+            if (obj_currentPageUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_currentPageUrl + '" (at "' + path_currentPageUrl + '")');
+            }
+        })();
+        if (obj_currentPageUrl_union1_error != null) {
+            obj_currentPageUrl_union1 = obj_currentPageUrl_union1_error.message;
+        }
+        if (obj_currentPageUrl_union0 && obj_currentPageUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_currentPageUrl + '")';
+            message += '\n' + obj_currentPageUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_currentPageUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_nextPageUrl = obj.nextPageUrl;
+        const path_nextPageUrl = path + '.nextPageUrl';
+        let obj_nextPageUrl_union0 = null;
+        const obj_nextPageUrl_union0_error = (() => {
+            if (typeof obj_nextPageUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_nextPageUrl + '" (at "' + path_nextPageUrl + '")');
+            }
+        })();
+        if (obj_nextPageUrl_union0_error != null) {
+            obj_nextPageUrl_union0 = obj_nextPageUrl_union0_error.message;
+        }
+        let obj_nextPageUrl_union1 = null;
+        const obj_nextPageUrl_union1_error = (() => {
+            if (obj_nextPageUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_nextPageUrl + '" (at "' + path_nextPageUrl + '")');
+            }
+        })();
+        if (obj_nextPageUrl_union1_error != null) {
+            obj_nextPageUrl_union1 = obj_nextPageUrl_union1_error.message;
+        }
+        if (obj_nextPageUrl_union0 && obj_nextPageUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_nextPageUrl + '")';
+            message += '\n' + obj_nextPageUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_nextPageUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_topics = obj.topics;
+        const path_topics = path + '.topics';
+        if (!ArrayIsArray(obj_topics)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_topics + '" (at "' + path_topics + '")');
+        }
+        for (let i = 0; i < obj_topics.length; i++) {
+            const obj_topics_item = obj_topics[i];
+            const path_topics_item = path_topics + '[' + i + ']';
+            let obj_topics_item_union0 = null;
+            const obj_topics_item_union0_error = (() => {
+                const referencepath_topics_itemValidationError = validate$2(obj_topics_item, path_topics_item);
+                if (referencepath_topics_itemValidationError !== null) {
+                    let message = 'Object doesn\'t match TopicRepresentation (at "' + path_topics_item + '")\n';
+                    message += referencepath_topics_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                    return new TypeError(message);
+                }
+            })();
+            if (obj_topics_item_union0_error != null) {
+                obj_topics_item_union0 = obj_topics_item_union0_error.message;
+            }
+            let obj_topics_item_union1 = null;
+            const obj_topics_item_union1_error = (() => {
+                if (obj_topics_item !== null) {
+                    return new TypeError('Expected "null" but received "' + typeof obj_topics_item + '" (at "' + path_topics_item + '")');
+                }
+            })();
+            if (obj_topics_item_union1_error != null) {
+                obj_topics_item_union1 = obj_topics_item_union1_error.message;
+            }
+            if (obj_topics_item_union0 && obj_topics_item_union1) {
+                let message = 'Object doesn\'t match union (at "' + path_topics_item + '")';
+                message += '\n' + obj_topics_item_union0.split('\n').map((line) => '\t' + line).join('\n');
+                message += '\n' + obj_topics_item_union1.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$2 = function TopicCollectionRepresentationSelect() {
+    const { selections: TopicRepresentation__selections, opaque: TopicRepresentation__opaque, } = select$3();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'currentPageUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'nextPageUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'topics',
+                kind: 'Object',
+                nullable: true,
+                plural: true,
+                selections: TopicRepresentation__selections
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_currentPageUrl = existing.currentPageUrl;
+    const incoming_currentPageUrl = incoming.currentPageUrl;
+    if (!(existing_currentPageUrl === incoming_currentPageUrl)) {
+        return false;
+    }
+    const existing_nextPageUrl = existing.nextPageUrl;
+    const incoming_nextPageUrl = incoming.nextPageUrl;
+    if (!(existing_nextPageUrl === incoming_nextPageUrl)) {
+        return false;
+    }
+    const existing_topics = existing.topics;
+    const incoming_topics = incoming.topics;
+    const equals_topics_items = equalsArray(existing_topics, incoming_topics, (existing_topics_item, incoming_topics_item) => {
+        if (!(existing_topics_item === incoming_topics_item
+            || (existing_topics_item != null &&
+                incoming_topics_item != null &&
+                equals$2(existing_topics_item, incoming_topics_item)))) {
+            return false;
+        }
+    });
+    if (equals_topics_items === false) {
+        return false;
+    }
+    return true;
+}
+
+const TTL = 100;
+const VERSION = "472a1bdc1617b702fa962cd73dd73eee";
+function validate(obj, path = 'FileDetailRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_checksum = obj.checksum;
+        const path_checksum = path + '.checksum';
+        let obj_checksum_union0 = null;
+        const obj_checksum_union0_error = (() => {
+            if (typeof obj_checksum !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_checksum + '" (at "' + path_checksum + '")');
+            }
+        })();
+        if (obj_checksum_union0_error != null) {
+            obj_checksum_union0 = obj_checksum_union0_error.message;
+        }
+        let obj_checksum_union1 = null;
+        const obj_checksum_union1_error = (() => {
+            if (obj_checksum !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_checksum + '" (at "' + path_checksum + '")');
+            }
+        })();
+        if (obj_checksum_union1_error != null) {
+            obj_checksum_union1 = obj_checksum_union1_error.message;
+        }
+        if (obj_checksum_union0 && obj_checksum_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_checksum + '")';
+            message += '\n' + obj_checksum_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_checksum_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_contentHubRepository = obj.contentHubRepository;
+        const path_contentHubRepository = path + '.contentHubRepository';
+        let obj_contentHubRepository_union0 = null;
+        const obj_contentHubRepository_union0_error = (() => {
+            const referencepath_contentHubRepositoryValidationError = validate$h(obj_contentHubRepository, path_contentHubRepository);
+            if (referencepath_contentHubRepositoryValidationError !== null) {
+                let message = 'Object doesn\'t match ContentHubRepositoryRepresentation (at "' + path_contentHubRepository + '")\n';
+                message += referencepath_contentHubRepositoryValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_contentHubRepository_union0_error != null) {
+            obj_contentHubRepository_union0 = obj_contentHubRepository_union0_error.message;
+        }
+        let obj_contentHubRepository_union1 = null;
+        const obj_contentHubRepository_union1_error = (() => {
+            if (obj_contentHubRepository !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_contentHubRepository + '" (at "' + path_contentHubRepository + '")');
+            }
+        })();
+        if (obj_contentHubRepository_union1_error != null) {
+            obj_contentHubRepository_union1 = obj_contentHubRepository_union1_error.message;
+        }
+        if (obj_contentHubRepository_union0 && obj_contentHubRepository_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_contentHubRepository + '")';
+            message += '\n' + obj_contentHubRepository_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_contentHubRepository_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_contentModifiedDate = obj.contentModifiedDate;
+        const path_contentModifiedDate = path + '.contentModifiedDate';
+        let obj_contentModifiedDate_union0 = null;
+        const obj_contentModifiedDate_union0_error = (() => {
+            if (typeof obj_contentModifiedDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contentModifiedDate + '" (at "' + path_contentModifiedDate + '")');
+            }
+        })();
+        if (obj_contentModifiedDate_union0_error != null) {
+            obj_contentModifiedDate_union0 = obj_contentModifiedDate_union0_error.message;
+        }
+        let obj_contentModifiedDate_union1 = null;
+        const obj_contentModifiedDate_union1_error = (() => {
+            if (obj_contentModifiedDate !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_contentModifiedDate + '" (at "' + path_contentModifiedDate + '")');
+            }
+        })();
+        if (obj_contentModifiedDate_union1_error != null) {
+            obj_contentModifiedDate_union1 = obj_contentModifiedDate_union1_error.message;
+        }
+        if (obj_contentModifiedDate_union0 && obj_contentModifiedDate_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_contentModifiedDate + '")';
+            message += '\n' + obj_contentModifiedDate_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_contentModifiedDate_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_contentSize = obj.contentSize;
+        const path_contentSize = path + '.contentSize';
+        let obj_contentSize_union0 = null;
+        const obj_contentSize_union0_error = (() => {
+            if (typeof obj_contentSize !== 'number' || (typeof obj_contentSize === 'number' && Math.floor(obj_contentSize) !== obj_contentSize)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_contentSize + '" (at "' + path_contentSize + '")');
+            }
+        })();
+        if (obj_contentSize_union0_error != null) {
+            obj_contentSize_union0 = obj_contentSize_union0_error.message;
+        }
+        let obj_contentSize_union1 = null;
+        const obj_contentSize_union1_error = (() => {
+            if (obj_contentSize !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_contentSize + '" (at "' + path_contentSize + '")');
+            }
+        })();
+        if (obj_contentSize_union1_error != null) {
+            obj_contentSize_union1 = obj_contentSize_union1_error.message;
+        }
+        if (obj_contentSize_union0 && obj_contentSize_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_contentSize + '")';
+            message += '\n' + obj_contentSize_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_contentSize_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_contentUrl = obj.contentUrl;
+        const path_contentUrl = path + '.contentUrl';
+        let obj_contentUrl_union0 = null;
+        const obj_contentUrl_union0_error = (() => {
+            if (typeof obj_contentUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contentUrl + '" (at "' + path_contentUrl + '")');
+            }
+        })();
+        if (obj_contentUrl_union0_error != null) {
+            obj_contentUrl_union0 = obj_contentUrl_union0_error.message;
+        }
+        let obj_contentUrl_union1 = null;
+        const obj_contentUrl_union1_error = (() => {
+            if (obj_contentUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_contentUrl + '" (at "' + path_contentUrl + '")');
+            }
+        })();
+        if (obj_contentUrl_union1_error != null) {
+            obj_contentUrl_union1 = obj_contentUrl_union1_error.message;
+        }
+        if (obj_contentUrl_union0 && obj_contentUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_contentUrl + '")';
+            message += '\n' + obj_contentUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_contentUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_contentVersionId = obj.contentVersionId;
+        const path_contentVersionId = path + '.contentVersionId';
+        let obj_contentVersionId_union0 = null;
+        const obj_contentVersionId_union0_error = (() => {
+            if (typeof obj_contentVersionId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_contentVersionId + '" (at "' + path_contentVersionId + '")');
+            }
+        })();
+        if (obj_contentVersionId_union0_error != null) {
+            obj_contentVersionId_union0 = obj_contentVersionId_union0_error.message;
+        }
+        let obj_contentVersionId_union1 = null;
+        const obj_contentVersionId_union1_error = (() => {
+            if (obj_contentVersionId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_contentVersionId + '" (at "' + path_contentVersionId + '")');
+            }
+        })();
+        if (obj_contentVersionId_union1_error != null) {
+            obj_contentVersionId_union1 = obj_contentVersionId_union1_error.message;
+        }
+        if (obj_contentVersionId_union0 && obj_contentVersionId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_contentVersionId + '")';
+            message += '\n' + obj_contentVersionId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_contentVersionId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_createdDate = obj.createdDate;
+        const path_createdDate = path + '.createdDate';
+        let obj_createdDate_union0 = null;
+        const obj_createdDate_union0_error = (() => {
+            if (typeof obj_createdDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+            }
+        })();
+        if (obj_createdDate_union0_error != null) {
+            obj_createdDate_union0 = obj_createdDate_union0_error.message;
+        }
+        let obj_createdDate_union1 = null;
+        const obj_createdDate_union1_error = (() => {
+            if (obj_createdDate !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+            }
+        })();
+        if (obj_createdDate_union1_error != null) {
+            obj_createdDate_union1 = obj_createdDate_union1_error.message;
+        }
+        if (obj_createdDate_union0 && obj_createdDate_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_createdDate + '")';
+            message += '\n' + obj_createdDate_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_createdDate_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        let obj_description_union0 = null;
+        const obj_description_union0_error = (() => {
+            if (typeof obj_description !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        })();
+        if (obj_description_union0_error != null) {
+            obj_description_union0 = obj_description_union0_error.message;
+        }
+        let obj_description_union1 = null;
+        const obj_description_union1_error = (() => {
+            if (obj_description !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+            }
+        })();
+        if (obj_description_union1_error != null) {
+            obj_description_union1 = obj_description_union1_error.message;
+        }
+        if (obj_description_union0 && obj_description_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_description + '")';
+            message += '\n' + obj_description_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_description_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_downloadUrl = obj.downloadUrl;
+        const path_downloadUrl = path + '.downloadUrl';
+        let obj_downloadUrl_union0 = null;
+        const obj_downloadUrl_union0_error = (() => {
+            if (typeof obj_downloadUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_downloadUrl + '" (at "' + path_downloadUrl + '")');
+            }
+        })();
+        if (obj_downloadUrl_union0_error != null) {
+            obj_downloadUrl_union0 = obj_downloadUrl_union0_error.message;
+        }
+        let obj_downloadUrl_union1 = null;
+        const obj_downloadUrl_union1_error = (() => {
+            if (obj_downloadUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_downloadUrl + '" (at "' + path_downloadUrl + '")');
+            }
+        })();
+        if (obj_downloadUrl_union1_error != null) {
+            obj_downloadUrl_union1 = obj_downloadUrl_union1_error.message;
+        }
+        if (obj_downloadUrl_union0 && obj_downloadUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_downloadUrl + '")';
+            message += '\n' + obj_downloadUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_downloadUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_externalDocumentUrl = obj.externalDocumentUrl;
+        const path_externalDocumentUrl = path + '.externalDocumentUrl';
+        let obj_externalDocumentUrl_union0 = null;
+        const obj_externalDocumentUrl_union0_error = (() => {
+            if (typeof obj_externalDocumentUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_externalDocumentUrl + '" (at "' + path_externalDocumentUrl + '")');
+            }
+        })();
+        if (obj_externalDocumentUrl_union0_error != null) {
+            obj_externalDocumentUrl_union0 = obj_externalDocumentUrl_union0_error.message;
+        }
+        let obj_externalDocumentUrl_union1 = null;
+        const obj_externalDocumentUrl_union1_error = (() => {
+            if (obj_externalDocumentUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_externalDocumentUrl + '" (at "' + path_externalDocumentUrl + '")');
+            }
+        })();
+        if (obj_externalDocumentUrl_union1_error != null) {
+            obj_externalDocumentUrl_union1 = obj_externalDocumentUrl_union1_error.message;
+        }
+        if (obj_externalDocumentUrl_union0 && obj_externalDocumentUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_externalDocumentUrl + '")';
+            message += '\n' + obj_externalDocumentUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_externalDocumentUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_externalFilePermissionInformation = obj.externalFilePermissionInformation;
+        const path_externalFilePermissionInformation = path + '.externalFilePermissionInformation';
+        let obj_externalFilePermissionInformation_union0 = null;
+        const obj_externalFilePermissionInformation_union0_error = (() => {
+            const referencepath_externalFilePermissionInformationValidationError = validate$e(obj_externalFilePermissionInformation, path_externalFilePermissionInformation);
+            if (referencepath_externalFilePermissionInformationValidationError !== null) {
+                let message = 'Object doesn\'t match ExternalFilePermissionInformationRepresentation (at "' + path_externalFilePermissionInformation + '")\n';
+                message += referencepath_externalFilePermissionInformationValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_externalFilePermissionInformation_union0_error != null) {
+            obj_externalFilePermissionInformation_union0 = obj_externalFilePermissionInformation_union0_error.message;
+        }
+        let obj_externalFilePermissionInformation_union1 = null;
+        const obj_externalFilePermissionInformation_union1_error = (() => {
+            if (obj_externalFilePermissionInformation !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_externalFilePermissionInformation + '" (at "' + path_externalFilePermissionInformation + '")');
+            }
+        })();
+        if (obj_externalFilePermissionInformation_union1_error != null) {
+            obj_externalFilePermissionInformation_union1 = obj_externalFilePermissionInformation_union1_error.message;
+        }
+        if (obj_externalFilePermissionInformation_union0 && obj_externalFilePermissionInformation_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_externalFilePermissionInformation + '")';
+            message += '\n' + obj_externalFilePermissionInformation_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_externalFilePermissionInformation_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_fileAsset = obj.fileAsset;
+        const path_fileAsset = path + '.fileAsset';
+        let obj_fileAsset_union0 = null;
+        const obj_fileAsset_union0_error = (() => {
+            const referencepath_fileAssetValidationError = validate$d(obj_fileAsset, path_fileAsset);
+            if (referencepath_fileAssetValidationError !== null) {
+                let message = 'Object doesn\'t match FileAssetRepresentation (at "' + path_fileAsset + '")\n';
+                message += referencepath_fileAssetValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_fileAsset_union0_error != null) {
+            obj_fileAsset_union0 = obj_fileAsset_union0_error.message;
+        }
+        let obj_fileAsset_union1 = null;
+        const obj_fileAsset_union1_error = (() => {
+            if (obj_fileAsset !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_fileAsset + '" (at "' + path_fileAsset + '")');
+            }
+        })();
+        if (obj_fileAsset_union1_error != null) {
+            obj_fileAsset_union1 = obj_fileAsset_union1_error.message;
+        }
+        if (obj_fileAsset_union0 && obj_fileAsset_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_fileAsset + '")';
+            message += '\n' + obj_fileAsset_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_fileAsset_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_fileExtension = obj.fileExtension;
+        const path_fileExtension = path + '.fileExtension';
+        let obj_fileExtension_union0 = null;
+        const obj_fileExtension_union0_error = (() => {
+            if (typeof obj_fileExtension !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fileExtension + '" (at "' + path_fileExtension + '")');
+            }
+        })();
+        if (obj_fileExtension_union0_error != null) {
+            obj_fileExtension_union0 = obj_fileExtension_union0_error.message;
+        }
+        let obj_fileExtension_union1 = null;
+        const obj_fileExtension_union1_error = (() => {
+            if (obj_fileExtension !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_fileExtension + '" (at "' + path_fileExtension + '")');
+            }
+        })();
+        if (obj_fileExtension_union1_error != null) {
+            obj_fileExtension_union1 = obj_fileExtension_union1_error.message;
+        }
+        if (obj_fileExtension_union0 && obj_fileExtension_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_fileExtension + '")';
+            message += '\n' + obj_fileExtension_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_fileExtension_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_fileType = obj.fileType;
+        const path_fileType = path + '.fileType';
+        let obj_fileType_union0 = null;
+        const obj_fileType_union0_error = (() => {
+            if (typeof obj_fileType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_fileType + '" (at "' + path_fileType + '")');
+            }
+        })();
+        if (obj_fileType_union0_error != null) {
+            obj_fileType_union0 = obj_fileType_union0_error.message;
+        }
+        let obj_fileType_union1 = null;
+        const obj_fileType_union1_error = (() => {
+            if (obj_fileType !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_fileType + '" (at "' + path_fileType + '")');
+            }
+        })();
+        if (obj_fileType_union1_error != null) {
+            obj_fileType_union1 = obj_fileType_union1_error.message;
+        }
+        if (obj_fileType_union0 && obj_fileType_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_fileType + '")';
+            message += '\n' + obj_fileType_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_fileType_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_flashRenditionStatus = obj.flashRenditionStatus;
+        const path_flashRenditionStatus = path + '.flashRenditionStatus';
+        let obj_flashRenditionStatus_union0 = null;
+        const obj_flashRenditionStatus_union0_error = (() => {
+            if (typeof obj_flashRenditionStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_flashRenditionStatus + '" (at "' + path_flashRenditionStatus + '")');
+            }
+        })();
+        if (obj_flashRenditionStatus_union0_error != null) {
+            obj_flashRenditionStatus_union0 = obj_flashRenditionStatus_union0_error.message;
+        }
+        let obj_flashRenditionStatus_union1 = null;
+        const obj_flashRenditionStatus_union1_error = (() => {
+            if (obj_flashRenditionStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_flashRenditionStatus + '" (at "' + path_flashRenditionStatus + '")');
+            }
+        })();
+        if (obj_flashRenditionStatus_union1_error != null) {
+            obj_flashRenditionStatus_union1 = obj_flashRenditionStatus_union1_error.message;
+        }
+        if (obj_flashRenditionStatus_union0 && obj_flashRenditionStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_flashRenditionStatus + '")';
+            message += '\n' + obj_flashRenditionStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_flashRenditionStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        let obj_id_union0 = null;
+        const obj_id_union0_error = (() => {
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        })();
+        if (obj_id_union0_error != null) {
+            obj_id_union0 = obj_id_union0_error.message;
+        }
+        let obj_id_union1 = null;
+        const obj_id_union1_error = (() => {
+            if (obj_id !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        })();
+        if (obj_id_union1_error != null) {
+            obj_id_union1 = obj_id_union1_error.message;
+        }
+        if (obj_id_union0 && obj_id_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_id + '")';
+            message += '\n' + obj_id_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_id_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_isFileAsset = obj.isFileAsset;
+        const path_isFileAsset = path + '.isFileAsset';
+        let obj_isFileAsset_union0 = null;
+        const obj_isFileAsset_union0_error = (() => {
+            if (typeof obj_isFileAsset !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isFileAsset + '" (at "' + path_isFileAsset + '")');
+            }
+        })();
+        if (obj_isFileAsset_union0_error != null) {
+            obj_isFileAsset_union0 = obj_isFileAsset_union0_error.message;
+        }
+        let obj_isFileAsset_union1 = null;
+        const obj_isFileAsset_union1_error = (() => {
+            if (obj_isFileAsset !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_isFileAsset + '" (at "' + path_isFileAsset + '")');
+            }
+        })();
+        if (obj_isFileAsset_union1_error != null) {
+            obj_isFileAsset_union1 = obj_isFileAsset_union1_error.message;
+        }
+        if (obj_isFileAsset_union0 && obj_isFileAsset_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_isFileAsset + '")';
+            message += '\n' + obj_isFileAsset_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_isFileAsset_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_isInMyFileSync = obj.isInMyFileSync;
+        const path_isInMyFileSync = path + '.isInMyFileSync';
+        let obj_isInMyFileSync_union0 = null;
+        const obj_isInMyFileSync_union0_error = (() => {
+            if (typeof obj_isInMyFileSync !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isInMyFileSync + '" (at "' + path_isInMyFileSync + '")');
+            }
+        })();
+        if (obj_isInMyFileSync_union0_error != null) {
+            obj_isInMyFileSync_union0 = obj_isInMyFileSync_union0_error.message;
+        }
+        let obj_isInMyFileSync_union1 = null;
+        const obj_isInMyFileSync_union1_error = (() => {
+            if (obj_isInMyFileSync !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_isInMyFileSync + '" (at "' + path_isInMyFileSync + '")');
+            }
+        })();
+        if (obj_isInMyFileSync_union1_error != null) {
+            obj_isInMyFileSync_union1 = obj_isInMyFileSync_union1_error.message;
+        }
+        if (obj_isInMyFileSync_union0 && obj_isInMyFileSync_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_isInMyFileSync + '")';
+            message += '\n' + obj_isInMyFileSync_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_isInMyFileSync_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_isMajorVersion = obj.isMajorVersion;
+        const path_isMajorVersion = path + '.isMajorVersion';
+        let obj_isMajorVersion_union0 = null;
+        const obj_isMajorVersion_union0_error = (() => {
+            if (typeof obj_isMajorVersion !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isMajorVersion + '" (at "' + path_isMajorVersion + '")');
+            }
+        })();
+        if (obj_isMajorVersion_union0_error != null) {
+            obj_isMajorVersion_union0 = obj_isMajorVersion_union0_error.message;
+        }
+        let obj_isMajorVersion_union1 = null;
+        const obj_isMajorVersion_union1_error = (() => {
+            if (obj_isMajorVersion !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_isMajorVersion + '" (at "' + path_isMajorVersion + '")');
+            }
+        })();
+        if (obj_isMajorVersion_union1_error != null) {
+            obj_isMajorVersion_union1 = obj_isMajorVersion_union1_error.message;
+        }
+        if (obj_isMajorVersion_union0 && obj_isMajorVersion_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_isMajorVersion + '")';
+            message += '\n' + obj_isMajorVersion_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_isMajorVersion_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_mimeType = obj.mimeType;
+        const path_mimeType = path + '.mimeType';
+        let obj_mimeType_union0 = null;
+        const obj_mimeType_union0_error = (() => {
+            if (typeof obj_mimeType !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_mimeType + '" (at "' + path_mimeType + '")');
+            }
+        })();
+        if (obj_mimeType_union0_error != null) {
+            obj_mimeType_union0 = obj_mimeType_union0_error.message;
+        }
+        let obj_mimeType_union1 = null;
+        const obj_mimeType_union1_error = (() => {
+            if (obj_mimeType !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_mimeType + '" (at "' + path_mimeType + '")');
+            }
+        })();
+        if (obj_mimeType_union1_error != null) {
+            obj_mimeType_union1 = obj_mimeType_union1_error.message;
+        }
+        if (obj_mimeType_union0 && obj_mimeType_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_mimeType + '")';
+            message += '\n' + obj_mimeType_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_mimeType_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_moderationFlags = obj.moderationFlags;
+        const path_moderationFlags = path + '.moderationFlags';
+        let obj_moderationFlags_union0 = null;
+        const obj_moderationFlags_union0_error = (() => {
+            const referencepath_moderationFlagsValidationError = validate$a(obj_moderationFlags, path_moderationFlags);
+            if (referencepath_moderationFlagsValidationError !== null) {
+                let message = 'Object doesn\'t match ModerationFlagsRepresentation (at "' + path_moderationFlags + '")\n';
+                message += referencepath_moderationFlagsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_moderationFlags_union0_error != null) {
+            obj_moderationFlags_union0 = obj_moderationFlags_union0_error.message;
+        }
+        let obj_moderationFlags_union1 = null;
+        const obj_moderationFlags_union1_error = (() => {
+            if (obj_moderationFlags !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_moderationFlags + '" (at "' + path_moderationFlags + '")');
+            }
+        })();
+        if (obj_moderationFlags_union1_error != null) {
+            obj_moderationFlags_union1 = obj_moderationFlags_union1_error.message;
+        }
+        if (obj_moderationFlags_union0 && obj_moderationFlags_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_moderationFlags + '")';
+            message += '\n' + obj_moderationFlags_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_moderationFlags_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_modifiedDate = obj.modifiedDate;
+        const path_modifiedDate = path + '.modifiedDate';
+        let obj_modifiedDate_union0 = null;
+        const obj_modifiedDate_union0_error = (() => {
+            if (typeof obj_modifiedDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_modifiedDate + '" (at "' + path_modifiedDate + '")');
+            }
+        })();
+        if (obj_modifiedDate_union0_error != null) {
+            obj_modifiedDate_union0 = obj_modifiedDate_union0_error.message;
+        }
+        let obj_modifiedDate_union1 = null;
+        const obj_modifiedDate_union1_error = (() => {
+            if (obj_modifiedDate !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_modifiedDate + '" (at "' + path_modifiedDate + '")');
+            }
+        })();
+        if (obj_modifiedDate_union1_error != null) {
+            obj_modifiedDate_union1 = obj_modifiedDate_union1_error.message;
+        }
+        if (obj_modifiedDate_union0 && obj_modifiedDate_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_modifiedDate + '")';
+            message += '\n' + obj_modifiedDate_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_modifiedDate_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_motif = obj.motif;
+        const path_motif = path + '.motif';
+        let obj_motif_union0 = null;
+        const obj_motif_union0_error = (() => {
+            const referencepath_motifValidationError = validate$9(obj_motif, path_motif);
+            if (referencepath_motifValidationError !== null) {
+                let message = 'Object doesn\'t match MotifRepresentation (at "' + path_motif + '")\n';
+                message += referencepath_motifValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_motif_union0_error != null) {
+            obj_motif_union0 = obj_motif_union0_error.message;
+        }
+        let obj_motif_union1 = null;
+        const obj_motif_union1_error = (() => {
+            if (obj_motif !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_motif + '" (at "' + path_motif + '")');
+            }
+        })();
+        if (obj_motif_union1_error != null) {
+            obj_motif_union1 = obj_motif_union1_error.message;
+        }
+        if (obj_motif_union0 && obj_motif_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_motif + '")';
+            message += '\n' + obj_motif_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_motif_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_mySubscription = obj.mySubscription;
+        const path_mySubscription = path + '.mySubscription';
+        let obj_mySubscription_union0 = null;
+        const obj_mySubscription_union0_error = (() => {
+            const referencepath_mySubscriptionValidationError = validate$j(obj_mySubscription, path_mySubscription);
+            if (referencepath_mySubscriptionValidationError !== null) {
+                let message = 'Object doesn\'t match ReferenceRepresentation (at "' + path_mySubscription + '")\n';
+                message += referencepath_mySubscriptionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_mySubscription_union0_error != null) {
+            obj_mySubscription_union0 = obj_mySubscription_union0_error.message;
+        }
+        let obj_mySubscription_union1 = null;
+        const obj_mySubscription_union1_error = (() => {
+            if (obj_mySubscription !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_mySubscription + '" (at "' + path_mySubscription + '")');
+            }
+        })();
+        if (obj_mySubscription_union1_error != null) {
+            obj_mySubscription_union1 = obj_mySubscription_union1_error.message;
+        }
+        if (obj_mySubscription_union0 && obj_mySubscription_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_mySubscription + '")';
+            message += '\n' + obj_mySubscription_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_mySubscription_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        let obj_name_union0 = null;
+        const obj_name_union0_error = (() => {
+            if (typeof obj_name !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+            }
+        })();
+        if (obj_name_union0_error != null) {
+            obj_name_union0 = obj_name_union0_error.message;
+        }
+        let obj_name_union1 = null;
+        const obj_name_union1_error = (() => {
+            if (obj_name !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+            }
+        })();
+        if (obj_name_union1_error != null) {
+            obj_name_union1 = obj_name_union1_error.message;
+        }
+        if (obj_name_union0 && obj_name_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_name + '")';
+            message += '\n' + obj_name_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_name_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_origin = obj.origin;
+        const path_origin = path + '.origin';
+        let obj_origin_union0 = null;
+        const obj_origin_union0_error = (() => {
+            if (typeof obj_origin !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_origin + '" (at "' + path_origin + '")');
+            }
+        })();
+        if (obj_origin_union0_error != null) {
+            obj_origin_union0 = obj_origin_union0_error.message;
+        }
+        let obj_origin_union1 = null;
+        const obj_origin_union1_error = (() => {
+            if (obj_origin !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_origin + '" (at "' + path_origin + '")');
+            }
+        })();
+        if (obj_origin_union1_error != null) {
+            obj_origin_union1 = obj_origin_union1_error.message;
+        }
+        if (obj_origin_union0 && obj_origin_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_origin + '")';
+            message += '\n' + obj_origin_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_origin_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_owner = obj.owner;
+        const path_owner = path + '.owner';
+        let obj_owner_union0 = null;
+        const obj_owner_union0_error = (() => {
+            const referencepath_ownerValidationError = validate$4(obj_owner, path_owner);
+            if (referencepath_ownerValidationError !== null) {
+                let message = 'Object doesn\'t match UserSummaryRepresentation (at "' + path_owner + '")\n';
+                message += referencepath_ownerValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_owner_union0_error != null) {
+            obj_owner_union0 = obj_owner_union0_error.message;
+        }
+        let obj_owner_union1 = null;
+        const obj_owner_union1_error = (() => {
+            if (obj_owner !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_owner + '" (at "' + path_owner + '")');
+            }
+        })();
+        if (obj_owner_union1_error != null) {
+            obj_owner_union1 = obj_owner_union1_error.message;
+        }
+        if (obj_owner_union0 && obj_owner_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_owner + '")';
+            message += '\n' + obj_owner_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_owner_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_pageCount = obj.pageCount;
+        const path_pageCount = path + '.pageCount';
+        let obj_pageCount_union0 = null;
+        const obj_pageCount_union0_error = (() => {
+            if (typeof obj_pageCount !== 'number' || (typeof obj_pageCount === 'number' && Math.floor(obj_pageCount) !== obj_pageCount)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_pageCount + '" (at "' + path_pageCount + '")');
+            }
+        })();
+        if (obj_pageCount_union0_error != null) {
+            obj_pageCount_union0 = obj_pageCount_union0_error.message;
+        }
+        let obj_pageCount_union1 = null;
+        const obj_pageCount_union1_error = (() => {
+            if (obj_pageCount !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_pageCount + '" (at "' + path_pageCount + '")');
+            }
+        })();
+        if (obj_pageCount_union1_error != null) {
+            obj_pageCount_union1 = obj_pageCount_union1_error.message;
+        }
+        if (obj_pageCount_union0 && obj_pageCount_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_pageCount + '")';
+            message += '\n' + obj_pageCount_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_pageCount_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_parentFolder = obj.parentFolder;
+        const path_parentFolder = path + '.parentFolder';
+        let obj_parentFolder_union0 = null;
+        const obj_parentFolder_union0_error = (() => {
+            const referencepath_parentFolderValidationError = validate$j(obj_parentFolder, path_parentFolder);
+            if (referencepath_parentFolderValidationError !== null) {
+                let message = 'Object doesn\'t match ReferenceRepresentation (at "' + path_parentFolder + '")\n';
+                message += referencepath_parentFolderValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_parentFolder_union0_error != null) {
+            obj_parentFolder_union0 = obj_parentFolder_union0_error.message;
+        }
+        let obj_parentFolder_union1 = null;
+        const obj_parentFolder_union1_error = (() => {
+            if (obj_parentFolder !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_parentFolder + '" (at "' + path_parentFolder + '")');
+            }
+        })();
+        if (obj_parentFolder_union1_error != null) {
+            obj_parentFolder_union1 = obj_parentFolder_union1_error.message;
+        }
+        if (obj_parentFolder_union0 && obj_parentFolder_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_parentFolder + '")';
+            message += '\n' + obj_parentFolder_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_parentFolder_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_pdfRenditionStatus = obj.pdfRenditionStatus;
+        const path_pdfRenditionStatus = path + '.pdfRenditionStatus';
+        let obj_pdfRenditionStatus_union0 = null;
+        const obj_pdfRenditionStatus_union0_error = (() => {
+            if (typeof obj_pdfRenditionStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_pdfRenditionStatus + '" (at "' + path_pdfRenditionStatus + '")');
+            }
+        })();
+        if (obj_pdfRenditionStatus_union0_error != null) {
+            obj_pdfRenditionStatus_union0 = obj_pdfRenditionStatus_union0_error.message;
+        }
+        let obj_pdfRenditionStatus_union1 = null;
+        const obj_pdfRenditionStatus_union1_error = (() => {
+            if (obj_pdfRenditionStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_pdfRenditionStatus + '" (at "' + path_pdfRenditionStatus + '")');
+            }
+        })();
+        if (obj_pdfRenditionStatus_union1_error != null) {
+            obj_pdfRenditionStatus_union1 = obj_pdfRenditionStatus_union1_error.message;
+        }
+        if (obj_pdfRenditionStatus_union0 && obj_pdfRenditionStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_pdfRenditionStatus + '")';
+            message += '\n' + obj_pdfRenditionStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_pdfRenditionStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_publishStatus = obj.publishStatus;
+        const path_publishStatus = path + '.publishStatus';
+        let obj_publishStatus_union0 = null;
+        const obj_publishStatus_union0_error = (() => {
+            if (typeof obj_publishStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_publishStatus + '" (at "' + path_publishStatus + '")');
+            }
+        })();
+        if (obj_publishStatus_union0_error != null) {
+            obj_publishStatus_union0 = obj_publishStatus_union0_error.message;
+        }
+        let obj_publishStatus_union1 = null;
+        const obj_publishStatus_union1_error = (() => {
+            if (obj_publishStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_publishStatus + '" (at "' + path_publishStatus + '")');
+            }
+        })();
+        if (obj_publishStatus_union1_error != null) {
+            obj_publishStatus_union1 = obj_publishStatus_union1_error.message;
+        }
+        if (obj_publishStatus_union0 && obj_publishStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_publishStatus + '")';
+            message += '\n' + obj_publishStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_publishStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_renditionUrl = obj.renditionUrl;
+        const path_renditionUrl = path + '.renditionUrl';
+        let obj_renditionUrl_union0 = null;
+        const obj_renditionUrl_union0_error = (() => {
+            if (typeof obj_renditionUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_renditionUrl + '" (at "' + path_renditionUrl + '")');
+            }
+        })();
+        if (obj_renditionUrl_union0_error != null) {
+            obj_renditionUrl_union0 = obj_renditionUrl_union0_error.message;
+        }
+        let obj_renditionUrl_union1 = null;
+        const obj_renditionUrl_union1_error = (() => {
+            if (obj_renditionUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_renditionUrl + '" (at "' + path_renditionUrl + '")');
+            }
+        })();
+        if (obj_renditionUrl_union1_error != null) {
+            obj_renditionUrl_union1 = obj_renditionUrl_union1_error.message;
+        }
+        if (obj_renditionUrl_union0 && obj_renditionUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_renditionUrl + '")';
+            message += '\n' + obj_renditionUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_renditionUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_renditionUrl240By180 = obj.renditionUrl240By180;
+        const path_renditionUrl240By180 = path + '.renditionUrl240By180';
+        let obj_renditionUrl240By180_union0 = null;
+        const obj_renditionUrl240By180_union0_error = (() => {
+            if (typeof obj_renditionUrl240By180 !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_renditionUrl240By180 + '" (at "' + path_renditionUrl240By180 + '")');
+            }
+        })();
+        if (obj_renditionUrl240By180_union0_error != null) {
+            obj_renditionUrl240By180_union0 = obj_renditionUrl240By180_union0_error.message;
+        }
+        let obj_renditionUrl240By180_union1 = null;
+        const obj_renditionUrl240By180_union1_error = (() => {
+            if (obj_renditionUrl240By180 !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_renditionUrl240By180 + '" (at "' + path_renditionUrl240By180 + '")');
+            }
+        })();
+        if (obj_renditionUrl240By180_union1_error != null) {
+            obj_renditionUrl240By180_union1 = obj_renditionUrl240By180_union1_error.message;
+        }
+        if (obj_renditionUrl240By180_union0 && obj_renditionUrl240By180_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_renditionUrl240By180 + '")';
+            message += '\n' + obj_renditionUrl240By180_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_renditionUrl240By180_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_renditionUrl720By480 = obj.renditionUrl720By480;
+        const path_renditionUrl720By480 = path + '.renditionUrl720By480';
+        let obj_renditionUrl720By480_union0 = null;
+        const obj_renditionUrl720By480_union0_error = (() => {
+            if (typeof obj_renditionUrl720By480 !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_renditionUrl720By480 + '" (at "' + path_renditionUrl720By480 + '")');
+            }
+        })();
+        if (obj_renditionUrl720By480_union0_error != null) {
+            obj_renditionUrl720By480_union0 = obj_renditionUrl720By480_union0_error.message;
+        }
+        let obj_renditionUrl720By480_union1 = null;
+        const obj_renditionUrl720By480_union1_error = (() => {
+            if (obj_renditionUrl720By480 !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_renditionUrl720By480 + '" (at "' + path_renditionUrl720By480 + '")');
+            }
+        })();
+        if (obj_renditionUrl720By480_union1_error != null) {
+            obj_renditionUrl720By480_union1 = obj_renditionUrl720By480_union1_error.message;
+        }
+        if (obj_renditionUrl720By480_union0 && obj_renditionUrl720By480_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_renditionUrl720By480 + '")';
+            message += '\n' + obj_renditionUrl720By480_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_renditionUrl720By480_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_repositoryFileId = obj.repositoryFileId;
+        const path_repositoryFileId = path + '.repositoryFileId';
+        let obj_repositoryFileId_union0 = null;
+        const obj_repositoryFileId_union0_error = (() => {
+            if (typeof obj_repositoryFileId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_repositoryFileId + '" (at "' + path_repositoryFileId + '")');
+            }
+        })();
+        if (obj_repositoryFileId_union0_error != null) {
+            obj_repositoryFileId_union0 = obj_repositoryFileId_union0_error.message;
+        }
+        let obj_repositoryFileId_union1 = null;
+        const obj_repositoryFileId_union1_error = (() => {
+            if (obj_repositoryFileId !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_repositoryFileId + '" (at "' + path_repositoryFileId + '")');
+            }
+        })();
+        if (obj_repositoryFileId_union1_error != null) {
+            obj_repositoryFileId_union1 = obj_repositoryFileId_union1_error.message;
+        }
+        if (obj_repositoryFileId_union0 && obj_repositoryFileId_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_repositoryFileId + '")';
+            message += '\n' + obj_repositoryFileId_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_repositoryFileId_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_repositoryFileUrl = obj.repositoryFileUrl;
+        const path_repositoryFileUrl = path + '.repositoryFileUrl';
+        let obj_repositoryFileUrl_union0 = null;
+        const obj_repositoryFileUrl_union0_error = (() => {
+            if (typeof obj_repositoryFileUrl !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_repositoryFileUrl + '" (at "' + path_repositoryFileUrl + '")');
+            }
+        })();
+        if (obj_repositoryFileUrl_union0_error != null) {
+            obj_repositoryFileUrl_union0 = obj_repositoryFileUrl_union0_error.message;
+        }
+        let obj_repositoryFileUrl_union1 = null;
+        const obj_repositoryFileUrl_union1_error = (() => {
+            if (obj_repositoryFileUrl !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_repositoryFileUrl + '" (at "' + path_repositoryFileUrl + '")');
+            }
+        })();
+        if (obj_repositoryFileUrl_union1_error != null) {
+            obj_repositoryFileUrl_union1 = obj_repositoryFileUrl_union1_error.message;
+        }
+        if (obj_repositoryFileUrl_union0 && obj_repositoryFileUrl_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_repositoryFileUrl + '")';
+            message += '\n' + obj_repositoryFileUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_repositoryFileUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_sharingOption = obj.sharingOption;
+        const path_sharingOption = path + '.sharingOption';
+        let obj_sharingOption_union0 = null;
+        const obj_sharingOption_union0_error = (() => {
+            if (typeof obj_sharingOption !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sharingOption + '" (at "' + path_sharingOption + '")');
+            }
+        })();
+        if (obj_sharingOption_union0_error != null) {
+            obj_sharingOption_union0 = obj_sharingOption_union0_error.message;
+        }
+        let obj_sharingOption_union1 = null;
+        const obj_sharingOption_union1_error = (() => {
+            if (obj_sharingOption !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_sharingOption + '" (at "' + path_sharingOption + '")');
+            }
+        })();
+        if (obj_sharingOption_union1_error != null) {
+            obj_sharingOption_union1 = obj_sharingOption_union1_error.message;
+        }
+        if (obj_sharingOption_union0 && obj_sharingOption_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_sharingOption + '")';
+            message += '\n' + obj_sharingOption_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_sharingOption_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_sharingPrivacy = obj.sharingPrivacy;
+        const path_sharingPrivacy = path + '.sharingPrivacy';
+        let obj_sharingPrivacy_union0 = null;
+        const obj_sharingPrivacy_union0_error = (() => {
+            if (typeof obj_sharingPrivacy !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sharingPrivacy + '" (at "' + path_sharingPrivacy + '")');
+            }
+        })();
+        if (obj_sharingPrivacy_union0_error != null) {
+            obj_sharingPrivacy_union0 = obj_sharingPrivacy_union0_error.message;
+        }
+        let obj_sharingPrivacy_union1 = null;
+        const obj_sharingPrivacy_union1_error = (() => {
+            if (obj_sharingPrivacy !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_sharingPrivacy + '" (at "' + path_sharingPrivacy + '")');
+            }
+        })();
+        if (obj_sharingPrivacy_union1_error != null) {
+            obj_sharingPrivacy_union1 = obj_sharingPrivacy_union1_error.message;
+        }
+        if (obj_sharingPrivacy_union0 && obj_sharingPrivacy_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_sharingPrivacy + '")';
+            message += '\n' + obj_sharingPrivacy_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_sharingPrivacy_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_sharingRole = obj.sharingRole;
+        const path_sharingRole = path + '.sharingRole';
+        let obj_sharingRole_union0 = null;
+        const obj_sharingRole_union0_error = (() => {
+            if (typeof obj_sharingRole !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_sharingRole + '" (at "' + path_sharingRole + '")');
+            }
+        })();
+        if (obj_sharingRole_union0_error != null) {
+            obj_sharingRole_union0 = obj_sharingRole_union0_error.message;
+        }
+        let obj_sharingRole_union1 = null;
+        const obj_sharingRole_union1_error = (() => {
+            if (obj_sharingRole !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_sharingRole + '" (at "' + path_sharingRole + '")');
+            }
+        })();
+        if (obj_sharingRole_union1_error != null) {
+            obj_sharingRole_union1 = obj_sharingRole_union1_error.message;
+        }
+        if (obj_sharingRole_union0 && obj_sharingRole_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_sharingRole + '")';
+            message += '\n' + obj_sharingRole_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_sharingRole_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_systemModstamp = obj.systemModstamp;
+        const path_systemModstamp = path + '.systemModstamp';
+        let obj_systemModstamp_union0 = null;
+        const obj_systemModstamp_union0_error = (() => {
+            if (typeof obj_systemModstamp !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_systemModstamp + '" (at "' + path_systemModstamp + '")');
+            }
+        })();
+        if (obj_systemModstamp_union0_error != null) {
+            obj_systemModstamp_union0 = obj_systemModstamp_union0_error.message;
+        }
+        let obj_systemModstamp_union1 = null;
+        const obj_systemModstamp_union1_error = (() => {
+            if (obj_systemModstamp !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_systemModstamp + '" (at "' + path_systemModstamp + '")');
+            }
+        })();
+        if (obj_systemModstamp_union1_error != null) {
+            obj_systemModstamp_union1 = obj_systemModstamp_union1_error.message;
+        }
+        if (obj_systemModstamp_union0 && obj_systemModstamp_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_systemModstamp + '")';
+            message += '\n' + obj_systemModstamp_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_systemModstamp_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_textPreview = obj.textPreview;
+        const path_textPreview = path + '.textPreview';
+        let obj_textPreview_union0 = null;
+        const obj_textPreview_union0_error = (() => {
+            if (typeof obj_textPreview !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_textPreview + '" (at "' + path_textPreview + '")');
+            }
+        })();
+        if (obj_textPreview_union0_error != null) {
+            obj_textPreview_union0 = obj_textPreview_union0_error.message;
+        }
+        let obj_textPreview_union1 = null;
+        const obj_textPreview_union1_error = (() => {
+            if (obj_textPreview !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_textPreview + '" (at "' + path_textPreview + '")');
+            }
+        })();
+        if (obj_textPreview_union1_error != null) {
+            obj_textPreview_union1 = obj_textPreview_union1_error.message;
+        }
+        if (obj_textPreview_union0 && obj_textPreview_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_textPreview + '")';
+            message += '\n' + obj_textPreview_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_textPreview_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_thumb120By90RenditionStatus = obj.thumb120By90RenditionStatus;
+        const path_thumb120By90RenditionStatus = path + '.thumb120By90RenditionStatus';
+        let obj_thumb120By90RenditionStatus_union0 = null;
+        const obj_thumb120By90RenditionStatus_union0_error = (() => {
+            if (typeof obj_thumb120By90RenditionStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_thumb120By90RenditionStatus + '" (at "' + path_thumb120By90RenditionStatus + '")');
+            }
+        })();
+        if (obj_thumb120By90RenditionStatus_union0_error != null) {
+            obj_thumb120By90RenditionStatus_union0 = obj_thumb120By90RenditionStatus_union0_error.message;
+        }
+        let obj_thumb120By90RenditionStatus_union1 = null;
+        const obj_thumb120By90RenditionStatus_union1_error = (() => {
+            if (obj_thumb120By90RenditionStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_thumb120By90RenditionStatus + '" (at "' + path_thumb120By90RenditionStatus + '")');
+            }
+        })();
+        if (obj_thumb120By90RenditionStatus_union1_error != null) {
+            obj_thumb120By90RenditionStatus_union1 = obj_thumb120By90RenditionStatus_union1_error.message;
+        }
+        if (obj_thumb120By90RenditionStatus_union0 && obj_thumb120By90RenditionStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_thumb120By90RenditionStatus + '")';
+            message += '\n' + obj_thumb120By90RenditionStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_thumb120By90RenditionStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_thumb240By180RenditionStatus = obj.thumb240By180RenditionStatus;
+        const path_thumb240By180RenditionStatus = path + '.thumb240By180RenditionStatus';
+        let obj_thumb240By180RenditionStatus_union0 = null;
+        const obj_thumb240By180RenditionStatus_union0_error = (() => {
+            if (typeof obj_thumb240By180RenditionStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_thumb240By180RenditionStatus + '" (at "' + path_thumb240By180RenditionStatus + '")');
+            }
+        })();
+        if (obj_thumb240By180RenditionStatus_union0_error != null) {
+            obj_thumb240By180RenditionStatus_union0 = obj_thumb240By180RenditionStatus_union0_error.message;
+        }
+        let obj_thumb240By180RenditionStatus_union1 = null;
+        const obj_thumb240By180RenditionStatus_union1_error = (() => {
+            if (obj_thumb240By180RenditionStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_thumb240By180RenditionStatus + '" (at "' + path_thumb240By180RenditionStatus + '")');
+            }
+        })();
+        if (obj_thumb240By180RenditionStatus_union1_error != null) {
+            obj_thumb240By180RenditionStatus_union1 = obj_thumb240By180RenditionStatus_union1_error.message;
+        }
+        if (obj_thumb240By180RenditionStatus_union0 && obj_thumb240By180RenditionStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_thumb240By180RenditionStatus + '")';
+            message += '\n' + obj_thumb240By180RenditionStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_thumb240By180RenditionStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_thumb720By480RenditionStatus = obj.thumb720By480RenditionStatus;
+        const path_thumb720By480RenditionStatus = path + '.thumb720By480RenditionStatus';
+        let obj_thumb720By480RenditionStatus_union0 = null;
+        const obj_thumb720By480RenditionStatus_union0_error = (() => {
+            if (typeof obj_thumb720By480RenditionStatus !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_thumb720By480RenditionStatus + '" (at "' + path_thumb720By480RenditionStatus + '")');
+            }
+        })();
+        if (obj_thumb720By480RenditionStatus_union0_error != null) {
+            obj_thumb720By480RenditionStatus_union0 = obj_thumb720By480RenditionStatus_union0_error.message;
+        }
+        let obj_thumb720By480RenditionStatus_union1 = null;
+        const obj_thumb720By480RenditionStatus_union1_error = (() => {
+            if (obj_thumb720By480RenditionStatus !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_thumb720By480RenditionStatus + '" (at "' + path_thumb720By480RenditionStatus + '")');
+            }
+        })();
+        if (obj_thumb720By480RenditionStatus_union1_error != null) {
+            obj_thumb720By480RenditionStatus_union1 = obj_thumb720By480RenditionStatus_union1_error.message;
+        }
+        if (obj_thumb720By480RenditionStatus_union0 && obj_thumb720By480RenditionStatus_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_thumb720By480RenditionStatus + '")';
+            message += '\n' + obj_thumb720By480RenditionStatus_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_thumb720By480RenditionStatus_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_title = obj.title;
+        const path_title = path + '.title';
+        let obj_title_union0 = null;
+        const obj_title_union0_error = (() => {
+            if (typeof obj_title !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        if (obj_title_union0_error != null) {
+            obj_title_union0 = obj_title_union0_error.message;
+        }
+        let obj_title_union1 = null;
+        const obj_title_union1_error = (() => {
+            if (obj_title !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_title + '" (at "' + path_title + '")');
+            }
+        })();
+        if (obj_title_union1_error != null) {
+            obj_title_union1 = obj_title_union1_error.message;
+        }
+        if (obj_title_union0 && obj_title_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_title + '")';
+            message += '\n' + obj_title_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_title_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_topics = obj.topics;
+        const path_topics = path + '.topics';
+        let obj_topics_union0 = null;
+        const obj_topics_union0_error = (() => {
+            const referencepath_topicsValidationError = validate$1(obj_topics, path_topics);
+            if (referencepath_topicsValidationError !== null) {
+                let message = 'Object doesn\'t match TopicCollectionRepresentation (at "' + path_topics + '")\n';
+                message += referencepath_topicsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        })();
+        if (obj_topics_union0_error != null) {
+            obj_topics_union0 = obj_topics_union0_error.message;
+        }
+        let obj_topics_union1 = null;
+        const obj_topics_union1_error = (() => {
+            if (obj_topics !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_topics + '" (at "' + path_topics + '")');
+            }
+        })();
+        if (obj_topics_union1_error != null) {
+            obj_topics_union1 = obj_topics_union1_error.message;
+        }
+        if (obj_topics_union0 && obj_topics_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_topics + '")';
+            message += '\n' + obj_topics_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_topics_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_type = obj.type;
+        const path_type = path + '.type';
+        let obj_type_union0 = null;
+        const obj_type_union0_error = (() => {
+            if (typeof obj_type !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        })();
+        if (obj_type_union0_error != null) {
+            obj_type_union0 = obj_type_union0_error.message;
+        }
+        let obj_type_union1 = null;
+        const obj_type_union1_error = (() => {
+            if (obj_type !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_type + '" (at "' + path_type + '")');
+            }
+        })();
+        if (obj_type_union1_error != null) {
+            obj_type_union1 = obj_type_union1_error.message;
+        }
+        if (obj_type_union0 && obj_type_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_type + '")';
+            message += '\n' + obj_type_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_type_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_url = obj.url;
+        const path_url = path + '.url';
+        let obj_url_union0 = null;
+        const obj_url_union0_error = (() => {
+            if (typeof obj_url !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+            }
+        })();
+        if (obj_url_union0_error != null) {
+            obj_url_union0 = obj_url_union0_error.message;
+        }
+        let obj_url_union1 = null;
+        const obj_url_union1_error = (() => {
+            if (obj_url !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_url + '" (at "' + path_url + '")');
+            }
+        })();
+        if (obj_url_union1_error != null) {
+            obj_url_union1 = obj_url_union1_error.message;
+        }
+        if (obj_url_union0 && obj_url_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_url + '")';
+            message += '\n' + obj_url_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_url_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_versionNumber = obj.versionNumber;
+        const path_versionNumber = path + '.versionNumber';
+        let obj_versionNumber_union0 = null;
+        const obj_versionNumber_union0_error = (() => {
+            if (typeof obj_versionNumber !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+            }
+        })();
+        if (obj_versionNumber_union0_error != null) {
+            obj_versionNumber_union0 = obj_versionNumber_union0_error.message;
+        }
+        let obj_versionNumber_union1 = null;
+        const obj_versionNumber_union1_error = (() => {
+            if (obj_versionNumber !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_versionNumber + '" (at "' + path_versionNumber + '")');
+            }
+        })();
+        if (obj_versionNumber_union1_error != null) {
+            obj_versionNumber_union1 = obj_versionNumber_union1_error.message;
+        }
+        if (obj_versionNumber_union0 && obj_versionNumber_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_versionNumber + '")';
+            message += '\n' + obj_versionNumber_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_versionNumber_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'FileDetailRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + (config.id === null ? '' : config.id);
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function FileDetailRepresentationSelect() {
+    const { selections: ContentHubRepositoryRepresentation__selections, opaque: ContentHubRepositoryRepresentation__opaque, } = select$i();
+    const { selections: ExternalFilePermissionInformationRepresentation__selections, opaque: ExternalFilePermissionInformationRepresentation__opaque, } = select$f();
+    const { selections: FileAssetRepresentation__selections, opaque: FileAssetRepresentation__opaque, } = select$e();
+    const { selections: ModerationFlagsRepresentation__selections, opaque: ModerationFlagsRepresentation__opaque, } = select$b();
+    const { selections: MotifRepresentation__selections, opaque: MotifRepresentation__opaque, } = select$a();
+    const { selections: ReferenceRepresentation__selections, opaque: ReferenceRepresentation__opaque, } = select$k();
+    const { selections: UserSummaryRepresentation__selections, opaque: UserSummaryRepresentation__opaque, } = select$5();
+    const { selections: TopicCollectionRepresentation__selections, opaque: TopicCollectionRepresentation__opaque, } = select$2();
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'checksum',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contentHubRepository',
+                kind: 'Object',
+                nullable: true,
+                selections: ContentHubRepositoryRepresentation__selections
+            },
+            {
+                name: 'contentModifiedDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contentSize',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contentUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'contentVersionId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'createdDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'downloadUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'externalDocumentUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'externalFilePermissionInformation',
+                kind: 'Object',
+                nullable: true,
+                selections: ExternalFilePermissionInformationRepresentation__selections
+            },
+            {
+                name: 'fileAsset',
+                kind: 'Object',
+                nullable: true,
+                selections: FileAssetRepresentation__selections
+            },
+            {
+                name: 'fileExtension',
+                kind: 'Scalar'
+            },
+            {
+                name: 'fileType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'flashRenditionStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isFileAsset',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isInMyFileSync',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isMajorVersion',
+                kind: 'Scalar'
+            },
+            {
+                name: 'mimeType',
+                kind: 'Scalar'
+            },
+            {
+                name: 'moderationFlags',
+                kind: 'Object',
+                nullable: true,
+                selections: ModerationFlagsRepresentation__selections
+            },
+            {
+                name: 'modifiedDate',
+                kind: 'Scalar'
+            },
+            {
+                name: 'motif',
+                kind: 'Object',
+                nullable: true,
+                selections: MotifRepresentation__selections
+            },
+            {
+                name: 'mySubscription',
+                kind: 'Object',
+                nullable: true,
+                selections: ReferenceRepresentation__selections
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'origin',
+                kind: 'Scalar'
+            },
+            {
+                name: 'owner',
+                kind: 'Object',
+                nullable: true,
+                selections: UserSummaryRepresentation__selections
+            },
+            {
+                name: 'pageCount',
+                kind: 'Scalar'
+            },
+            {
+                name: 'parentFolder',
+                kind: 'Object',
+                nullable: true,
+                selections: ReferenceRepresentation__selections
+            },
+            {
+                name: 'pdfRenditionStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'publishStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'renditionUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'renditionUrl240By180',
+                kind: 'Scalar'
+            },
+            {
+                name: 'renditionUrl720By480',
+                kind: 'Scalar'
+            },
+            {
+                name: 'repositoryFileId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'repositoryFileUrl',
+                kind: 'Scalar'
+            },
+            {
+                name: 'sharingOption',
+                kind: 'Scalar'
+            },
+            {
+                name: 'sharingPrivacy',
+                kind: 'Scalar'
+            },
+            {
+                name: 'sharingRole',
+                kind: 'Scalar'
+            },
+            {
+                name: 'systemModstamp',
+                kind: 'Scalar'
+            },
+            {
+                name: 'textPreview',
+                kind: 'Scalar'
+            },
+            {
+                name: 'thumb120By90RenditionStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'thumb240By180RenditionStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'thumb720By480RenditionStatus',
+                kind: 'Scalar'
+            },
+            {
+                name: 'title',
+                kind: 'Scalar'
+            },
+            {
+                name: 'topics',
+                kind: 'Object',
+                nullable: true,
+                selections: TopicCollectionRepresentation__selections
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            },
+            {
+                name: 'versionNumber',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_checksum = existing.checksum;
+    const incoming_checksum = incoming.checksum;
+    if (!(existing_checksum === incoming_checksum)) {
+        return false;
+    }
+    const existing_contentHubRepository = existing.contentHubRepository;
+    const incoming_contentHubRepository = incoming.contentHubRepository;
+    if (!(existing_contentHubRepository === incoming_contentHubRepository
+        || (existing_contentHubRepository != null &&
+            incoming_contentHubRepository != null &&
+            equals$h(existing_contentHubRepository, incoming_contentHubRepository)))) {
+        return false;
+    }
+    const existing_contentModifiedDate = existing.contentModifiedDate;
+    const incoming_contentModifiedDate = incoming.contentModifiedDate;
+    if (!(existing_contentModifiedDate === incoming_contentModifiedDate)) {
+        return false;
+    }
+    const existing_contentSize = existing.contentSize;
+    const incoming_contentSize = incoming.contentSize;
+    if (!(existing_contentSize === incoming_contentSize)) {
+        return false;
+    }
+    const existing_contentUrl = existing.contentUrl;
+    const incoming_contentUrl = incoming.contentUrl;
+    if (!(existing_contentUrl === incoming_contentUrl)) {
+        return false;
+    }
+    const existing_contentVersionId = existing.contentVersionId;
+    const incoming_contentVersionId = incoming.contentVersionId;
+    if (!(existing_contentVersionId === incoming_contentVersionId)) {
+        return false;
+    }
+    const existing_createdDate = existing.createdDate;
+    const incoming_createdDate = incoming.createdDate;
+    if (!(existing_createdDate === incoming_createdDate)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_downloadUrl = existing.downloadUrl;
+    const incoming_downloadUrl = incoming.downloadUrl;
+    if (!(existing_downloadUrl === incoming_downloadUrl)) {
+        return false;
+    }
+    const existing_externalDocumentUrl = existing.externalDocumentUrl;
+    const incoming_externalDocumentUrl = incoming.externalDocumentUrl;
+    if (!(existing_externalDocumentUrl === incoming_externalDocumentUrl)) {
+        return false;
+    }
+    const existing_externalFilePermissionInformation = existing.externalFilePermissionInformation;
+    const incoming_externalFilePermissionInformation = incoming.externalFilePermissionInformation;
+    if (!(existing_externalFilePermissionInformation === incoming_externalFilePermissionInformation
+        || (existing_externalFilePermissionInformation != null &&
+            incoming_externalFilePermissionInformation != null &&
+            equals$e(existing_externalFilePermissionInformation, incoming_externalFilePermissionInformation)))) {
+        return false;
+    }
+    const existing_fileAsset = existing.fileAsset;
+    const incoming_fileAsset = incoming.fileAsset;
+    if (!(existing_fileAsset === incoming_fileAsset
+        || (existing_fileAsset != null &&
+            incoming_fileAsset != null &&
+            equals$d(existing_fileAsset, incoming_fileAsset)))) {
+        return false;
+    }
+    const existing_fileExtension = existing.fileExtension;
+    const incoming_fileExtension = incoming.fileExtension;
+    if (!(existing_fileExtension === incoming_fileExtension)) {
+        return false;
+    }
+    const existing_fileType = existing.fileType;
+    const incoming_fileType = incoming.fileType;
+    if (!(existing_fileType === incoming_fileType)) {
+        return false;
+    }
+    const existing_flashRenditionStatus = existing.flashRenditionStatus;
+    const incoming_flashRenditionStatus = incoming.flashRenditionStatus;
+    if (!(existing_flashRenditionStatus === incoming_flashRenditionStatus)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_isFileAsset = existing.isFileAsset;
+    const incoming_isFileAsset = incoming.isFileAsset;
+    if (!(existing_isFileAsset === incoming_isFileAsset)) {
+        return false;
+    }
+    const existing_isInMyFileSync = existing.isInMyFileSync;
+    const incoming_isInMyFileSync = incoming.isInMyFileSync;
+    if (!(existing_isInMyFileSync === incoming_isInMyFileSync)) {
+        return false;
+    }
+    const existing_isMajorVersion = existing.isMajorVersion;
+    const incoming_isMajorVersion = incoming.isMajorVersion;
+    if (!(existing_isMajorVersion === incoming_isMajorVersion)) {
+        return false;
+    }
+    const existing_mimeType = existing.mimeType;
+    const incoming_mimeType = incoming.mimeType;
+    if (!(existing_mimeType === incoming_mimeType)) {
+        return false;
+    }
+    const existing_moderationFlags = existing.moderationFlags;
+    const incoming_moderationFlags = incoming.moderationFlags;
+    if (!(existing_moderationFlags === incoming_moderationFlags
+        || (existing_moderationFlags != null &&
+            incoming_moderationFlags != null &&
+            equals$a(existing_moderationFlags, incoming_moderationFlags)))) {
+        return false;
+    }
+    const existing_modifiedDate = existing.modifiedDate;
+    const incoming_modifiedDate = incoming.modifiedDate;
+    if (!(existing_modifiedDate === incoming_modifiedDate)) {
+        return false;
+    }
+    const existing_motif = existing.motif;
+    const incoming_motif = incoming.motif;
+    if (!(existing_motif === incoming_motif
+        || (existing_motif != null &&
+            incoming_motif != null &&
+            equals$9(existing_motif, incoming_motif)))) {
+        return false;
+    }
+    const existing_mySubscription = existing.mySubscription;
+    const incoming_mySubscription = incoming.mySubscription;
+    if (!(existing_mySubscription === incoming_mySubscription
+        || (existing_mySubscription != null &&
+            incoming_mySubscription != null &&
+            equals$j(existing_mySubscription, incoming_mySubscription)))) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    const existing_origin = existing.origin;
+    const incoming_origin = incoming.origin;
+    if (!(existing_origin === incoming_origin)) {
+        return false;
+    }
+    const existing_owner = existing.owner;
+    const incoming_owner = incoming.owner;
+    if (!(existing_owner === incoming_owner
+        || (existing_owner != null &&
+            incoming_owner != null &&
+            equals$4(existing_owner, incoming_owner)))) {
+        return false;
+    }
+    const existing_pageCount = existing.pageCount;
+    const incoming_pageCount = incoming.pageCount;
+    if (!(existing_pageCount === incoming_pageCount)) {
+        return false;
+    }
+    const existing_parentFolder = existing.parentFolder;
+    const incoming_parentFolder = incoming.parentFolder;
+    if (!(existing_parentFolder === incoming_parentFolder
+        || (existing_parentFolder != null &&
+            incoming_parentFolder != null &&
+            equals$j(existing_parentFolder, incoming_parentFolder)))) {
+        return false;
+    }
+    const existing_pdfRenditionStatus = existing.pdfRenditionStatus;
+    const incoming_pdfRenditionStatus = incoming.pdfRenditionStatus;
+    if (!(existing_pdfRenditionStatus === incoming_pdfRenditionStatus)) {
+        return false;
+    }
+    const existing_publishStatus = existing.publishStatus;
+    const incoming_publishStatus = incoming.publishStatus;
+    if (!(existing_publishStatus === incoming_publishStatus)) {
+        return false;
+    }
+    const existing_renditionUrl = existing.renditionUrl;
+    const incoming_renditionUrl = incoming.renditionUrl;
+    if (!(existing_renditionUrl === incoming_renditionUrl)) {
+        return false;
+    }
+    const existing_renditionUrl240By180 = existing.renditionUrl240By180;
+    const incoming_renditionUrl240By180 = incoming.renditionUrl240By180;
+    if (!(existing_renditionUrl240By180 === incoming_renditionUrl240By180)) {
+        return false;
+    }
+    const existing_renditionUrl720By480 = existing.renditionUrl720By480;
+    const incoming_renditionUrl720By480 = incoming.renditionUrl720By480;
+    if (!(existing_renditionUrl720By480 === incoming_renditionUrl720By480)) {
+        return false;
+    }
+    const existing_repositoryFileId = existing.repositoryFileId;
+    const incoming_repositoryFileId = incoming.repositoryFileId;
+    if (!(existing_repositoryFileId === incoming_repositoryFileId)) {
+        return false;
+    }
+    const existing_repositoryFileUrl = existing.repositoryFileUrl;
+    const incoming_repositoryFileUrl = incoming.repositoryFileUrl;
+    if (!(existing_repositoryFileUrl === incoming_repositoryFileUrl)) {
+        return false;
+    }
+    const existing_sharingOption = existing.sharingOption;
+    const incoming_sharingOption = incoming.sharingOption;
+    if (!(existing_sharingOption === incoming_sharingOption)) {
+        return false;
+    }
+    const existing_sharingPrivacy = existing.sharingPrivacy;
+    const incoming_sharingPrivacy = incoming.sharingPrivacy;
+    if (!(existing_sharingPrivacy === incoming_sharingPrivacy)) {
+        return false;
+    }
+    const existing_sharingRole = existing.sharingRole;
+    const incoming_sharingRole = incoming.sharingRole;
+    if (!(existing_sharingRole === incoming_sharingRole)) {
+        return false;
+    }
+    const existing_systemModstamp = existing.systemModstamp;
+    const incoming_systemModstamp = incoming.systemModstamp;
+    if (!(existing_systemModstamp === incoming_systemModstamp)) {
+        return false;
+    }
+    const existing_textPreview = existing.textPreview;
+    const incoming_textPreview = incoming.textPreview;
+    if (!(existing_textPreview === incoming_textPreview)) {
+        return false;
+    }
+    const existing_thumb120By90RenditionStatus = existing.thumb120By90RenditionStatus;
+    const incoming_thumb120By90RenditionStatus = incoming.thumb120By90RenditionStatus;
+    if (!(existing_thumb120By90RenditionStatus === incoming_thumb120By90RenditionStatus)) {
+        return false;
+    }
+    const existing_thumb240By180RenditionStatus = existing.thumb240By180RenditionStatus;
+    const incoming_thumb240By180RenditionStatus = incoming.thumb240By180RenditionStatus;
+    if (!(existing_thumb240By180RenditionStatus === incoming_thumb240By180RenditionStatus)) {
+        return false;
+    }
+    const existing_thumb720By480RenditionStatus = existing.thumb720By480RenditionStatus;
+    const incoming_thumb720By480RenditionStatus = incoming.thumb720By480RenditionStatus;
+    if (!(existing_thumb720By480RenditionStatus === incoming_thumb720By480RenditionStatus)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_topics = existing.topics;
+    const incoming_topics = incoming.topics;
+    if (!(existing_topics === incoming_topics
+        || (existing_topics != null &&
+            incoming_topics != null &&
+            equals$1(existing_topics, incoming_topics)))) {
+        return false;
+    }
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    if (!(existing_url === incoming_url)) {
+        return false;
+    }
+    const existing_versionNumber = existing.versionNumber;
+    const incoming_versionNumber = incoming.versionNumber;
+    if (!(existing_versionNumber === incoming_versionNumber)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function FileDetailRepresentationIngest(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 = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "files", 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(luvio, params) {
+    return select$1();
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response);
+}
+function ingestSuccess(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType(luvio, body);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        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(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/connect/files/users/' + config.urlParams.userId + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'createContentDocFromContentBody';
+const createContentDocFromContentBody_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('userId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('contentBodyId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('contentModifiedDate', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('desc', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('firstPublishLocationId', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('includeExternalFilePermissionsInfo', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('isInMyFileSync', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('isMajorVersion', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('networkId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('parentFolderId', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('pathOnClient', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('repositoryFileId', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('repositoryFileUri', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('repositoryId', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('reuseReference', false, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('sharingOption', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('sharingPrivacy', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('title', true, 2 /* Body */, 0 /* String */),
+];
+const createContentDocFromContentBody_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, createContentDocFromContentBody_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$2(createContentDocFromContentBody_ConfigPropertyMetadata);
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$2(untrustedConfig, config, createContentDocFromContentBody_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 buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createContentDocFromContentBodyAdapterFactory = (luvio) => {
+    return function createContentDocFromContentBody(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, createContentDocFromContentBody_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createContentDocFromContentBody"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+export { createContentDocFromContentBodyAdapterFactory, getFileUploadConfigAdapterFactory };