@salesforce/lds-runtime-one-runtime 1.457.0

package/dist/types/network-fetch.d.ts

@@ -0,0 +1,51 @@
+import { type ResourceRequest } from '@luvio/engine';
+import type { RequestLogger } from '@salesforce/lds-network-fetch';
+import type { RequestTracker } from './instrumentation-utils';
+/**
+ * Public UIAPI url paths verified for HTTP transport.
+ *
+ * Inclusion criteria:
+ *   1. The path's underlying Connect resource does NOT carry
+ *      `clientFilters=@ConnectClientFilters({@ConnectClientFilter(key = "UiTier")...})`.
+ *   2. LDS actually invokes this URL via a Luvio adapter wired into
+ *      `ldsEngineCreator.js` (i.e. there is a corresponding `*AdapterFactory`
+ *      import). Connect resources with no LDS adapter are intentionally
+ *      excluded — adding them produces no traffic and just bloats the matcher.
+ *
+ * Where a single Connect resource exposes multiple URL shapes (e.g. a 4-segment
+ * GET form alongside a 3-segment POST form), all forms LDS adapters can hit at
+ * runtime are registered.
+ */
+export declare const UIAPI_PUBLIC_PATHS: string[];
+/**
+ * Private UIAPI url paths gated by the private-endpoint gates per runtime.
+ *
+ * Inclusion criteria:
+ *   1. The path's underlying Connect resource carries
+ *      `clientFilters=@ConnectClientFilters({@ConnectClientFilter(key = "UiTier")...})`,
+ *      which restricts callers to the UI tier (one.app / One Runtime / UISDK runtime) and
+ *      excludes the public REST API.
+ *   2. LDS actually invokes this URL via a Luvio adapter wired into
+ *      `ldsEngineCreator.js`.
+ */
+export declare const UIAPI_PRIVATE_PATHS: string[];
+/**
+ * Single content documents version URL enabled/disabled by killswitch.
+ * Exported for reuse in tests.
+ */
+export declare const CONTENT_DOCUMENTS_VERSIONS_PATH = "/ui-api/records/content-documents/content-versions";
+/**
+ * Indicates whether any predicate-enabled path sets are active.
+ * Used by adapter composition to decide whether to include the fetch adapter.
+ */
+export declare function isFetchAdapterEnabled(): boolean;
+export declare const instrumentationTracker: RequestTracker;
+export declare const requestLogger: RequestLogger;
+export declare const composedFetchNetworkAdapter: {
+    /**
+     * Handles only the enabled paths. The incoming path is normalized
+     * (trailing slash removed) before matching against the precomputed matchers.
+     */
+    shouldHandleRequest(resourceRequest: ResourceRequest): boolean;
+    adapter: import("@luvio/engine").NetworkAdapter;
+};

package/dist/types/network-instrumentation.d.ts

@@ -0,0 +1,2 @@
+import type { FetchResponse, ResourceRequest } from '@luvio/engine';
+export declare function checkAndLogCrudInteraction(request: ResourceRequest, isResolve: boolean, error: any, response?: FetchResponse<any>): void;

package/dist/types/network-sfap.d.ts

