@salesforce/lds-adapters-platform-mobilepublisher 0.1.0-dev1

package/LICENSE.txt

@@ -0,0 +1,82 @@
+Terms of Use
+
+Copyright 2022 Salesforce, Inc. All rights reserved.
+
+These Terms of Use govern the download, installation, and/or use of this
+software provided by Salesforce, Inc. ("Salesforce") (the "Software"), were
+last updated on April 15, 2022, and constitute a legally binding
+agreement between you and Salesforce. If you do not agree to these Terms of
+Use, do not install or use the Software.
+
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free
+copyright license to reproduce, prepare derivative works of, publicly
+display, publicly perform, sublicense, and distribute the Software and
+derivative works subject to these Terms. These Terms shall be included in
+all copies or substantial portions of the Software.
+
+Subject to the limited rights expressly granted hereunder, Salesforce
+reserves all rights, title, and interest in and to all intellectual
+property subsisting in the Software. No rights are granted to you hereunder
+other than as expressly set forth herein. Users residing in countries on
+the United States Office of Foreign Assets Control sanction list, or which
+are otherwise subject to a US export embargo, may not use the Software.
+
+Implementation of the Software may require development work, for which you
+are responsible. The Software may contain bugs, errors and
+incompatibilities and is made available on an AS IS basis without support,
+updates, or service level commitments.
+
+Salesforce reserves the right at any time to modify, suspend, or
+discontinue, the Software (or any part thereof) with or without notice. You
+agree that Salesforce shall not be liable to you or to any third party for
+any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or
+proceeding made or brought against Salesforce by a third party arising out
+of or accruing from (a) your use of the Software, and (b) any application
+you develop with the Software that infringes any copyright, trademark,
+trade secret, trade dress, patent, or other intellectual property right of
+any person or defames any person or violates their rights of publicity or
+privacy (each a "Claim Against Salesforce"), and will indemnify Salesforce
+from any damages, attorney fees, and costs finally awarded against
+Salesforce as a result of, or for any amounts paid by Salesforce under a
+settlement approved by you in writing of, a Claim Against Salesforce,
+provided Salesforce (x) promptly gives you written notice of the Claim
+Against Salesforce, (y) gives you sole control of the defense and
+settlement of the Claim Against Salesforce (except that you may not settle
+any Claim Against Salesforce unless it unconditionally releases Salesforce
+of all liability), and (z) gives you all reasonable assistance, at your
+expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT
+SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES,
+INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA,
+OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN
+CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of
+the State of California, without regard to its conflicts of laws
+rules. Each party hereby consents to the exclusive jurisdiction of the
+state and federal courts located in San Francisco County, California to
+adjudicate any dispute arising out of or relating to these Terms of Use and
+the download, installation, and/or use of the Software. Except as expressly
+stated herein, these Terms of Use constitute the entire agreement between
+the parties, and supersede all prior and contemporaneous agreements,
+proposals, or representations, written or oral, concerning their subject
+matter. No modification, amendment, or waiver of any provision of these
+Terms of Use shall be effective unless it is by an update to these Terms of
+Use that Salesforce makes available, or is in writing and signed by the
+party against whom the modification, amendment, or waiver is to be
+asserted.
+
+Data Privacy: Salesforce may collect, process, and store device,
+system, and other information related to your use of the Software. This
+information includes, but is not limited to, IP address, user metrics, and
+other data ("Usage Data"). Salesforce may use Usage Data for analytics,
+product development, and marketing purposes. You acknowledge that files
+generated in conjunction with the Software may contain sensitive or
+confidential data, and you are solely responsible for anonymizing and
+protecting such data.

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

