@salesforce/lds-adapters-apex 0.1.0-dev1

package/dist/es/es2018/apex-service.js

@@ -0,0 +1,642 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, deepFreeze, StoreKeyMap, StoreKeySet } from '@luvio/engine';
+
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { stringify: JSONStringify } = JSON;
+const { isArray: ArrayIsArray } = Array;
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray(untrusted) === false;
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify$1(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
+    }
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return JSONStringify(node);
+    }
+    let i;
+    let out;
+    if (ArrayIsArray(node)) {
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify$1(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const keys = ObjectKeys(node).sort();
+    out = '';
+    for (i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = stableJSONStringify$1(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += JSONStringify(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
+const keyPrefix = 'Apex';
+
+function createResourceRequest$1(config) {
+    const headers = {};
+    const header_xSFDCAllowContinuation = config.headers.xSFDCAllowContinuation;
+    if (header_xSFDCAllowContinuation !== undefined) {
+        headers['X-SFDC-Allow-Continuation'] = header_xSFDCAllowContinuation;
+    }
+    return {
+        baseUri: '/lwr/apex/v66.0',
+        basePath: '/' + config.urlParams.apexClass + '/' + config.urlParams.apexMethod + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const { create, keys, values } = Object;
+const { hasOwnProperty } = Object.prototype;
+const { isArray } = Array;
+const { stringify } = JSON;
+
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const CACHE_CONTROL = 'cache-control';
+// eslint-disable-next-line @salesforce/lds/no-invalid-todo
+// TODO: APEX_TTL, apexResponseEquals, apexResponseIngest, and validateAdapterConfig should have been code generated
+// however compiler does not support response body type any so hand roll for now
+/**
+ * Time to live for the Apex cache value. 5 minutes.
+ */
+const APEX_TTL = 5 * 60 * 1000;
+// apex is essentially versionless, we can never know the shape of apex data
+// so we will rely on components to code defensively. All apex data will be ingested
+// and looked up with this version
+const APEX_VERSION = 'APEX_V_1';
+const APEX_STORE_METADATA_PARAMS = {
+    ttl: APEX_TTL,
+    namespace: keyPrefix,
+    representationName: '',
+    version: APEX_VERSION,
+};
+function apexResponseEquals(existing, incoming) {
+    return stringify(incoming) === stringify(existing);
+}
+const apexResponseIngest = (input, path, luvio, store, timestamp) => {
+    // skip validation and normalization, since input type is any
+    const key = path.fullPath;
+    const incomingRecord = input;
+    const existingRecord = store.readEntry(key);
+    // freeze on ingest (luvio.opaque)
+    deepFreeze(incomingRecord);
+    if (existingRecord === undefined ||
+        apexResponseEquals(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    luvio.publishStoreMetadata(key, {
+        ...APEX_STORE_METADATA_PARAMS,
+        ingestionTimestamp: timestamp,
+    });
+    return createLink(key);
+};
+function validateAdapterConfig(untrustedConfig) {
+    if (untrustedIsObject(untrustedConfig)) {
+        const values$1 = values(untrustedConfig);
+        return values$1.indexOf(undefined) === -1 ? untrustedConfig : null;
+    }
+    return untrustedConfig;
+}
+/**
+ * A standard delimiter when producing cache keys.
+ */
+const KEY_DELIM = ':';
+function isEmptyParam(param) {
+    return (param === undefined ||
+        param === null ||
+        (typeof param === 'object' && keys(param).length === 0));
+}
+function keyBuilder(classname, method, isContinuation, params) {
+    return [
+        classname.replace('__', KEY_DELIM),
+        method,
+        isContinuation,
+        isEmptyParam(params) ? '' : stableJSONStringify$1(params),
+    ].join(KEY_DELIM);
+}
+function configBuilder(config, classname, method, isContinuation) {
+    return {
+        apexMethod: method,
+        apexClass: classname,
+        methodParams: config,
+        xSFDCAllowContinuation: isContinuation + '',
+    };
+}
+function apexClassnameBuilder(namespace, classname) {
+    return namespace !== '' ? `${namespace}__${classname}` : classname;
+}
+function isCacheControlValueCacheable(value) {
+    if (value === undefined || value === null || typeof value !== 'string') {
+        return false;
+    }
+    return value.indexOf('no-cache') < 0 && value.indexOf('no-store') < 0;
+}
+function getCacheControlHeaderValue(headers) {
+    if (headers === undefined) {
+        return undefined;
+    }
+    // header fields are case-insensitive according to
+    // https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+    const headerKeys = keys(headers);
+    for (let i = 0, len = headerKeys.length; i < len; i += 1) {
+        const key = headerKeys[i];
+        if (key.toLowerCase() === CACHE_CONTROL) {
+            return headers[key];
+        }
+    }
+    return undefined;
+}
+function shouldCache(response) {
+    const { headers } = response;
+    const headerValue = getCacheControlHeaderValue(headers);
+    return isCacheControlValueCacheable(headerValue);
+}
+
+function createResourceParams$1(config) {
+    const queryParams = create(null);
+    if (!isEmptyParam(config.methodParams)) {
+        queryParams.methodParams = config.methodParams;
+    }
+    return {
+        queryParams,
+        urlParams: {
+            apexMethod: config.apexMethod,
+            apexClass: config.apexClass,
+        },
+        headers: {
+            xSFDCAllowContinuation: config.xSFDCAllowContinuation,
+        },
+    };
+}
+function keyBuilderFromResourceParams$1(params) {
+    let classname = params.urlParams.apexClass.replace('__', KEY_DELIM);
+    return [
+        classname,
+        params.urlParams.apexMethod,
+        params.headers.xSFDCAllowContinuation,
+        isEmptyParam(params.queryParams.methodParams)
+            ? ''
+            : stableJSONStringify$1(params.queryParams.methodParams),
+    ].join(KEY_DELIM);
+}
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const recordId = keyBuilderFromResourceParams$1(resourceParams);
+    const select = {
+        recordId,
+        node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+        variables: {},
+    };
+    luvio.storeIngest(recordId, apexResponseIngest, body);
+    const snapshot = luvio.storeLookup(select, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (response.headers !== undefined && snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+        if (!(snapshot.state === 'Fulfilled' || snapshot.state === 'Stale')) {
+            throw new Error('Invalid resource response. Expected resource response to result in Fulfilled or Stale snapshot');
+        }
+    }
+    return snapshot;
+}
+function buildCachedSnapshotCachePolicy$1(buildSnapshotContext, storeLookup) {
+    const { luvio, config } = buildSnapshotContext;
+    const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
+    const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
+    return storeLookup({
+        recordId: recordId,
+        node: {
+            kind: 'Fragment',
+            opaque: true,
+            private: [],
+            version: APEX_VERSION,
+        },
+        variables: {},
+    }, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
+    });
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const recordId = keyBuilderFromResourceParams$1(resourceParams);
+    const select = {
+        recordId,
+        node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+        variables: {},
+    };
+    if (shouldCache(response)) {
+        const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+            config,
+            resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
+        });
+        return luvio.storeBroadcast().then(() => snapshot);
+    }
+    // if Cache-Control is not set or set to 'no-cache', return a synthetic snapshot
+    return Promise.resolve({
+        recordId,
+        variables: {},
+        seenRecords: new StoreKeySet(),
+        select,
+        state: 'Fulfilled',
+        data: response.body,
+    });
+}
+function onFetchResponseError$1(luvio, config, _resourceParams, response) {
+    return Promise.resolve(luvio.errorSnapshot(response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
+    }));
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options).then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), 
+        // TODO [W-10490362]: Properly generate the response cache keys
+        () => {
+            return new StoreKeyMap();
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            sourceContext,
+        },
+        eventObservers,
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority,
+        };
+    }
+    return buildNetworkSnapshot$1(luvio, config, dispatchOptions);
+}
+const factory = (luvio, invokerParams) => {
+    const { namespace, classname, method, isContinuation } = invokerParams;
+    return getApexAdapterFactory(luvio, namespace, classname, method, isContinuation);
+};
+function getApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
+    return (untrustedConfig, requestContext) => {
+        // Even though the config is of type `any`,
+        // validation is required here because `undefined`
+        // values on a wire mean that properties on the component
+        // used in the config have not been loaded yet.
+        const config = validateAdapterConfig(untrustedConfig);
+        // Invalid or incomplete config
+        if (config === null) {
+            return null;
+        }
+        const configPlus = configBuilder(config, apexClassnameBuilder(namespace, classname), method, isContinuation);
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    };
+}
+
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
+    }
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return stringify(node);
+    }
+    let i;
+    let out;
+    if (isArray(node)) {
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const keys$1 = keys(node).sort();
+    out = '';
+    for (i = 0; i < keys$1.length; i++) {
+        const key = keys$1[i];
+        const value = stableJSONStringify(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += stringify(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
+/**
+ * Returns the field API name, qualified with an object name if possible.
+ * @param value The value from which to get the qualified field API name.
+ * @return The qualified field API name.
+ */
+function getFieldApiName(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else if (value &&
+        typeof value.objectApiName === 'string' &&
+        typeof value.fieldApiName === 'string') {
+        return value.objectApiName + '.' + value.fieldApiName;
+    }
+    throw new TypeError('Value is not a string or FieldId.');
+}
+/**
+ * Split the object API name and field API name from a qualified field name.
+ * Eg: Opportunity.Title returns ['Opportunity', 'Title']
+ * Eg: Opportunity.Account.Name returns ['Opportunity', 'Account.Name']
+ * @param fieldApiName The qualified field name.
+ * @return The object and field API names.
+ */
+function splitQualifiedFieldApiName(fieldApiName) {
+    const idx = fieldApiName.indexOf('.');
+    if (idx < 1) {
+        // object api name must non-empty
+        throw new TypeError('Value does not include an object API name.');
+    }
+    return [fieldApiName.substring(0, idx), fieldApiName.substring(idx + 1)];
+}
+
+function createResourceRequest(config) {
+    const headers = {};
+    const header_xSFDCAllowContinuation = config.headers.xSFDCAllowContinuation;
+    if (header_xSFDCAllowContinuation !== undefined) {
+        headers['X-SFDC-Allow-Continuation'] = header_xSFDCAllowContinuation;
+    }
+    return {
+        baseUri: '/lwr/apex/v66.0',
+        basePath: '/' + config.urlParams.apexClass + '/' + config.urlParams.apexMethod + '',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+function createResourceParams(config) {
+    return {
+        urlParams: {
+            apexMethod: config.apexMethod,
+            apexClass: config.apexClass,
+        },
+        body: config.methodParams,
+        headers: {
+            xSFDCAllowContinuation: config.xSFDCAllowContinuation,
+        },
+    };
+}
+function keyBuilderFromResourceParams(params) {
+    let classname = params.urlParams.apexClass.replace('__', KEY_DELIM);
+    return [
+        classname,
+        params.urlParams.apexMethod,
+        params.headers.xSFDCAllowContinuation,
+        isEmptyParam(params.body) ? '' : stableJSONStringify(params.body),
+    ].join(KEY_DELIM);
+}
+function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const recordId = keyBuilderFromResourceParams(resourceParams);
+    const select = {
+        recordId,
+        node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+        variables: {},
+    };
+    luvio.storeIngest(recordId, apexResponseIngest, body);
+    const snapshot = luvio.storeLookup(select, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (response.headers !== undefined && snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+        if (!(snapshot.state === 'Fulfilled' || snapshot.state === 'Stale')) {
+            throw new Error('Invalid resource response. Expected resource response to result in Fulfilled or Stale snapshot');
+        }
+    }
+    return snapshot;
+}
+function buildCachedSnapshotCachePolicy(buildSnapshotContext, storeLookup) {
+    const { config } = buildSnapshotContext;
+    const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
+    const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
+    return storeLookup({
+        recordId: recordId,
+        node: {
+            kind: 'Fragment',
+            opaque: true,
+            private: [],
+            version: APEX_VERSION,
+        },
+        variables: {},
+    });
+}
+function onFetchResponseSuccess(luvio, _config, resourceParams, response) {
+    const recordId = keyBuilderFromResourceParams(resourceParams);
+    const select = {
+        recordId,
+        node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+        variables: {},
+    };
+    if (shouldCache(response)) {
+        const snapshot = ingestSuccess(luvio, resourceParams, response);
+        return luvio.storeBroadcast().then(() => snapshot);
+    }
+    // if Cache-Control is not set or set to 'no-cache', return a synthetic snapshot
+    return Promise.resolve({
+        recordId,
+        variables: {},
+        seenRecords: new StoreKeySet(),
+        select,
+        state: 'Fulfilled',
+        data: response.body,
+    });
+}
+function onFetchResponseError(luvio, _config, _resourceParams, response) {
+    return Promise.resolve(luvio.errorSnapshot(response));
+}
+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), 
+        // TODO [W-10490362]: Properly generate response cache keys
+        () => {
+            return new StoreKeyMap();
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            sourceContext,
+        },
+        eventObservers,
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority,
+        };
+    }
+    return buildNetworkSnapshot(luvio, config, dispatchOptions);
+}
+function handleSnapshot(snapshot) {
+    if (snapshot.state === 'Error') {
+        throw snapshot.error;
+    }
+    return snapshot.data;
+}
+/**
+ * Returns a function that executes the supplied ldsAdapter,
+ * and handles unwrapping the snapshot to return to caller
+ *
+ * @param ldsAdapter adapter to be invoked
+ * @returns an ApexInvoker
+ */
+function invoker(ldsAdapter) {
+    return (config, requestContext) => {
+        const snapshotOrPromise = ldsAdapter(config, requestContext);
+        return Promise.resolve(snapshotOrPromise).then(handleSnapshot);
+    };
+}
+const invokerFactory = (luvio, invokerParams, adapterFactory) => {
+    const { namespace, classname, method, isContinuation } = invokerParams;
+    const ldsAdapter = adapterFactory(luvio, namespace, classname, method, isContinuation);
+    return invoker(ldsAdapter);
+};
+const postInvoker = (luvio, invokerParams) => {
+    return invokerFactory(luvio, invokerParams, postApexAdapterFactory);
+};
+const getInvoker = (luvio, invokerParams) => {
+    return invokerFactory(luvio, invokerParams, getApexAdapterFactory);
+};
+function postApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
+    return (config, requestContext) => {
+        // config validation is unnecessary for this imperative adapter
+        // due to the config being of type `any`.
+        // however, we have special config validation for the wire adapter,
+        // explanation in getApex
+        const configPlus = configBuilder(config, apexClassnameBuilder(namespace, classname), method, isContinuation);
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    };
+}
+
+/**
+ * Gets a field value from an Apex sObject.
+ * @param sobject The sObject holding the field.
+ * @param field The qualified API name of the field to return.
+ * @returns The field's value. If it doesn't exist, undefined is returned.
+ */
+function getSObjectValue(sObject, field) {
+    if (untrustedIsObject(sObject) === false) {
+        return;
+    }
+    const unqualifiedField = splitQualifiedFieldApiName(getFieldApiName(field))[1];
+    const fields = unqualifiedField.split('.');
+    let ret = sObject;
+    for (let i = 0, fieldsLength = fields.length; i < fieldsLength; i++) {
+        const nextField = fields[i];
+        if (!hasOwnProperty.call(ret, nextField)) {
+            return undefined;
+        }
+        ret = ret[nextField];
+    }
+    return ret;
+}
+
+const engineForPrefetcherMap = new Map();
+function registerPrefetcher(luvio, prefetcher) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (engineForPrefetcherMap.has(luvio)) {
+            throw new Error('Environment error: Only one prefetcher per engine is allowed.');
+        }
+    }
+    engineForPrefetcherMap.set(luvio, prefetcher);
+}
+
+export { getInvoker as GetApexInvoker, factory as GetApexWireAdapterFactory, postInvoker as PostApexInvoker, getSObjectValue, registerPrefetcher };

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