@@ -0,0 +1,18 @@
+import type { FetchResponse, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+import type { JwtResolver } from '@conduit-client/jwt-manager';
+export declare const SFAPController = "SalesforceApiPlatformController";
+export declare const SFAPJwtMethod = "getSFAPLightningJwtService";
+export declare const SFAPJwtPostMethod = "postSFAPLightningJwtService";
+export type ExtraInfo = {
+    baseUri: string;
+};
+/**
+ * Resolves Jwt token for SFAP by calling Aura action
+ * {@link JwtResolver} for platform SFAP
+ */
+export declare const platformSfapJwtResolver: JwtResolver<ExtraInfo>;
+declare const composedNetworkAdapter: {
+    shouldHandleRequest(resourceRequest: ResourceRequest): boolean;
+    adapter: (resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext) => Promise<FetchResponse<any>>;
+};
+export default composedNetworkAdapter;

package/dist/types/parameterized-sfap-jwt-aura-resolver.d.ts

@@ -0,0 +1,34 @@
+import type { JwtMintParams, JwtResolver } from '@conduit-client/jwt-manager';
+import { type ParameterizedSfapExtraInfo } from './sfap-jwt-mint-params';
+/**
+ * Parameterized SFAP JWT resolver that mints over **Aura transport** instead of a
+ * direct HTTP `fetch`.
+ *
+ * It dispatches the SFAP Lightning JWT Service's parameterized POST via its
+ * auto-generated Aura controller method
+ * `SalesforceApiPlatformController.postSFAPLightningJwtService` (generated by
+ * `@ConnectSignature(..., generateAuraMethod = true)` on the Connect resource).
+ * The mint inputs ride as the single `requestBody` named param, in the same
+ * `{ scopes, dynamicParameters: { items } }` shape the HTTP resolver POSTs — built
+ * by the shared {@link buildRequestBody}, so the two transports stay in lockstep.
+ *
+ * Why Aura (not the HTTP resolver): the mint endpoint is a same-origin core
+ * resource, and routing it over Aura keeps session/CSRF handling inside the Aura
+ * stack rather than issuing a credentialed cross-cutting `fetch` from the client.
+ * This mirrors the legacy parameterless `platformSfapJwtResolver` in
+ * `network-sfap.ts`, which already mints over Aura via the `getSFAPLightningJwtService`
+ * generated method — this is the parameterized sibling of that call.
+ *
+ * A `JwtResolver` is invoked directly by `JwtManager` (not through Luvio's
+ * `appRouter`/`ResourceRequest` pipeline), so the correct mechanism is a direct
+ * named-controller `dispatchAuraAction`, not the `auraNetworkAdapter`/connect-route
+ * table. The SFAP JWT endpoint is not registered as a connect-over-Aura route, and
+ * a resolver has no `ResourceRequest` for the router to look up.
+ */
+export declare class ParameterizedSfapJwtAuraResolver implements JwtResolver<ParameterizedSfapExtraInfo> {
+    getJwt(params?: JwtMintParams): Promise<{
+        jwt: string;
+        extraInfo: ParameterizedSfapExtraInfo;
+    }>;
+}
+export declare function buildParameterizedSfapJwtAuraResolver(): ParameterizedSfapJwtAuraResolver;

package/dist/types/predictive-loading/common/index.d.ts

@@ -0,0 +1,17 @@
+export declare const PDL_EXECUTE_ASYNC_OPTIONS: {
+    LOG_ERROR_ONLY: boolean;
+    ERROR_SCOPE: string;
+};
+export type RequestEntry<Request> = {
+    request: Request;
+    requestMetadata: {
+        requestTime: number;
+    };
+};
+/**
+ * Request and context-based Key data to be saved.
+ */
+export type SaveRequestData<Request, Context> = {
+    request: Request;
+    key: Context;
+};

package/dist/types/predictive-loading/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './pages';
+export * from './prefetcher';
+export * from './repository';
+export * from './request-runner';
+export * from './request-strategy';
+export * from './storage';

package/dist/types/predictive-loading/lex/index.d.ts

@@ -0,0 +1,17 @@
+import type { BaseAdapterRequest } from '../../predictive-loading';
+import type { DefaultPageContext, ObjectHomePageContext, RecordHomePageContext } from '../pages';
+/**
+ * Options for the predictive prefetcher.
+ */
+export type LexPrefetcherOptions = {
+    /**
+     * Limit on the number of requests that can be inflight at any given time.
+     */
+    inflightRequestLimit: number;
+};
+export { PredictionsReadyManager } from './predictions-ready-manager';
+export type LexRequest<Config = unknown> = BaseAdapterRequest<Config>;
+export type LexRequestOptions = {
+    disableHotspot?: boolean;
+};
+export type LexContext = RecordHomePageContext | ObjectHomePageContext | DefaultPageContext;

package/dist/types/predictive-loading/lex/predictions-ready-manager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Manages the state of predictions and notifies registered callbacks when predictions are ready.
+ */
+export declare class PredictionsReadyManager {
+    /**
+     * Array of callbacks to be executed when predictions are ready.
+     * @private
+     */
+    private predictionsReadyCallbacks;
+    /**
+     * Indicates whether the predictions are ready.
+     * @private
+     */
+    private predictionsReady;
+    /**
+     * Registers a callback to be called when predictions are ready.
+     * If predictions are already ready, the callback is invoked immediately.
+     *
+     * @param {() => void} callback - The callback function to be executed when predictions are ready.
+     */
+    whenPredictionsReady(callback: () => void): void;
+    /**
+     * Notifies that predictions are ready by invoking all registered callbacks.
+     */
+    notifyPredictionsReady(): void;
+    /**
+     * Retrieves the list of callbacks registered to be executed when predictions are ready.
+     *
+     * @returns {Array<() => void>} Array of callback functions.
+     */
+    getCallbacks(): Array<() => void>;
+}

package/dist/types/predictive-loading/pages/abstract-home-page.d.ts

@@ -0,0 +1,17 @@
+import { LexDefaultPage } from './lex-default-page';
+import type { LexRequest } from '../lex';
+import type { DefaultPageContext } from './lex-default-page';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+/**
+ * Base implementation of a home page
+ */
+export declare abstract class AbstractHomePage<HomePageContext extends DefaultPageContext> extends LexDefaultPage<LexRequest, HomePageContext> {
+    protected requestStrategyManager: RequestStrategyManager;
+    private supportedAdapters;
+    protected constructor(context: HomePageContext, similarContext: HomePageContext, requestStrategyManager: RequestStrategyManager, supportedAdapters: Set<string>);
+    supportsRequest(request: LexRequest): boolean;
+    buildSaveRequestData(request: LexRequest): {
+        key: HomePageContext;
+        request: LexRequest<unknown>;
+    }[];
+}

package/dist/types/predictive-loading/pages/index.d.ts

@@ -0,0 +1,4 @@
+export * from './predictive-prefetch-page';
+export * from './lex-default-page';
+export * from './record-home-page';
+export * from './object-home-page';

package/dist/types/predictive-loading/pages/lex-default-page.d.ts

@@ -0,0 +1,15 @@
+import type { BaseAdapterRequest } from '../request-strategy';
+import { PredictivePrefetchPage } from './predictive-prefetch-page';
+export type DefaultPageContext = Record<string, any>;
+export declare class LexDefaultPage<Request extends BaseAdapterRequest, Context extends DefaultPageContext> extends PredictivePrefetchPage<Request, Context> {
+    constructor(context: Context, similarContext?: Context);
+    supportsRequest(_request: Request): boolean;
+    buildSaveRequestData(request: Request): {
+        key: Context;
+        request: Request;
+    }[];
+    resolveSimilarRequest(similarRequest: Request): Request;
+    getAlwaysRunRequests(): Request[];
+    shouldReduceAlwaysRequestsWithPredictions(): boolean;
+    shouldExecuteAlwaysRequestByThemself(): boolean;
+}

package/dist/types/predictive-loading/pages/object-home-page.d.ts

@@ -0,0 +1,23 @@
+import type { LexRequest } from '../lex';
+import type { DefaultPageContext } from './lex-default-page';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import { AbstractHomePage } from './abstract-home-page';
+export type ObjectHomePageContext = {
+    objectApiName: string;
+    listViewApiName: string;
+    type: 'objectHomePage';
+};
+export declare const OBJECT_HOME_SUPPORTED_ADAPTERS: Set<string>;
+export declare class ObjectHomePage extends AbstractHomePage<ObjectHomePageContext> {
+    constructor(context: ObjectHomePageContext, requestStrategyManager: RequestStrategyManager);
+    getAlwaysRunRequests(): LexRequest[];
+    /**
+     * In OH, the always requests are reduced with predictions, and because they
+     * can't be merged with other predictions, they will always run by themself.
+     * This value must be `false`, otherwise we may see repeated requests.
+     *
+     * @returns false
+     */
+    shouldExecuteAlwaysRequestByThemself(): boolean;
+    static handlesContext(context: DefaultPageContext): context is ObjectHomePageContext;
+}

package/dist/types/predictive-loading/pages/predictive-prefetch-page.d.ts

@@ -0,0 +1,12 @@
+import type { SaveRequestData } from '../common';
+export declare abstract class PredictivePrefetchPage<Request, Context> {
+    protected context: Context;
+    protected similarContext?: Context | undefined;
+    protected constructor(context: Context, similarContext?: Context | undefined);
+    abstract supportsRequest(request: Request): boolean;
+    abstract buildSaveRequestData(request: Request): SaveRequestData<Request, Context>[];
+    abstract resolveSimilarRequest(similarRequest: Request): Request;
+    abstract getAlwaysRunRequests(): Request[];
+    getExactKey(): Context;
+    getSimilarKey(): Context;
+}

package/dist/types/predictive-loading/pages/record-home-page.d.ts

@@ -0,0 +1,26 @@
+import type { LexRequest } from '../lex';
+import type { DefaultPageContext } from './lex-default-page';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import { AbstractHomePage } from './abstract-home-page';
+export declare const RECORD_HOME_SUPPORTED_ADAPTERS: Set<string>;
+export type RecordHomePageContext = {
+    objectApiName: string;
+    recordId: string;
+    recordTypeId?: string;
+    actionName: string;
+    type: 'recordPage';
+};
+export declare class RecordHomePage extends AbstractHomePage<RecordHomePageContext> {
+    constructor(context: RecordHomePageContext, requestStrategyManager: RequestStrategyManager);
+    getExactKey(): RecordHomePageContext;
+    resolveSimilarRequest(similarRequest: LexRequest): LexRequest;
+    getAlwaysRunRequests(): LexRequest[];
+    /**
+     * In RH, we should execute the getRecord(id, type) by itself as we want the result asap, so
+     * it does not stop rendering.
+     * @returns true
+     */
+    shouldExecuteAlwaysRequestByThemself(): boolean;
+    static handlesContext(context: DefaultPageContext): context is RecordHomePageContext;
+    static contextToExactKey(context: RecordHomePageContext): RecordHomePageContext;
+}

package/dist/types/predictive-loading/prefetcher/events.d.ts

@@ -0,0 +1,25 @@
+import type { PredictivePrefetchPage } from '../pages';
+export declare enum PdlPrefetcherEventType {
+    STARTED_RECORDING = "started-recording",
+    STOPPED_RECORDING = "stopped-recording"
+}
+export type StartedRecordingEvent = {
+    type: PdlPrefetcherEventType.STARTED_RECORDING;
+    page: PredictivePrefetchPage<any, any>;
+};
+export type StoppedRecordingEvent = {
+    type: PdlPrefetcherEventType.STOPPED_RECORDING;
+    page: PredictivePrefetchPage<any, any>;
+};
+export type PrefetcherEvent = StartedRecordingEvent | StoppedRecordingEvent;
+export type PrefetcherEventMap = {
+    [PdlPrefetcherEventType.STARTED_RECORDING]: StartedRecordingEvent;
+    [PdlPrefetcherEventType.STOPPED_RECORDING]: StoppedRecordingEvent;
+};
+type ListenerFn<T extends PdlPrefetcherEventType> = (event: PrefetcherEventMap[T]) => void;
+export declare class PrefetcherEventEmitter {
+    private listeners;
+    subscribeTo<T extends PdlPrefetcherEventType>(type: T, listener: ListenerFn<T>): () => void;
+    emit<T extends PdlPrefetcherEventType>(event: PrefetcherEventMap[T]): void;
+}
+export {};

package/dist/types/predictive-loading/prefetcher/index.d.ts

@@ -0,0 +1,4 @@
+export * from './predictive-prefetcher';
+export * from './lex-predictive-prefetcher';
+export type { PrefetcherEvent, StartedRecordingEvent, StoppedRecordingEvent, PrefetcherEventMap, } from './events';
+export { PdlPrefetcherEventType } from './events';

package/dist/types/predictive-loading/prefetcher/lex-predictive-prefetcher.d.ts

@@ -0,0 +1,18 @@
+import { LexDefaultPage } from '../pages';
+import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
+import type { RequestRunner } from '../request-runner';
+import type { PrefetchRepository } from '../repository';
+import type { RequestEntry } from '../common';
+import type { LexContext, LexPrefetcherOptions, LexRequest } from '../lex';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import type { PrefetcherEventEmitter } from './events';
+export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher<LexRequest, LexContext, LexDefaultPage<LexRequest, LexContext>> {
+    protected options: LexPrefetcherOptions;
+    page: LexDefaultPage<LexRequest, LexContext>;
+    private requestStrategyManager;
+    constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, eventEmitter: PrefetcherEventEmitter, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
+    getPage(): LexDefaultPage<LexRequest, LexContext>;
+    getAllPageRequests(): RequestEntry<LexRequest>[];
+    getPredictedRequestsOrderedByPriority(): RequestEntry<LexRequest>[];
+    predict(): Promise<void>;
+}

package/dist/types/predictive-loading/prefetcher/predictive-prefetcher.d.ts

@@ -0,0 +1,38 @@
+import type { PrefetchRepository } from '../repository';
+import type { PredictivePrefetchPage } from '../pages';
+import type { RequestRunner } from '../request-runner';
+import type { BaseAdapterRequest } from '../request-strategy';
+import type { PrefetcherEventEmitter, PrefetcherEventMap } from './events';
+import { PdlPrefetcherEventType } from './events';
+export declare abstract class ApplicationPredictivePrefetcher<Request extends BaseAdapterRequest, Context extends Record<string, any>, Page extends PredictivePrefetchPage<Request, Context>> {
+    protected repository: PrefetchRepository<Request>;
+    protected requestRunner: RequestRunner<Request>;
+    protected eventEmitter: PrefetcherEventEmitter;
+    private _context;
+    isRecording: boolean;
+    totalRequestCount: Number;
+    page: Page;
+    queuedPredictionRequests: Request[];
+    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>, eventEmitter: PrefetcherEventEmitter);
+    abstract getPage(): Page;
+    set context(value: Context);
+    get context(): Context;
+    subscribeToEvent<T extends PdlPrefetcherEventType>(type: T, callback: (event: PrefetcherEventMap[T]) => void): () => void;
+    stopRecording(): Promise<void>;
+    startRecording(): void;
+    saveRequest(request: Request): void;
+    predict(): Promise<void>;
+    getPredictionSummary(): {
+        exact: number;
+        similar: number;
+        totalRequestCount: Number;
+    };
+    hasPredictions(): boolean;
+    getSimilarPageRequests(): {
+        request: Request;
+        requestMetadata: {
+            requestTime: number;
+        };
+    }[];
+    getExactPageRequests(): import("../common").RequestEntry<Request>[];
+}

