@salesforce/lds-adapters-industries-documentmatrix 0.1.0-dev1

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

@@ -0,0 +1,28 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "8cb5e7eceb053c1f1a4cd0fd01b94bef";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentDecisionInputRepresentation, existing: DocumentDecisionInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentDecisionInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentDecisionInputRepresentationNormalized, incoming: DocumentDecisionInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DocumentDecisionInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for the connect api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentDecisionInputRepresentationNormalized {
+    /** List of inputs passed to Decision Table. The key should contain field name of Decision table and value should contain value of the field that is the key. An input may contain multiple fields. */
+    inputs: unknown;
+}
+/**
+ * Input representation for the connect api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentDecisionInputRepresentation {
+    inputs: unknown;
+}

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

@@ -0,0 +1,36 @@
+import { DecisionTableDocumentDecisionRepresentation as DecisionTableDocumentDecisionRepresentation_DecisionTableDocumentDecisionRepresentation } from './DecisionTableDocumentDecisionRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 300;
+export declare const VERSION = "6bd68bfab828ce0f9e1f82bd1920e04d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentDecisionResponseRepresentation, existing: DocumentDecisionResponseRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentDecisionResponseRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: DocumentDecisionResponseRepresentationNormalized, incoming: DocumentDecisionResponseRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DocumentDecisionResponseRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of Document Matrix Decision
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentDecisionResponseRepresentationNormalized {
+    /** The flat data of Decision Table Output. */
+    decisionTableDocumentDecisions: Array<DecisionTableDocumentDecisionRepresentation_DecisionTableDocumentDecisionRepresentation>;
+    /** The message explaining why the request failed. */
+    message: string;
+    /** Indicates whether the request succeeded (true) or failed (false). */
+    status: string;
+}
+/**
+ * Output representation of Document Matrix Decision
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentDecisionResponseRepresentation {
+    decisionTableDocumentDecisions: Array<DecisionTableDocumentDecisionRepresentation_DecisionTableDocumentDecisionRepresentation>;
+    message: string;
+    status: string;
+}

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

@@ -0,0 +1,37 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "add8a5d32573407b3829466076c1cb90";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentTypesRepresentation, existing: DocumentTypesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentTypesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentTypesRepresentationNormalized, incoming: DocumentTypesRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DocumentTypesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of Document Type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentTypesRepresentationNormalized {
+    /** The Id of Document Type that is associated with document category */
+    documentTypeId: string;
+    /** The label of Document Type that is associated with document category */
+    documentTypeLabel: string;
+    /** Maximum file size in KBs for a file that can be uploaded for a document type  */
+    maximumFileSizeAllowed: string;
+    /** Maximum file uploads that can be uploaded for a document type  */
+    maximumFileUploadsAllowed: string;
+}
+/**
+ * Output representation of Document Type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentTypesRepresentation {
+    documentTypeId: string;
+    documentTypeLabel: string;
+    maximumFileSizeAllowed: string;
+    maximumFileUploadsAllowed: string;
+}

package/dist/es/es2018/types/src/generated/types/type-utils.d.ts

@@ -0,0 +1,32 @@
+import { NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, ObjectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const JSONStringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+type AllowedPrimitives = boolean | string | number | Date | null;
+type Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;
+export type RecursivePartial<T> = null | {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> | null : Value<T[P]> | null;
+};
+export declare function equalsArray<U, V extends U[]>(a: V, b: V, equalsItem: (itemA: U, itemB: U) => boolean | void): boolean;
+export declare function equalsObject<U, V extends {
+    [key: string]: U;
+}>(a: V, b: V, equalsProp: (propA: U, propB: U) => boolean | void): boolean;
+export declare function createLink(ref: string | $64$luvio_engine_NormalizedKeyMetadata): {
+    __ref: string;
+};
+export declare function assignMetadataLink(entry: any, metadataKey: string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export {};

package/package.json

@@ -0,0 +1,74 @@
+{
+    "name": "@salesforce/lds-adapters-industries-documentmatrix",
+    "version": "0.1.0-dev1",
+    "description": "Document Matrix component is a custom OS element by Discovery Framework. It is an out-of-box solution that removes the need for Admins to create multiple Assessments with the same set of questions but with a different set of files to upload at the end.",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "main": "dist/es/es2018/industries-documentmatrix.js",
+    "module": "dist/es/es2018/industries-documentmatrix.js",
+    "types": "dist/es/es2018/types/src/generated/artifacts/main.d.ts",
+    "files": [
+        "dist",
+        "sfdc",
+        "src/raml/*"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/es/es2018/types/src/generated/artifacts/main.d.ts",
+            "import": "./dist/es/es2018/industries-documentmatrix.js",
+            "require": "./dist/es/es2018/industries-documentmatrix.js"
+        },
+        "./sfdc": {
+            "types": "./sfdc/index.d.ts",
+            "import": "./sfdc/index.js",
+            "default": "./sfdc/index.js"
+        }
+    },
+    "sfdc": {
+        "namespace": "lightning",
+        "module": "industriesDocumentmatrixApi"
+    },
+    "contributors": [
+        "gkandpal@salesforce.com"
+    ],
+    "scripts": {
+        "build": "yarn build:services",
+        "build:karma": "rollup --bundleConfigAsCjs --config rollup.config.karma.js",
+        "build:raml": "luvio generate src/raml/luvio.raml src/generated -p '../lds-compiler-plugins'",
+        "build:services": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist sfdc src/generated karma/dist",
+        "release:core": "../../scripts/release/core.js --adapter=lds-adapters-industries-documentmatrix",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --adapter=lds-adapters-industries-documentmatrix",
+        "start": "nx build:karma && karma start",
+        "test": "nx build:karma && karma start --single-run"
+    },
+    "dependencies": {
+        "@salesforce/lds-bindings": "^0.1.0-dev1"
+    },
+    "devDependencies": {
+        "@salesforce/lds-compiler-plugins": "^0.1.0-dev1",
+        "@salesforce/lds-karma": "^0.1.0-dev1"
+    },
+    "nx": {
+        "targets": {
+            "build": {
+                "outputs": [
+                    "{projectRoot}/dist",
+                    "{projectRoot}/sfdc"
+                ]
+            },
+            "build:raml": {
+                "outputs": [
+                    "{projectRoot}/src/generated"
+                ]
+            },
+            "build:karma": {
+                "outputs": [
+                    "{projectRoot}/karma/dist"
+                ]
+            }
+        }
+    },
+    "volta": {
+        "extends": "../../package.json"
+    }
+}

package/sfdc/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/es/es2018/types/src/generated/artifacts/sfdc';

package/sfdc/index.js

@@ -0,0 +1,416 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
+import { withDefaultLuvio } from 'force/ldsEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1, typeCheckConfig as typeCheckConfig$1, StoreKeyMap, createResourceParams as createResourceParams$1 } from 'force/luvioEngine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = 'DocumentMatrix';
+
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+function validate$2(obj, path = 'DocumentTypesRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_documentTypeId = obj.documentTypeId;
+        const path_documentTypeId = path + '.documentTypeId';
+        if (typeof obj_documentTypeId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_documentTypeId + '" (at "' + path_documentTypeId + '")');
+        }
+        const obj_documentTypeLabel = obj.documentTypeLabel;
+        const path_documentTypeLabel = path + '.documentTypeLabel';
+        if (typeof obj_documentTypeLabel !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_documentTypeLabel + '" (at "' + path_documentTypeLabel + '")');
+        }
+        const obj_maximumFileSizeAllowed = obj.maximumFileSizeAllowed;
+        const path_maximumFileSizeAllowed = path + '.maximumFileSizeAllowed';
+        if (typeof obj_maximumFileSizeAllowed !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_maximumFileSizeAllowed + '" (at "' + path_maximumFileSizeAllowed + '")');
+        }
+        const obj_maximumFileUploadsAllowed = obj.maximumFileUploadsAllowed;
+        const path_maximumFileUploadsAllowed = path + '.maximumFileUploadsAllowed';
+        if (typeof obj_maximumFileUploadsAllowed !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_maximumFileUploadsAllowed + '" (at "' + path_maximumFileUploadsAllowed + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+function validate$1(obj, path = 'DecisionTableDocumentDecisionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_defaultMaximumFileSizeAllowed = obj.defaultMaximumFileSizeAllowed;
+        const path_defaultMaximumFileSizeAllowed = path + '.defaultMaximumFileSizeAllowed';
+        if (typeof obj_defaultMaximumFileSizeAllowed !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_defaultMaximumFileSizeAllowed + '" (at "' + path_defaultMaximumFileSizeAllowed + '")');
+        }
+        const obj_defaultMaximumFileUploadsAllowed = obj.defaultMaximumFileUploadsAllowed;
+        const path_defaultMaximumFileUploadsAllowed = path + '.defaultMaximumFileUploadsAllowed';
+        if (typeof obj_defaultMaximumFileUploadsAllowed !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_defaultMaximumFileUploadsAllowed + '" (at "' + path_defaultMaximumFileUploadsAllowed + '")');
+        }
+        const obj_documentCategoryId = obj.documentCategoryId;
+        const path_documentCategoryId = path + '.documentCategoryId';
+        if (typeof obj_documentCategoryId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_documentCategoryId + '" (at "' + path_documentCategoryId + '")');
+        }
+        const obj_documentCategoryLabel = obj.documentCategoryLabel;
+        const path_documentCategoryLabel = path + '.documentCategoryLabel';
+        if (typeof obj_documentCategoryLabel !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_documentCategoryLabel + '" (at "' + path_documentCategoryLabel + '")');
+        }
+        const obj_documentTypes = obj.documentTypes;
+        const path_documentTypes = path + '.documentTypes';
+        if (!ArrayIsArray(obj_documentTypes)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_documentTypes + '" (at "' + path_documentTypes + '")');
+        }
+        for (let i = 0; i < obj_documentTypes.length; i++) {
+            const obj_documentTypes_item = obj_documentTypes[i];
+            const path_documentTypes_item = path_documentTypes + '[' + i + ']';
+            const referencepath_documentTypes_itemValidationError = validate$2(obj_documentTypes_item, path_documentTypes_item);
+            if (referencepath_documentTypes_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DocumentTypesRepresentation (at "' + path_documentTypes_item + '")\n';
+                message += referencepath_documentTypes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_helpText = obj.helpText;
+        const path_helpText = path + '.helpText';
+        if (typeof obj_helpText !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_helpText + '" (at "' + path_helpText + '")');
+        }
+        const obj_isRequired = obj.isRequired;
+        const path_isRequired = path + '.isRequired';
+        if (typeof obj_isRequired !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isRequired + '" (at "' + path_isRequired + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL = 300;
+const VERSION = "6bd68bfab828ce0f9e1f82bd1920e04d";
+function validate(obj, path = 'DocumentDecisionResponseRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_decisionTableDocumentDecisions = obj.decisionTableDocumentDecisions;
+        const path_decisionTableDocumentDecisions = path + '.decisionTableDocumentDecisions';
+        if (!ArrayIsArray(obj_decisionTableDocumentDecisions)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_decisionTableDocumentDecisions + '" (at "' + path_decisionTableDocumentDecisions + '")');
+        }
+        for (let i = 0; i < obj_decisionTableDocumentDecisions.length; i++) {
+            const obj_decisionTableDocumentDecisions_item = obj_decisionTableDocumentDecisions[i];
+            const path_decisionTableDocumentDecisions_item = path_decisionTableDocumentDecisions + '[' + i + ']';
+            const referencepath_decisionTableDocumentDecisions_itemValidationError = validate$1(obj_decisionTableDocumentDecisions_item, path_decisionTableDocumentDecisions_item);
+            if (referencepath_decisionTableDocumentDecisions_itemValidationError !== null) {
+                let message = 'Object doesn\'t match DecisionTableDocumentDecisionRepresentation (at "' + path_decisionTableDocumentDecisions_item + '")\n';
+                message += referencepath_decisionTableDocumentDecisions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        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 + '")');
+        }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'DocumentDecisionResponseRepresentation';
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function DocumentDecisionResponseRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function DocumentDecisionResponseRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "DocumentMatrix", VERSION, RepresentationType, equals);
+    return createLink(key);
+};
+function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType,
+        mergeable: false
+    });
+}
+
+function select(luvio, params) {
+    return select$1();
+}
+function keyBuilder$1(luvio, params) {
+    return keyPrefix + '::DocumentDecisionResponseRepresentation:(' + 'decisionTableId:' + params.urlParams.decisionTableId + ',' + 'inputs:' + params.body.inputs + ')';
+}
+function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1(luvio, resourceParams));
+}
+function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$1(luvio, resourceParams);
+    luvio.storeIngest(key, ingest, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$1(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL,
+        namespace: keyPrefix,
+        version: VERSION,
+        representationName: RepresentationType
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v66.0',
+        basePath: '/connect/document-matrix/document-decision/' + config.urlParams.decisionTableId + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'getDocumentDecision';
+const getDocumentDecision_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('decisionTableId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('inputs', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const getDocumentDecision_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getDocumentDecision_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$1(getDocumentDecision_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$1(untrustedConfig, config, getDocumentDecision_ConfigPropertyMetadata);
+    const untrustedConfig_inputs = untrustedConfig.inputs;
+    config.inputs = untrustedConfig_inputs;
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, 'get', false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getDocumentDecisionAdapterFactory = (luvio) => function DocumentMatrix__getDocumentDecision(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getDocumentDecision_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+let getDocumentDecision;
+// Imperative GET Adapters
+let getDocumentDecision_imperative;
+// Adapter Metadata
+const getDocumentDecisionMetadata = {
+    apiFamily: 'DocumentMatrix',
+    name: 'getDocumentDecision',
+    ttl: 300,
+};
+// Notify Update Available
+function bindExportsTo(luvio) {
+    // LDS Adapters
+    const getDocumentDecision_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getDocumentDecision', getDocumentDecisionAdapterFactory), getDocumentDecisionMetadata);
+    return {
+        getDocumentDecision: createWireAdapterConstructor(luvio, getDocumentDecision_ldsAdapter, getDocumentDecisionMetadata),
+        // Imperative GET Adapters
+        getDocumentDecision_imperative: createImperativeAdapter(luvio, getDocumentDecision_ldsAdapter, getDocumentDecisionMetadata),
+        // Notify Update Availables
+    };
+}
+withDefaultLuvio((luvio) => {
+    ({ getDocumentDecision, getDocumentDecision_imperative } = bindExportsTo(luvio));
+});
+
+export { getDocumentDecision, getDocumentDecision_imperative };
+// version: 0.1.0-dev1-c978a7b010