@@ -0,0 +1,62 @@
+import { Adapter as $64$luvio_engine_Adapter, Snapshot as $64$luvio_engine_Snapshot, UnfulfilledSnapshot as $64$luvio_engine_UnfulfilledSnapshot, AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata } from '@luvio/engine';
+export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
+declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export { ObjectCreate, ObjectKeys };
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayPrototypePush: (...items: any[]) => number;
+export interface AdapterValidationConfig {
+    displayName: string;
+    parameters: {
+        required: string[];
+        optional: string[];
+        unsupported?: string[];
+    };
+}
+/**
+ * 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.
+ */
+export declare function validateConfig<T>(config: Untrusted<T>, adapter: AdapterValidationConfig, oneOf?: string[]): void;
+export declare function untrustedIsObject<Base>(untrusted: unknown): untrusted is Untrusted<Base>;
+export type UncoercedConfiguration<Base, Options extends {
+    [key in keyof Base]?: any;
+}> = {
+    [Key in keyof Base]?: Base[Key] | Options[Key];
+};
+export type Untrusted<Base> = Partial<Base>;
+export declare function areRequiredParametersPresent<T>(config: any, configPropertyNames: AdapterValidationConfig): config is T;
+export declare function refreshable<C, D, R>(adapter: $64$luvio_engine_Adapter<C, D>, resolve: (config: unknown) => Promise<$64$luvio_engine_Snapshot<R>>): $64$luvio_engine_Adapter<C, D>;
+export declare const SNAPSHOT_STATE_FULFILLED = "Fulfilled";
+export declare const SNAPSHOT_STATE_UNFULFILLED = "Unfulfilled";
+export declare const snapshotRefreshOptions: {
+    overrides: {
+        headers: {
+            'Cache-Control': string;
+        };
+    };
+};
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function getFetchResponseStatusText(status: number): string;
+export declare function isUnfulfilledSnapshot<T, U>(snapshot: $64$luvio_engine_Snapshot<T, U>): snapshot is $64$luvio_engine_UnfulfilledSnapshot<T, U>;
+export declare function generateParamConfigMetadata(name: string, required: boolean, resourceType: $64$luvio_engine_AdapterConfigMetadata['resourceType'], typeCheckShape: $64$luvio_engine_AdapterConfigMetadata['typeCheckShape'], isArrayShape?: boolean, coerceFn?: (v: unknown) => unknown): $64$luvio_engine_AdapterConfigMetadata;
+export declare function buildAdapterValidationConfig(displayName: string, paramsMeta: $64$luvio_engine_AdapterConfigMetadata[]): AdapterValidationConfig;
+export declare const keyPrefix = "Apex";