package/dist/types/predictive-loading/prefetcher/utils.d.ts

@@ -0,0 +1,52 @@
+import type { RequestRunner } from '../request-runner';
+import type { RequestEntry } from '../common';
+import type { LexRequest, LexRequestOptions } from '../lex';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import type { DefaultPageContext } from '../pages';
+/**
+ * Runs a list of requests with a specified concurrency limit.
+ *
+ * @template Request - The type of the requests being processed.
+ * @param {RequestEntry<Request>[]} requests - An array of request entries to be processed in the array order.
+ * @param {RequestRunner<Request>} runner - The runner instance responsible for executing the requests.
+ * @param {number} concurrentRequestsLimit - The maximum number of concurrent requests allowed.
+ * @param {number} pageStartTime - The start time of the page load, used to calculate the time elapsed since the page starts loading.
+ * @returns {Promise<void>} A promise that resolves when all requests have been processed.
+ *
+ * This function manages a queue of pending requests and processes them with a concurrency limit.
+ * Requests are only processed if their `requestTime` is less than the time elapsed since `pageStartTime`.
+ */
+export declare function runRequestsWithLimit<Request>(requests: RequestEntry<Request>[], runner: RequestRunner<Request>, concurrentRequestsLimit: number, pageStartTime: number): Promise<void>;
+/**
+ * Runs entire list of LEX requests, applying hotspot up to the specified limit and disabling for all remaining
+ *
+ * @param {RequestEntry<LexRequest>[]} requests - An array of request entries to be processed in the array order.
+ * @param {RequestRunner<LexRequest, LexRequestOptions>} runner - The runner instance responsible for executing the requests.
+ * @param {number} hotspotLimit - The number of hotspot requests allowed.
+ * @returns {Promise<void>} A promise that resolves when all requests have been processed.
+ *
+ * This function processes a queue of pending requests, enabling hotspot for the first N requests,
+ * as specified by the hotspotLimit argument.  The remaining requests have hotspot disabled.
+ */
+export declare function runRequestsWithHotspotLimit(requests: RequestEntry<LexRequest>[], runner: RequestRunner<LexRequest, LexRequestOptions>, hotspotLimit: number): Promise<void>;
+/**
+ * Compares two request entries based on their priority and, if the priorities are the same, their request times.
+ * This function is typically used for sorting requests where priority takes precedence, and timing is used
+ * as a secondary criterion. The function assumes that any necessary filtering of requests has already been done.
+ *
+ * @template Context - Extends `DefaultPageContext`, provides additional context for the request priority determination.
+ *
+ * @param {RequestEntry<LexRequest>} requestA - The first request entry containing the request and its metadata.
+ * @param {RequestEntry<LexRequest>} requestB - The second request entry containing the request and its metadata.
+ * @param {RequestStrategyManager} requestStrategyManager - Manager that provides access to request strategies based on adapter names.
+ * @param {Context} context - The context in which the requests are being compared, used to determine request priority.
+ *
+ * @returns {number} A negative number if the first request should come before the second, a positive number if the
+ *                   second should come before the first, or zero if they are considered equal for sorting purposes.
+ *                   This is determined first by the priority (higher priority comes first) and then by the request
+ *                   time (earlier request comes first) if priorities are the same. The priorities are fetched from
+ *                   the `requestStrategyManager` for each request's `adapterName`. If a strategy is not found,
+ *                   the priority defaults to `RequestPriority.LOW`.
+ */
+export declare function compareByPriorityThenTime<Context extends DefaultPageContext = DefaultPageContext>({ request: requestA, requestMetadata: requestMetadataA }: RequestEntry<LexRequest>, { request: requestB, requestMetadata: requestMetadataB }: RequestEntry<LexRequest>, requestStrategyManager: RequestStrategyManager, context: Context): number;
+export declare function isUseHotspotLimitOpen(): boolean;