@@ -0,0 +1,275 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1, typeCheckConfig as typeCheckConfig$1, StoreKeyMap, createResourceParams as createResourceParams$1 } from '@luvio/engine';
+
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+function validateConfig(config, adapter, oneOf) {
+    const { displayName } = adapter;
+    const { required, optional, unsupported } = adapter.parameters;
+    if (config === undefined ||
+        required.every(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify ${required.sort().join(', ')}`);
+    }
+    if (oneOf && oneOf.some(req => ObjectPrototypeHasOwnProperty.call(config, req)) === false) {
+        throw new TypeError(`adapter ${displayName} configuration must specify one of ${oneOf.sort().join(', ')}`);
+    }
+    if (unsupported !== undefined &&
+        unsupported.some(req => ObjectPrototypeHasOwnProperty.call(config, req))) {
+        throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
+    }
+    const supported = required.concat(optional);
+    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+        throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
+    }
+}
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+}
+function areRequiredParametersPresent(config, configPropertyNames) {
+    return configPropertyNames.parameters.required.every(req => req in config);
+}
+const snapshotRefreshOptions = {
+    overrides: {
+        headers: {
+            'Cache-Control': 'no-cache',
+        },
+    }
+};
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = 'MobilePublisher';
+
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const TTL = 100;
+const VERSION = "9ea1c4910ff2c7f0401deb55b7799bb6";
+function validate(obj, path = 'MobilePublisherContainerOneTimeLoginUrlOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_oneTimeLoginUrl = obj.oneTimeLoginUrl;
+        const path_oneTimeLoginUrl = path + '.oneTimeLoginUrl';
+        if (typeof obj_oneTimeLoginUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_oneTimeLoginUrl + '" (at "' + path_oneTimeLoginUrl + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'MobilePublisherContainerOneTimeLoginUrlOutputRepresentation';
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function MobilePublisherContainerOneTimeLoginUrlOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function MobilePublisherContainerOneTimeLoginUrlOutputRepresentationIngest(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, "MobilePublisher", 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 + '::MobilePublisherContainerOneTimeLoginUrlOutputRepresentation:(' + 'consumerKey:' + params.queryParams.consumerKey + ')';
+}
+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/mobilepublisher/container/onetimeloginurl',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'getMobilePublisherContainerOneTimeLoginUrl';
+const getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('consumerKey', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$1(getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$1(untrustedConfig, config, getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getMobilePublisherContainerOneTimeLoginUrlAdapterFactory = (luvio) => function MobilePublisher__getMobilePublisherContainerOneTimeLoginUrl(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+export { getMobilePublisherContainerOneTimeLoginUrlAdapterFactory };

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 = "MobilePublisher";

package/dist/es/es2018/types/src/generated/adapters/getMobilePublisherContainerOneTimeLoginUrl.d.ts

@@ -0,0 +1,27 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ResourceRequestConfig as resources_getConnectMobilepublisherContainerOnetimeloginurl_ResourceRequestConfig } from '../resources/getConnectMobilepublisherContainerOnetimeloginurl';
+import { MobilePublisherContainerOneTimeLoginUrlOutputRepresentation as types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation } from '../types/MobilePublisherContainerOneTimeLoginUrlOutputRepresentation';
+export declare const adapterName = "getMobilePublisherContainerOneTimeLoginUrl";
+export declare const getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetMobilePublisherContainerOneTimeLoginUrlConfig {
+    consumerKey?: string;
+}
+export declare const createResourceParams: (config: GetMobilePublisherContainerOneTimeLoginUrlConfig) => resources_getConnectMobilepublisherContainerOnetimeloginurl_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetMobilePublisherContainerOneTimeLoginUrlConfig>): adapter$45$utils_Untrusted<GetMobilePublisherContainerOneTimeLoginUrlConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetMobilePublisherContainerOneTimeLoginUrlConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig): $64$luvio_engine_Snapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig, resourceParams: resources_getConnectMobilepublisherContainerOnetimeloginurl_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig, resourceParams: resources_getConnectMobilepublisherContainerOnetimeloginurl_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetMobilePublisherContainerOneTimeLoginUrlConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetMobilePublisherContainerOneTimeLoginUrlConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation>): $64$luvio_engine_Snapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, any>;
+export declare const getMobilePublisherContainerOneTimeLoginUrlAdapterFactory: $64$luvio_engine_AdapterFactory<GetMobilePublisherContainerOneTimeLoginUrlConfig, types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -0,0 +1 @@
+export { getMobilePublisherContainerOneTimeLoginUrlAdapterFactory } from '../adapters/getMobilePublisherContainerOneTimeLoginUrl';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -0,0 +1,3 @@
+declare let getMobilePublisherContainerOneTimeLoginUrl: any;
+declare let getMobilePublisherContainerOneTimeLoginUrl_imperative: any;
+export { getMobilePublisherContainerOneTimeLoginUrl, getMobilePublisherContainerOneTimeLoginUrl_imperative, };

package/dist/es/es2018/types/src/generated/resources/getConnectMobilepublisherContainerOnetimeloginurl.d.ts

@@ -0,0 +1,15 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { MobilePublisherContainerOneTimeLoginUrlOutputRepresentation as types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation } from '../types/MobilePublisherContainerOneTimeLoginUrlOutputRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        consumerKey?: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation_MobilePublisherContainerOneTimeLoginUrlOutputRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,29 @@
+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 = 100;
+export declare const VERSION = "9ea1c4910ff2c7f0401deb55b7799bb6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, existing: MobilePublisherContainerOneTimeLoginUrlOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MobilePublisherContainerOneTimeLoginUrlOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: MobilePublisherContainerOneTimeLoginUrlOutputRepresentationNormalized, incoming: MobilePublisherContainerOneTimeLoginUrlOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MobilePublisherContainerOneTimeLoginUrlOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of Response
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MobilePublisherContainerOneTimeLoginUrlOutputRepresentationNormalized {
+    /** One Time Login Url */
+    oneTimeLoginUrl: string;
+}
+/**
+ * Details of Response
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MobilePublisherContainerOneTimeLoginUrlOutputRepresentation {
+    oneTimeLoginUrl: 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,66 @@
+{
+    "name": "@salesforce/lds-adapters-platform-mobilepublisher",
+    "version": "0.1.0-dev1",
+    "description": "Mobile Publisher API Family",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "main": "dist/es/es2018/platform-mobilepublisher.js",
+    "module": "dist/es/es2018/platform-mobilepublisher.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/platform-mobilepublisher.js",
+            "require": "./dist/es/es2018/platform-mobilepublisher.js"
+        },
+        "./sfdc": {
+            "types": "./sfdc/index.d.ts",
+            "import": "./sfdc/index.js",
+            "default": "./sfdc/index.js"
+        }
+    },
+    "sfdc": {
+        "namespace": "lightning",
+        "module": "platformMobilepublisherApi"
+    },
+    "contributors": [
+        "jeff.lai@salesforce.com"
+    ],
+    "scripts": {
+        "build": "yarn build:services",
+        "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",
+        "release:core": "../../scripts/release/core.js --adapter=lds-adapters-platform-mobilepublisher",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --adapter=lds-adapters-platform-mobilepublisher",
+        "test:unit": "jest"
+    },
+    "dependencies": {
+        "@salesforce/lds-bindings": "^0.1.0-dev1"
+    },
+    "devDependencies": {
+        "@salesforce/lds-compiler-plugins": "^0.1.0-dev1"
+    },
+    "nx": {
+        "targets": {
+            "build": {
+                "outputs": [
+                    "{projectRoot}/dist",
+                    "{projectRoot}/sfdc"
+                ]
+            },
+            "build:raml": {
+                "outputs": [
+                    "{projectRoot}/src/generated"
+                ]
+            }
+        }
+    },
+    "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,313 @@
+/**
+ * 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 = 'MobilePublisher';
+
+const { isArray: ArrayIsArray } = Array;
+const { stringify: JSONStringify } = JSON;
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const TTL = 100;
+const VERSION = "9ea1c4910ff2c7f0401deb55b7799bb6";
+function validate(obj, path = 'MobilePublisherContainerOneTimeLoginUrlOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_oneTimeLoginUrl = obj.oneTimeLoginUrl;
+        const path_oneTimeLoginUrl = path + '.oneTimeLoginUrl';
+        if (typeof obj_oneTimeLoginUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_oneTimeLoginUrl + '" (at "' + path_oneTimeLoginUrl + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'MobilePublisherContainerOneTimeLoginUrlOutputRepresentation';
+function normalize(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$1 = function MobilePublisherContainerOneTimeLoginUrlOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        opaque: true
+    };
+};
+function equals(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest = function MobilePublisherContainerOneTimeLoginUrlOutputRepresentationIngest(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, "MobilePublisher", 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 + '::MobilePublisherContainerOneTimeLoginUrlOutputRepresentation:(' + 'consumerKey:' + params.queryParams.consumerKey + ')';
+}
+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/mobilepublisher/container/onetimeloginurl',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName = 'getMobilePublisherContainerOneTimeLoginUrl';
+const getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('consumerKey', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$1(getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata);
+function keyBuilder(luvio, config) {
+    const resourceParams = createResourceParams(config);
+    return keyBuilder$1(luvio, resourceParams);
+}
+function typeCheckConfig(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$1(untrustedConfig, config, getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams(config);
+    return select();
+}
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getMobilePublisherContainerOneTimeLoginUrlAdapterFactory = (luvio) => function MobilePublisher__getMobilePublisherContainerOneTimeLoginUrl(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getMobilePublisherContainerOneTimeLoginUrl_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+
+let getMobilePublisherContainerOneTimeLoginUrl;
+// Imperative GET Adapters
+let getMobilePublisherContainerOneTimeLoginUrl_imperative;
+// Adapter Metadata
+const getMobilePublisherContainerOneTimeLoginUrlMetadata = {
+    apiFamily: 'MobilePublisher',
+    name: 'getMobilePublisherContainerOneTimeLoginUrl',
+    ttl: 100,
+};
+// Notify Update Available
+function bindExportsTo(luvio) {
+    // LDS Adapters
+    const getMobilePublisherContainerOneTimeLoginUrl_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getMobilePublisherContainerOneTimeLoginUrl', getMobilePublisherContainerOneTimeLoginUrlAdapterFactory), getMobilePublisherContainerOneTimeLoginUrlMetadata);
+    return {
+        getMobilePublisherContainerOneTimeLoginUrl: createWireAdapterConstructor(luvio, getMobilePublisherContainerOneTimeLoginUrl_ldsAdapter, getMobilePublisherContainerOneTimeLoginUrlMetadata),
+        // Imperative GET Adapters
+        getMobilePublisherContainerOneTimeLoginUrl_imperative: createImperativeAdapter(luvio, getMobilePublisherContainerOneTimeLoginUrl_ldsAdapter, getMobilePublisherContainerOneTimeLoginUrlMetadata),
+        // Notify Update Availables
+    };
+}
+withDefaultLuvio((luvio) => {
+    ({
+        getMobilePublisherContainerOneTimeLoginUrl,
+        getMobilePublisherContainerOneTimeLoginUrl_imperative,
+    } = bindExportsTo(luvio));
+});
+
+export { getMobilePublisherContainerOneTimeLoginUrl, getMobilePublisherContainerOneTimeLoginUrl_imperative };
+// version: 0.1.0-dev1-c978a7b010

package/src/raml/api.raml

@@ -0,0 +1,153 @@
+#%RAML 1.0
+securedBy:
+  - OAuth2
+title: Salesforce Connect API
+version: '65.0'
+mediaType: application/json
+protocols:
+  - https
+baseUri: /services/data/v66.0
+securitySchemes:
+  OAuth2:
+    type: OAuth 2.0
+    settings:
+      authorizationUri: https://example.com/oauth/authorize
+      accessTokenUri: ''
+      authorizationGrants:
+        - implicit
+annotationTypes:
+  oas-readOnly:
+    type: boolean
+    allowedTargets: TypeDeclaration
+  oas-collectionFormat:
+    type: string
+  oas-body-name:
+    type: string
+    allowedTargets: TypeDeclaration
+types:
+  #  the types commented out below should not be exposed as as wire adapterss
+  #  ErrorInputRepresentation:
+  #    description: The input representation for Error
+  #    type: object
+  #    properties:
+  #      errorCode:
+  #        description: Error code is required
+  #        type: string
+  #      errorMsg:
+  #        description: Error Message is required
+  #        type: string
+  MobilePublisherContainerOneTimeLoginUrlOutputRepresentation:
+    description: Details of Response
+    type: object
+    properties:
+      oneTimeLoginUrl:
+        description: One Time Login Url
+        type: string
+#  MobilePublisherInputRepresentation:
+#    description: The input representation for Mobile Publisher Update Metadata
+#    type: object
+#    properties:
+#      errors:
+#        description: Error is optional
+#        type: array
+#        items:
+#          type: object
+#      metadataId:
+#        description: MetadataId is required
+#        type: string
+#      status:
+#        description: status is required
+#        type: string
+#  MobilePublisherOutputRepresentation:
+#    description: Details of Response
+#    type: object
+#    properties: {}
+#  MobilePublisherServiceAccountAuthRepresentation:
+#    description: Mobile Publisher Service Account Auth
+#    type: object
+#    properties:
+#      auth_provider_x509_cert_url:
+#        description: Auth Provider X509 Cert Url
+#        type: string
+#      auth_uri:
+#        description: Auth Uri
+#        type: string
+#      client_email:
+#        description: Client Email
+#        type: string
+#      client_id:
+#        description: Client Id
+#        type: string
+#      client_x509_cert_url:
+#        description: Client X509 Cert Url
+#        type: string
+#      private_key:
+#        description: Private Key
+#        type: string
+#      private_key_id:
+#        description: Private Key Id
+#        type: string
+#      project_id:
+#        description: Project Id
+#        type: string
+#      token_uri:
+#        description: Token Uri
+#        type: string
+#      type:
+#        description: Type
+#        type: string
+#  MobilePublisherStoreCredentialsOutputRepresentation:
+#    description: Details of Response
+#    type: object
+#    properties:
+#      serviceAccountAuth:
+#        description: Service Account Auth Data
+#        type: MobilePublisherServiceAccountAuthRepresentation
+#      storeIdentifier:
+#        description: Store Identifier
+#        type: string
+/connect/mobilepublisher:
+  #  the end points commented out below should not be exposed as as wire adapters
+  #  /buildstatus:
+  #    post:
+  #      displayName: postMobilePublisher
+  #      description: Update the mobile publisher metadata status, error
+  #      responses:
+  #        '200':
+  #          description: Success
+  #          body:
+  #            application/json:
+  #              type: MobilePublisherOutputRepresentation
+  #      body:
+  #        application/json:
+  #          type: MobilePublisherInputRepresentation
+  # TODO hand-rolled W-9271732 (removed required: false)
+  #          (oas-body-name): MobilePublisherInputRepresentation
+  /container/onetimeloginurl:
+    get:
+      displayName: getMobilePublisherContainerOneTimeLoginUrl
+      description: Retrieve Mobile Publisher Container One Time Login Url
+      responses:
+        '200':
+          description: Success
+          body:
+            application/json:
+              type: MobilePublisherContainerOneTimeLoginUrlOutputRepresentation
+      queryParameters:
+        consumerKey:
+          type: string
+          required: false
+#  /storecredentials:
+#   get:
+#      displayName: getMobilePublisherStoreCredentials
+#      description: Retrieve Mobile Publisher Store Credentials
+#      responses:
+#        '200':
+#          description: Success
+#          body:
+#            application/json:
+#              type: MobilePublisherStoreCredentialsOutputRepresentation
+#      queryParameters:
+#        metadataId:
+#          type: string
+#          required: false

package/src/raml/luvio.raml

@@ -0,0 +1,18 @@
+#%RAML 1.0 Overlay
+extends: ./api.raml
+
+uses:
+  luvio: luvio://annotations.raml
+
+(luvio.keyPrefix): 'MobilePublisher'
+
+types:
+  MobilePublisherContainerOneTimeLoginUrlOutputRepresentation:
+    # using the ttl value 100 to prevent the response from being cached, this login url result should not be cached because the login url is only valid for 60 seconds and each user will need to get a different login url generated
+    (luvio.ttl): 100
+    (luvio.opaque): true
+
+/connect/mobilepublisher/container/onetimeloginurl:
+  get:
+    (luvio.adapter):
+      name: getMobilePublisherContainerOneTimeLoginUrl