@salesforce/lds-adapters-starter-solution-recipes 0.1.0-dev1

package/dist/es/es2018/starter-solution-recipes.js

@@ -0,0 +1,1159 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$1, typeCheckConfig as typeCheckConfig$1 } from '@luvio/engine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = 'solution-recipes';
+
+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),
+    };
+}
+
+function validate$6(obj, path = 'SolutionLibraryFilterInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.bookMarked !== undefined) {
+            const obj_bookMarked = obj.bookMarked;
+            const path_bookMarked = path + '.bookMarked';
+            if (typeof obj_bookMarked !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_bookMarked + '" (at "' + path_bookMarked + '")');
+            }
+        }
+        if (obj.clouds !== undefined) {
+            const obj_clouds = obj.clouds;
+            const path_clouds = path + '.clouds';
+            if (!ArrayIsArray(obj_clouds)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_clouds + '" (at "' + path_clouds + '")');
+            }
+            for (let i = 0; i < obj_clouds.length; i++) {
+                const obj_clouds_item = obj_clouds[i];
+                const path_clouds_item = path_clouds + '[' + i + ']';
+                if (typeof obj_clouds_item !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_clouds_item + '" (at "' + path_clouds_item + '")');
+                }
+            }
+        }
+        if (obj.markedAsDone !== undefined) {
+            const obj_markedAsDone = obj.markedAsDone;
+            const path_markedAsDone = path + '.markedAsDone';
+            if (typeof obj_markedAsDone !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_markedAsDone + '" (at "' + path_markedAsDone + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const VERSION$5 = "deb9e2640d87eef8846f028fcf2e32d3";
+function validate$5(obj, path = 'SolutionLibraryErrorRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_code = obj.code;
+        const path_code = path + '.code';
+        if (typeof obj_code !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_code + '" (at "' + path_code + '")');
+        }
+        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$6 = function SolutionLibraryErrorRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$5,
+        private: [],
+        selections: [
+            {
+                name: 'code',
+                kind: 'Scalar'
+            },
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$5(existing, incoming) {
+    const existing_code = existing.code;
+    const incoming_code = incoming.code;
+    if (!(existing_code === incoming_code)) {
+        return false;
+    }
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$4 = "6f2b19ff90e46c3e647132b30ffe615a";
+function validate$4(obj, path = 'SolutionLibraryPageReferenceRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_attributes = obj.attributes;
+        const path_attributes = path + '.attributes';
+        if (typeof obj_attributes !== 'object' || ArrayIsArray(obj_attributes) || obj_attributes === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj_attributes + '" (at "' + path_attributes + '")');
+        }
+        const obj_attributes_keys = ObjectKeys(obj_attributes);
+        for (let i = 0; i < obj_attributes_keys.length; i++) {
+            const key = obj_attributes_keys[i];
+            const obj_attributes_prop = obj_attributes[key];
+            const path_attributes_prop = path_attributes + '["' + key + '"]';
+            if (typeof obj_attributes_prop !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_attributes_prop + '" (at "' + path_attributes_prop + '")');
+            }
+        }
+        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$5 = function SolutionLibraryPageReferenceRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'attributes',
+                kind: 'Scalar',
+                map: true
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    const existing_attributes = existing.attributes;
+    const incoming_attributes = incoming.attributes;
+    const equals_attributes_props = equalsObject(existing_attributes, incoming_attributes, (existing_attributes_prop, incoming_attributes_prop) => {
+        if (!(existing_attributes_prop === incoming_attributes_prop)) {
+            return false;
+        }
+    });
+    if (equals_attributes_props === false) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$3 = "dfddf07b11ab903a46c7e322d1376f05";
+function validate$3(obj, path = 'SolutionRecipeActionParamsRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.id !== undefined) {
+            const obj_id = obj.id;
+            const path_id = path + '.id';
+            if (typeof obj_id !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+            }
+        }
+        if (obj.index !== undefined) {
+            const obj_index = obj.index;
+            const path_index = path + '.index';
+            if (typeof obj_index !== 'number' || (typeof obj_index === 'number' && Math.floor(obj_index) !== obj_index)) {
+                return new TypeError('Expected "integer" but received "' + typeof obj_index + '" (at "' + path_index + '")');
+            }
+        }
+        if (obj.isDeclarative !== undefined) {
+            const obj_isDeclarative = obj.isDeclarative;
+            const path_isDeclarative = path + '.isDeclarative';
+            if (typeof obj_isDeclarative !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isDeclarative + '" (at "' + path_isDeclarative + '")');
+            }
+        }
+        if (obj.isFolder !== undefined) {
+            const obj_isFolder = obj.isFolder;
+            const path_isFolder = path + '.isFolder';
+            if (typeof obj_isFolder !== 'boolean') {
+                return new TypeError('Expected "boolean" but received "' + typeof obj_isFolder + '" (at "' + path_isFolder + '")');
+            }
+        }
+        if (obj.lsf !== undefined) {
+            const obj_lsf = obj.lsf;
+            const path_lsf = path + '.lsf';
+            if (typeof obj_lsf !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lsf + '" (at "' + path_lsf + '")');
+            }
+        }
+        if (obj.lsfParams !== undefined) {
+            const obj_lsfParams = obj.lsfParams;
+            const path_lsfParams = path + '.lsfParams';
+            if (typeof obj_lsfParams !== 'object' || ArrayIsArray(obj_lsfParams) || obj_lsfParams === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_lsfParams + '" (at "' + path_lsfParams + '")');
+            }
+            const obj_lsfParams_keys = ObjectKeys(obj_lsfParams);
+            for (let i = 0; i < obj_lsfParams_keys.length; i++) {
+                const key = obj_lsfParams_keys[i];
+                const obj_lsfParams_prop = obj_lsfParams[key];
+                const path_lsfParams_prop = path_lsfParams + '["' + key + '"]';
+                if (typeof obj_lsfParams_prop !== 'string') {
+                    return new TypeError('Expected "string" but received "' + typeof obj_lsfParams_prop + '" (at "' + path_lsfParams_prop + '")');
+                }
+            }
+        }
+        if (obj.name !== undefined) {
+            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 + '")');
+            }
+        }
+        if (obj.pageReference !== undefined) {
+            const obj_pageReference = obj.pageReference;
+            const path_pageReference = path + '.pageReference';
+            const referencepath_pageReferenceValidationError = validate$4(obj_pageReference, path_pageReference);
+            if (referencepath_pageReferenceValidationError !== null) {
+                let message = 'Object doesn\'t match SolutionLibraryPageReferenceRepresentation (at "' + path_pageReference + '")\n';
+                message += referencepath_pageReferenceValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        if (obj.pubSubEvents !== undefined) {
+            const obj_pubSubEvents = obj.pubSubEvents;
+            const path_pubSubEvents = path + '.pubSubEvents';
+            if (typeof obj_pubSubEvents !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_pubSubEvents + '" (at "' + path_pubSubEvents + '")');
+            }
+        }
+        if (obj.stepId !== undefined) {
+            const obj_stepId = obj.stepId;
+            const path_stepId = path + '.stepId';
+            if (typeof obj_stepId !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_stepId + '" (at "' + path_stepId + '")');
+            }
+        }
+        if (obj.url !== undefined) {
+            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$4 = function SolutionRecipeActionParamsRepresentationSelect() {
+    const { selections: SolutionLibraryPageReferenceRepresentation__selections, opaque: SolutionLibraryPageReferenceRepresentation__opaque, } = select$5();
+    return {
+        kind: 'Fragment',
+        version: VERSION$3,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'index',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isDeclarative',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'isFolder',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'lsf',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'lsfParams',
+                kind: 'Scalar',
+                map: true,
+                required: false
+            },
+            {
+                name: 'name',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'pageReference',
+                kind: 'Object',
+                selections: SolutionLibraryPageReferenceRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'pubSubEvents',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'stepId',
+                kind: 'Scalar',
+                required: false
+            },
+            {
+                name: 'url',
+                kind: 'Scalar',
+                required: false
+            }
+        ]
+    };
+};
+function equals$3(existing, incoming) {
+    const existing_isDeclarative = existing.isDeclarative;
+    const incoming_isDeclarative = incoming.isDeclarative;
+    // if at least one of these optionals is defined
+    if (existing_isDeclarative !== undefined || incoming_isDeclarative !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isDeclarative === undefined || incoming_isDeclarative === undefined) {
+            return false;
+        }
+        if (!(existing_isDeclarative === incoming_isDeclarative)) {
+            return false;
+        }
+    }
+    const existing_isFolder = existing.isFolder;
+    const incoming_isFolder = incoming.isFolder;
+    // if at least one of these optionals is defined
+    if (existing_isFolder !== undefined || incoming_isFolder !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_isFolder === undefined || incoming_isFolder === undefined) {
+            return false;
+        }
+        if (!(existing_isFolder === incoming_isFolder)) {
+            return false;
+        }
+    }
+    const existing_index = existing.index;
+    const incoming_index = incoming.index;
+    // if at least one of these optionals is defined
+    if (existing_index !== undefined || incoming_index !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_index === undefined || incoming_index === undefined) {
+            return false;
+        }
+        if (!(existing_index === incoming_index)) {
+            return false;
+        }
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    // if at least one of these optionals is defined
+    if (existing_id !== undefined || incoming_id !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_id === undefined || incoming_id === undefined) {
+            return false;
+        }
+        if (!(existing_id === incoming_id)) {
+            return false;
+        }
+    }
+    const existing_lsf = existing.lsf;
+    const incoming_lsf = incoming.lsf;
+    // if at least one of these optionals is defined
+    if (existing_lsf !== undefined || incoming_lsf !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_lsf === undefined || incoming_lsf === undefined) {
+            return false;
+        }
+        if (!(existing_lsf === incoming_lsf)) {
+            return false;
+        }
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    // if at least one of these optionals is defined
+    if (existing_name !== undefined || incoming_name !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_name === undefined || incoming_name === undefined) {
+            return false;
+        }
+        if (!(existing_name === incoming_name)) {
+            return false;
+        }
+    }
+    const existing_pubSubEvents = existing.pubSubEvents;
+    const incoming_pubSubEvents = incoming.pubSubEvents;
+    // if at least one of these optionals is defined
+    if (existing_pubSubEvents !== undefined || incoming_pubSubEvents !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_pubSubEvents === undefined || incoming_pubSubEvents === undefined) {
+            return false;
+        }
+        if (!(existing_pubSubEvents === incoming_pubSubEvents)) {
+            return false;
+        }
+    }
+    const existing_stepId = existing.stepId;
+    const incoming_stepId = incoming.stepId;
+    // if at least one of these optionals is defined
+    if (existing_stepId !== undefined || incoming_stepId !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_stepId === undefined || incoming_stepId === undefined) {
+            return false;
+        }
+        if (!(existing_stepId === incoming_stepId)) {
+            return false;
+        }
+    }
+    const existing_url = existing.url;
+    const incoming_url = incoming.url;
+    // if at least one of these optionals is defined
+    if (existing_url !== undefined || incoming_url !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_url === undefined || incoming_url === undefined) {
+            return false;
+        }
+        if (!(existing_url === incoming_url)) {
+            return false;
+        }
+    }
+    const existing_lsfParams = existing.lsfParams;
+    const incoming_lsfParams = incoming.lsfParams;
+    // if at least one of these optionals is defined
+    if (existing_lsfParams !== undefined || incoming_lsfParams !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_lsfParams === undefined || incoming_lsfParams === undefined) {
+            return false;
+        }
+        const equals_lsfParams_props = equalsObject(existing_lsfParams, incoming_lsfParams, (existing_lsfParams_prop, incoming_lsfParams_prop) => {
+            if (!(existing_lsfParams_prop === incoming_lsfParams_prop)) {
+                return false;
+            }
+        });
+        if (equals_lsfParams_props === false) {
+            return false;
+        }
+    }
+    const existing_pageReference = existing.pageReference;
+    const incoming_pageReference = incoming.pageReference;
+    // if at least one of these optionals is defined
+    if (existing_pageReference !== undefined || incoming_pageReference !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_pageReference === undefined || incoming_pageReference === undefined) {
+            return false;
+        }
+        if (!(equals$4(existing_pageReference, incoming_pageReference))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$2 = "093239ddf995094f84ebe2556ec42b34";
+function validate$2(obj, path = 'SolutionRecipeActionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.params !== undefined) {
+            const obj_params = obj.params;
+            const path_params = path + '.params';
+            const referencepath_paramsValidationError = validate$3(obj_params, path_params);
+            if (referencepath_paramsValidationError !== null) {
+                let message = 'Object doesn\'t match SolutionRecipeActionParamsRepresentation (at "' + path_params + '")\n';
+                message += referencepath_paramsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        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$3 = function SolutionRecipeActionRepresentationSelect() {
+    const { selections: SolutionRecipeActionParamsRepresentation__selections, opaque: SolutionRecipeActionParamsRepresentation__opaque, } = select$4();
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        selections: [
+            {
+                name: 'params',
+                kind: 'Object',
+                selections: SolutionRecipeActionParamsRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'type',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$2(existing, incoming) {
+    const existing_type = existing.type;
+    const incoming_type = incoming.type;
+    if (!(existing_type === incoming_type)) {
+        return false;
+    }
+    const existing_params = existing.params;
+    const incoming_params = incoming.params;
+    // if at least one of these optionals is defined
+    if (existing_params !== undefined || incoming_params !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_params === undefined || incoming_params === undefined) {
+            return false;
+        }
+        if (!(equals$3(existing_params, incoming_params))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const VERSION$1 = "f8503a533562a0754b07845c810b7f60";
+function validate$1(obj, path = 'SolutionLibraryRecipeRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_action = obj.action;
+        const path_action = path + '.action';
+        const referencepath_actionValidationError = validate$2(obj_action, path_action);
+        if (referencepath_actionValidationError !== null) {
+            let message = 'Object doesn\'t match SolutionRecipeActionRepresentation (at "' + path_action + '")\n';
+            message += referencepath_actionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        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_icon = obj.icon;
+        const path_icon = path + '.icon';
+        if (typeof obj_icon !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_icon + '" (at "' + path_icon + '")');
+        }
+        const obj_iconAltText = obj.iconAltText;
+        const path_iconAltText = path + '.iconAltText';
+        if (typeof obj_iconAltText !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_iconAltText + '" (at "' + path_iconAltText + '")');
+        }
+        const obj_iconStyle = obj.iconStyle;
+        const path_iconStyle = path + '.iconStyle';
+        if (typeof obj_iconStyle !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_iconStyle + '" (at "' + path_iconStyle + '")');
+        }
+        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_isBookmarked = obj.isBookmarked;
+        const path_isBookmarked = path + '.isBookmarked';
+        if (typeof obj_isBookmarked !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isBookmarked + '" (at "' + path_isBookmarked + '")');
+        }
+        const obj_isMarkedAsComplete = obj.isMarkedAsComplete;
+        const path_isMarkedAsComplete = path + '.isMarkedAsComplete';
+        if (typeof obj_isMarkedAsComplete !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isMarkedAsComplete + '" (at "' + path_isMarkedAsComplete + '")');
+        }
+        const obj_recipeId = obj.recipeId;
+        const path_recipeId = path + '.recipeId';
+        if (typeof obj_recipeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_recipeId + '" (at "' + path_recipeId + '")');
+        }
+        const obj_score = obj.score;
+        const path_score = path + '.score';
+        if (typeof obj_score !== 'number' || (typeof obj_score === 'number' && Math.floor(obj_score) !== obj_score)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_score + '" (at "' + path_score + '")');
+        }
+        const obj_state = obj.state;
+        const path_state = path + '.state';
+        if (typeof obj_state !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_state + '" (at "' + path_state + '")');
+        }
+        const obj_tagId = obj.tagId;
+        const path_tagId = path + '.tagId';
+        if (!ArrayIsArray(obj_tagId)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_tagId + '" (at "' + path_tagId + '")');
+        }
+        for (let i = 0; i < obj_tagId.length; i++) {
+            const obj_tagId_item = obj_tagId[i];
+            const path_tagId_item = path_tagId + '[' + i + ']';
+            if (typeof obj_tagId_item !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_tagId_item + '" (at "' + path_tagId_item + '")');
+            }
+        }
+        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 + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'SolutionLibraryRecipeRepresentation';
+function keyBuilder$1(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.id;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$1(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$2 = function SolutionLibraryRecipeRepresentationSelect() {
+    const { selections: SolutionRecipeActionRepresentation__selections, opaque: SolutionRecipeActionRepresentation__opaque, } = select$3();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'action',
+                kind: 'Object',
+                selections: SolutionRecipeActionRepresentation__selections
+            },
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'icon',
+                kind: 'Scalar'
+            },
+            {
+                name: 'iconAltText',
+                kind: 'Scalar'
+            },
+            {
+                name: 'iconStyle',
+                kind: 'Scalar'
+            },
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isBookmarked',
+                kind: 'Scalar'
+            },
+            {
+                name: 'isMarkedAsComplete',
+                kind: 'Scalar'
+            },
+            {
+                name: 'recipeId',
+                kind: 'Scalar'
+            },
+            {
+                name: 'score',
+                kind: 'Scalar'
+            },
+            {
+                name: 'state',
+                kind: 'Scalar'
+            },
+            {
+                name: 'tagId',
+                kind: 'Scalar',
+                plural: true
+            },
+            {
+                name: 'title',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_isBookmarked = existing.isBookmarked;
+    const incoming_isBookmarked = incoming.isBookmarked;
+    if (!(existing_isBookmarked === incoming_isBookmarked)) {
+        return false;
+    }
+    const existing_isMarkedAsComplete = existing.isMarkedAsComplete;
+    const incoming_isMarkedAsComplete = incoming.isMarkedAsComplete;
+    if (!(existing_isMarkedAsComplete === incoming_isMarkedAsComplete)) {
+        return false;
+    }
+    const existing_score = existing.score;
+    const incoming_score = incoming.score;
+    if (!(existing_score === incoming_score)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_icon = existing.icon;
+    const incoming_icon = incoming.icon;
+    if (!(existing_icon === incoming_icon)) {
+        return false;
+    }
+    const existing_iconAltText = existing.iconAltText;
+    const incoming_iconAltText = incoming.iconAltText;
+    if (!(existing_iconAltText === incoming_iconAltText)) {
+        return false;
+    }
+    const existing_iconStyle = existing.iconStyle;
+    const incoming_iconStyle = incoming.iconStyle;
+    if (!(existing_iconStyle === incoming_iconStyle)) {
+        return false;
+    }
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_recipeId = existing.recipeId;
+    const incoming_recipeId = incoming.recipeId;
+    if (!(existing_recipeId === incoming_recipeId)) {
+        return false;
+    }
+    const existing_state = existing.state;
+    const incoming_state = incoming.state;
+    if (!(existing_state === incoming_state)) {
+        return false;
+    }
+    const existing_title = existing.title;
+    const incoming_title = incoming.title;
+    if (!(existing_title === incoming_title)) {
+        return false;
+    }
+    const existing_action = existing.action;
+    const incoming_action = incoming.action;
+    if (!(equals$2(existing_action, incoming_action))) {
+        return false;
+    }
+    const existing_tagId = existing.tagId;
+    const incoming_tagId = incoming.tagId;
+    const equals_tagId_items = equalsArray(existing_tagId, incoming_tagId, (existing_tagId_item, incoming_tagId_item) => {
+        if (!(existing_tagId_item === incoming_tagId_item)) {
+            return false;
+        }
+    });
+    if (equals_tagId_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$1 = function SolutionLibraryRecipeRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$1(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 1000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "solution-recipes", VERSION$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$1(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+
+const VERSION = "9e6d2fd679515b62b1f6ae0f9b4b3d26";
+function validate(obj, path = 'SolutionLibraryOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.error !== undefined) {
+            const obj_error = obj.error;
+            const path_error = path + '.error';
+            const referencepath_errorValidationError = validate$5(obj_error, path_error);
+            if (referencepath_errorValidationError !== null) {
+                let message = 'Object doesn\'t match SolutionLibraryErrorRepresentation (at "' + path_error + '")\n';
+                message += referencepath_errorValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_isSuccess = obj.isSuccess;
+        const path_isSuccess = path + '.isSuccess';
+        if (typeof obj_isSuccess !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isSuccess + '" (at "' + path_isSuccess + '")');
+        }
+        if (obj.recipes !== undefined) {
+            const obj_recipes = obj.recipes;
+            const path_recipes = path + '.recipes';
+            if (!ArrayIsArray(obj_recipes)) {
+                return new TypeError('Expected "array" but received "' + typeof obj_recipes + '" (at "' + path_recipes + '")');
+            }
+            for (let i = 0; i < obj_recipes.length; i++) {
+                const obj_recipes_item = obj_recipes[i];
+                const path_recipes_item = path_recipes + '[' + i + ']';
+                if (typeof obj_recipes_item !== 'object' || Array.isArray(obj_recipes_item)) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_recipes_item + '" (at "' + path_recipes_item + '")');
+                }
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'SolutionLibraryOutputRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.isSuccess;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        isSuccess: object.isSuccess
+    };
+    return keyBuilder(luvio, keyParams);
+}
+function normalize(input, existing, path, luvio, store, timestamp) {
+    const input_recipes = input.recipes;
+    const input_recipes_id = path.fullPath + '__recipes';
+    if (input_recipes !== undefined) {
+        for (let i = 0; i < input_recipes.length; i++) {
+            const input_recipes_item = input_recipes[i];
+            let input_recipes_item_id = input_recipes_id + '__' + i;
+            input_recipes[i] = ingest$1(input_recipes_item, {
+                fullPath: input_recipes_item_id,
+                propertyName: i,
+                parent: {
+                    data: input,
+                    key: path.fullPath,
+                    existing: existing,
+                },
+                ttl: path.ttl
+            }, luvio, store, timestamp);
+        }
+    }
+    return input;
+}
+const select$1 = function SolutionLibraryOutputRepresentationSelect() {
+    const { selections: SolutionLibraryErrorRepresentation__selections, opaque: SolutionLibraryErrorRepresentation__opaque, } = select$6();
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'error',
+                kind: 'Object',
+                selections: SolutionLibraryErrorRepresentation__selections,
+                required: false
+            },
+            {
+                name: 'isSuccess',
+                kind: 'Scalar'
+            },
+            {
+                name: 'recipes',
+                kind: 'Link',
+                plural: true,
+                required: false,
+                fragment: select$2()
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_isSuccess = existing.isSuccess;
+    const incoming_isSuccess = incoming.isSuccess;
+    if (!(existing_isSuccess === incoming_isSuccess)) {
+        return false;
+    }
+    const existing_error = existing.error;
+    const incoming_error = incoming.error;
+    // if at least one of these optionals is defined
+    if (existing_error !== undefined || incoming_error !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_error === undefined || incoming_error === undefined) {
+            return false;
+        }
+        if (!(equals$5(existing_error, incoming_error))) {
+            return false;
+        }
+    }
+    const existing_recipes = existing.recipes;
+    const incoming_recipes = incoming.recipes;
+    // if at least one of these optionals is defined
+    if (existing_recipes !== undefined || incoming_recipes !== undefined) {
+        // if one of these is not defined we know the other is defined and therefore
+        // not equal
+        if (existing_recipes === undefined || incoming_recipes === undefined) {
+            return false;
+        }
+        const equals_recipes_items = equalsArray(existing_recipes, incoming_recipes, (existing_recipes_item, incoming_recipes_item) => {
+            if (!(existing_recipes_item.__ref === incoming_recipes_item.__ref)) {
+                return false;
+            }
+        });
+        if (equals_recipes_items === false) {
+            return false;
+        }
+    }
+    return true;
+}
+const ingest = function SolutionLibraryOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 1000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "solution-recipes", 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
+    });
+    if (input.recipes !== undefined) {
+        const input_recipes_length = input.recipes.length;
+        for (let i = 0; i < input_recipes_length; i++) {
+            getTypeCacheKeys$1(rootKeySet, luvio, input.recipes[i]);
+        }
+    }
+}
+
+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/v66.0',
+        basePath: '/connect/solution-library/recipes',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'postSolutionLibraryRecipes';
+const postSolutionLibraryRecipes_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('currentRecipes', false, 2 /* Body */, 0 /* String */, true),
+    generateParamConfigMetadata('filters', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('offset', false, 2 /* Body */, 3 /* Integer */),
+    generateParamConfigMetadata('section', true, 2 /* Body */, 0 /* String */),
+];
+const postSolutionLibraryRecipes_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, postSolutionLibraryRecipes_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$1(postSolutionLibraryRecipes_ConfigPropertyMetadata);
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$1(untrustedConfig, config, postSolutionLibraryRecipes_ConfigPropertyMetadata);
+    const untrustedConfig_filters = untrustedConfig.filters;
+    const referenceSolutionLibraryFilterInputRepresentationValidationError = validate$6(untrustedConfig_filters);
+    if (referenceSolutionLibraryFilterInputRepresentationValidationError === null) {
+        config.filters = untrustedConfig_filters;
+    }
+    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 postSolutionLibraryRecipesAdapterFactory = (luvio) => {
+    return function postSolutionLibraryRecipes(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, postSolutionLibraryRecipes_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "postSolutionLibraryRecipes"');
+        }
+        return buildNetworkSnapshot(luvio, config);
+    };
+};
+
+export { postSolutionLibraryRecipesAdapterFactory };