package/dist/types/predictive-loading/repository/index.d.ts

@@ -0,0 +1,2 @@
+export * from './prefetch-repository';
+export * from './utils';

package/dist/types/predictive-loading/repository/prefetch-repository.d.ts

@@ -0,0 +1,31 @@
+import type { PrefetchStorage } from '../storage';
+import type { RequestEntry } from '../common';
+type Key = Record<string, any>;
+export type History = {
+    version: '1.0';
+    pages: Key[];
+};
+export type PageEntry<Request> = {
+    id: string;
+    recordTypeId?: string;
+    requests: RequestEntry<Request>[];
+};
+export type PrefetchRepositoryOptions<Request> = {
+    modifyBeforeSaveHook?: (requests: RequestEntry<Request>[]) => RequestEntry<Request>[];
+    modifyPageBeforeSavingHook?: (page: PageEntry<Request>) => void;
+};
+export declare class PrefetchRepository<Request> {
+    private storage;
+    private options;
+    private requestBuffer;
+    constructor(storage: PrefetchStorage, options?: PrefetchRepositoryOptions<Request>);
+    clearRequestBuffer(): void;
+    pageStartTime: number;
+    markPageStart(): void;
+    flushRequestsToStorage(): Promise<void>;
+    getKeyId(key: Key): string;
+    saveRequest<Request>(key: Key, request: Request): void;
+    getPage(key: Key): PageEntry<Request> | undefined;
+    getPageRequests(key: Key): RequestEntry<Request>[];
+}
+export {};

package/dist/types/predictive-loading/repository/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 isObject(obj: any): obj is Record<string, unknown>;
+export declare function deepEquals(objA: any, objB: any): boolean;

package/dist/types/predictive-loading/request-runner/index.d.ts

@@ -0,0 +1,2 @@
+export * from './request-runner';
+export * from './lex-request-runner';

package/dist/types/predictive-loading/request-runner/lex-request-runner.d.ts

@@ -0,0 +1,10 @@
+import type { RequestRunner } from './request-runner';
+import type { RequestEntry } from '../common';
+import type { LexRequest, LexRequestOptions } from '../lex';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+export declare class LexRequestRunner implements RequestRunner<LexRequest, LexRequestOptions> {
+    private requestStrategyManager;
+    constructor(requestStrategyManager: RequestStrategyManager);
+    reduceRequests(requests: RequestEntry<LexRequest>[]): RequestEntry<LexRequest>[];
+    runRequest(request: LexRequest, options?: LexRequestOptions): Promise<void>;
+}

package/dist/types/predictive-loading/request-runner/request-runner.d.ts

@@ -0,0 +1,5 @@
+import type { RequestEntry } from '../common';
+export type RequestRunner<Request, Options = Record<string, any>> = {
+    runRequest(request: Request, options?: Options): Promise<void>;
+    reduceRequests(requests: RequestEntry<Request>[]): RequestEntry<Request>[];
+};

package/dist/types/predictive-loading/request-strategy/get-apex-request-strategy.d.ts

@@ -0,0 +1,30 @@
+import type { ApexInvokerParams } from '@salesforce/lds-adapters-apex';
+import type { AdapterRequestContext, Luvio } from '@luvio/engine';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import { RequestPriority } from './request-strategy';
+import type { LexRequestOptions } from '../lex';
+export type GetApexConfig = {
+    name: string;
+    invokerParams: ApexInvokerParams;
+    config: Record<string, any>;
+};
+export type GetApexRequest = {
+    adapterName: 'getApex';
+    config: GetApexConfig;
+};
+export declare function getApexPdlFactory(luvio: Luvio): ({ invokerParams, config }: GetApexConfig, requestContext?: AdapterRequestContext) => import("@luvio/engine").Snapshot<any> | Promise<import("@luvio/engine").Snapshot<any>> | null;
+type GetApexContext = Record<string, unknown>;
+export declare const GET_APEX_ADAPTER_NAME = "getApex";
+export declare class GetApexRequestStrategy extends LuvioAdapterRequestStrategy<GetApexConfig, GetApexRequest, GetApexContext> {
+    adapterName: string;
+    adapterFactory: typeof getApexPdlFactory;
+    buildConcreteRequest(similarRequest: GetApexRequest): GetApexRequest;
+    protected createAdapterContext(_options: LexRequestOptions): {
+        sourceContext: {
+            actionConfig: undefined;
+            tagName: string;
+        };
+    };
+    getRequestPriority(_request: GetApexRequest, _context: GetApexContext): RequestPriority;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-list-info-by-name-request-strategy.d.ts

@@ -0,0 +1,19 @@
+import type { GetListInfoByNameConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetListInfoByNameRequest = {
+    adapterName: 'getListInfoByName';
+    config: GetListInfoByNameConfig;
+};
+export declare const GET_LIST_INFO_BY_NAME_ADAPTER_NAME = "getListInfoByName";
+export type GetListInfoByNameContext = {
+    objectApiName: string;
+    listViewApiName: string;
+};
+export declare class GetListInfoByNameRequestStrategy extends LuvioAdapterRequestStrategy<GetListInfoByNameConfig, GetListInfoByNameRequest, GetListInfoByNameContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetListInfoByNameConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ListInfoRepresentation").ListInfoRepresentation>;
+    buildConcreteRequest(similarRequest: GetListInfoByNameRequest): GetListInfoByNameRequest;
+    transformForSave(request: GetListInfoByNameRequest): GetListInfoByNameRequest;
+    canCombine(reqA: GetListInfoByNameConfig, reqB: GetListInfoByNameConfig): boolean;
+    combineRequests(reqA: GetListInfoByNameConfig, _reqB: GetListInfoByNameConfig): GetListInfoByNameConfig;
+}

package/dist/types/predictive-loading/request-strategy/get-list-infos-by-object-name-request-strategy.d.ts

@@ -0,0 +1,19 @@
+import type { GetListInfosByObjectNameConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetListInfosByObjectNameRequest = {
+    adapterName: 'getListInfosByObjectName';
+    config: GetListInfosByObjectNameConfig;
+};
+export declare const GET_LIST_INFOS_BY_OBJECT_NAME_ADAPTER_NAME = "getListInfosByObjectName";
+export type GetListInfosByObjectNameContext = {
+    objectApiName: string;
+    listViewApiName: string;
+};
+export declare class GetListInfosByObjectNameRequestStrategy extends LuvioAdapterRequestStrategy<GetListInfosByObjectNameConfig, GetListInfosByObjectNameRequest, GetListInfosByObjectNameContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetListInfosByObjectNameConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ListInfoSummaryCollectionRepresentation").ListInfoSummaryCollectionRepresentation>;
+    buildConcreteRequest(similarRequest: GetListInfosByObjectNameRequest): GetListInfosByObjectNameRequest;
+    transformForSave(request: GetListInfosByObjectNameRequest): GetListInfosByObjectNameRequest;
+    canCombine(reqA: GetListInfosByObjectNameConfig, reqB: GetListInfosByObjectNameConfig): boolean;
+    combineRequests(reqA: GetListInfosByObjectNameConfig, _reqB: GetListInfosByObjectNameConfig): GetListInfosByObjectNameConfig;
+}

package/dist/types/predictive-loading/request-strategy/get-list-object-info-request-strategy.d.ts

@@ -0,0 +1,18 @@
+import type { GetListObjectInfoConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetListObjectInfoRequest = {
+    adapterName: 'getListObjectInfo';
+    config: GetListObjectInfoConfig;
+};
+export declare const GET_LIST_OBJECT_INFO_ADAPTER_NAME = "getListObjectInfo";
+export type GetListObjectInfoContext = {
+    objectApiName: string;
+};
+export declare class GetListObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy<GetListObjectInfoConfig, GetListObjectInfoRequest, GetListObjectInfoContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetListObjectInfoConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ListObjectInfoRepresentation").ListObjectInfoRepresentation>;
+    buildConcreteRequest(similarRequest: GetListObjectInfoRequest): GetListObjectInfoRequest;
+    transformForSave(request: GetListObjectInfoRequest): GetListObjectInfoRequest;
+    canCombine(reqA: GetListObjectInfoConfig, reqB: GetListObjectInfoConfig): boolean;
+    combineRequests(reqA: GetListObjectInfoConfig, _reqB: GetListObjectInfoConfig): GetListObjectInfoConfig;
+}

package/dist/types/predictive-loading/request-strategy/get-list-records-by-name-request-strategy.d.ts

@@ -0,0 +1,19 @@
+import type { GetListRecordsByNameConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetListRecordsByNameRequest = {
+    adapterName: 'getListRecordsByName';
+    config: GetListRecordsByNameConfig;
+};
+export declare const GET_LIST_RECORDS_BY_NAME_ADAPTER_NAME = "getListRecordsByName";
+export type GetListRecordsByNameContext = {
+    objectApiName: string;
+    listViewApiName: string;
+};
+export declare class GetListRecordsByNameRequestStrategy extends LuvioAdapterRequestStrategy<GetListRecordsByNameConfig, GetListRecordsByNameRequest, GetListRecordsByNameContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetListRecordsByNameConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ListRecordCollectionRepresentation").ListRecordCollectionRepresentation>;
+    buildConcreteRequest(similarRequest: GetListRecordsByNameRequest): GetListRecordsByNameRequest;
+    transformForSave(request: GetListRecordsByNameRequest): GetListRecordsByNameRequest;
+    canCombine(reqA: GetListRecordsByNameConfig, reqB: GetListRecordsByNameConfig): boolean;
+    combineRequests(reqA: GetListRecordsByNameConfig, _reqB: GetListRecordsByNameConfig): GetListRecordsByNameConfig;
+}