@salesforce/lds-runtime-aura 0.1.0-dev1

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/index.d.ts

@@ -0,0 +1,2 @@
+export * from './predictive-prefetcher';
+export * from './lex-predictive-prefetcher';

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

@@ -0,0 +1,17 @@
+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';
+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>, 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,34 @@
+import type { PrefetchRepository } from '../repository';
+import type { PredictivePrefetchPage } from '../pages';
+import type { RequestRunner } from '../request-runner';
+import type { BaseAdapterRequest } from '../request-strategy';
+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>;
+    private _context;
+    isRecording: boolean;
+    totalRequestCount: Number;
+    page: Page;
+    queuedPredictionRequests: Request[];
+    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>);
+    abstract getPage(): Page;
+    set context(value: Context);
+    get context(): Context;
+    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-components-request-strategy.d.ts

@@ -0,0 +1,31 @@
+import { LexRequestStrategy } from './lex-request-strategy';
+type DescriptorsMap = Record<string, unknown | string | undefined>;
+type NormalizedDescriptorsMap = Record<string, string>;
+export type GetComponentsRequest = {
+    adapterName: 'getComponentsDef';
+    config: DescriptorsMap;
+};
+export type NormalizedGetComponentsRequest = {
+    adapterName: 'getComponentsDef';
+    config: NormalizedDescriptorsMap;
+};
+export type GetComponentsContext = {
+    objectApiName: string;
+};
+export declare const GET_COMPONENTS_DEF_ADAPTER_NAME = "getComponentsDef";
+export declare class GetComponentsDefStrategy extends LexRequestStrategy<DescriptorsMap, GetComponentsRequest, GetComponentsContext> {
+    adapterName: string;
+    execute(config: NormalizedDescriptorsMap): void;
+    buildConcreteRequest(similarRequest: GetComponentsRequest, _context: GetComponentsContext): GetComponentsRequest;
+    transformForSave(request: GetComponentsRequest): NormalizedGetComponentsRequest;
+    canCombine(): boolean;
+    combineRequests(reqA: NormalizedDescriptorsMap, reqB: NormalizedDescriptorsMap): NormalizedDescriptorsMap;
+    isContextDependent(_context: GetComponentsContext, _request: GetComponentsRequest): boolean;
+    /**
+     * Component predictions are not boxcared
+     *
+     * @returns false
+     */
+    get isBoxcarable(): boolean;
+}
+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;
+}

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

@@ -0,0 +1,26 @@
+import type { GetObjectInfoConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { RequestEntry } from '../common';
+import type { BaseAdapterRequest } from './request-strategy';
+export type GetObjectInfoRequest = {
+    adapterName: 'getObjectInfo';
+    config: GetObjectInfoConfig;
+};
+export type GetObjectInfoContext = {
+    objectApiName: string;
+};
+export declare const GET_OBJECT_INFO_ADAPTER_NAME = "getObjectInfo";
+export declare class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy<GetObjectInfoConfig, GetObjectInfoRequest, GetObjectInfoContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetObjectInfoConfig, import("@salesforce/lds-adapters-uiapi").ObjectInfoRepresentation>;
+    buildConcreteRequest(similarRequest: GetObjectInfoRequest, context: GetObjectInfoContext): GetObjectInfoRequest;
+    transformForSave(request: GetObjectInfoRequest): GetObjectInfoRequest;
+    isContextDependent(context: GetObjectInfoContext, request: GetObjectInfoRequest): boolean;
+    /**
+     * This method returns GetObjectInfoRequest[] that won't be part of a batch (getObjectInfos) request.
+     *
+     * @param unfilteredRequests all prediction requests
+     * @returns
+     */
+    reduce(unfilteredRequests: RequestEntry<BaseAdapterRequest<unknown>>[]): RequestEntry<GetObjectInfoRequest>[];
+}

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

@@ -0,0 +1,25 @@
+import type { GetObjectInfosConfig } from '@salesforce/lds-adapters-uiapi';
+import type { RequestEntry } from '../common';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { BaseAdapterRequest } from './request-strategy';
+export type GetObjectInfosRequest = {
+    adapterName: 'getObjectInfos';
+    config: GetObjectInfosConfig;
+};
+export declare const GET_OBJECT_INFO_BATCH_ADAPTER_NAME = "getObjectInfos";
+type GetObjectInfosContext = Record<string, unknown>;
+export declare class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy<GetObjectInfosConfig, GetObjectInfosRequest, GetObjectInfosContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetObjectInfosConfig, import("@salesforce/lds-adapters-uiapi").SimplifiedBatchRepresentation>;
+    buildConcreteRequest(similarRequest: GetObjectInfosRequest): GetObjectInfosRequest;
+    transformForSave(request: GetObjectInfosRequest): GetObjectInfosRequest;
+    /**
+     * Reduces the given GetObjectInfosRequest requests by eliminating those for which config.objectApiNames
+     * is a subset of another GetObjectInfosRequest.
+     *
+     * @param unfilteredRequests - Array of unfiltered requests
+     * @returns RequestEntry<GetObjectInfosRequest>[] - Array of reduced requests
+     */
+    reduce(unfilteredRequests: RequestEntry<BaseAdapterRequest<unknown>>[]): RequestEntry<GetObjectInfosRequest>[];
+}
+export {};

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

@@ -0,0 +1,20 @@
+import type { GetRecordActionsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRecordActionsRequest = {
+    adapterName: 'getRecordActions';
+    config: GetRecordActionsConfig;
+};
+type GetRecordActionsContext = {
+    recordId: string;
+};
+export declare const GET_RECORD_ACTIONS_ADAPTER_NAME = "getRecordActions";
+export declare class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordActionsConfig, GetRecordActionsRequest, GetRecordActionsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordActionsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ActionRepresentation").ActionRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordActionsRequest, context: GetRecordActionsContext): GetRecordActionsRequest;
+    transformForSaveSimilarRequest(request: GetRecordActionsRequest): GetRecordActionsRequest;
+    canCombine(reqA: GetRecordActionsConfig, reqB: GetRecordActionsConfig): boolean;
+    combineRequests(reqA: GetRecordActionsConfig, reqB: GetRecordActionsConfig): GetRecordActionsConfig;
+    isContextDependent(context: GetRecordActionsContext, request: GetRecordActionsRequest): boolean;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import type { GetRecordAvatarsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRecordAvatarsRequest = {
+    adapterName: 'getRecordAvatars';
+    config: GetRecordAvatarsConfig;
+};
+type GetRecordAvatarsContext = {
+    recordId: string;
+};
+export declare const GET_RECORD_AVATARS_ADAPTER_NAME = "getRecordAvatars";
+export declare class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordAvatarsConfig, GetRecordAvatarsRequest, GetRecordAvatarsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordAvatarsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/RecordAvatarBulkMapRepresentation").RecordAvatarBulkMapRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordAvatarsRequest, context: GetRecordAvatarsContext): GetRecordAvatarsRequest;
+    transformForSaveSimilarRequest(request: GetRecordAvatarsRequest): GetRecordAvatarsRequest;
+    isContextDependent<C extends GetRecordAvatarsContext>(context: C, request: GetRecordAvatarsRequest): boolean;
+    canCombine(reqA: GetRecordAvatarsConfig, reqB: GetRecordAvatarsConfig): boolean;
+    combineRequests(reqA: GetRecordAvatarsConfig, reqB: GetRecordAvatarsConfig): GetRecordAvatarsConfig;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import type { GetRecordConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRecordRequest = {
+    adapterName: 'getRecord';
+    config: GetRecordConfig;
+};
+type GetRecordContext = {
+    recordId: string;
+};
+export declare const GET_RECORD_ADAPTER_NAME = "getRecord";
+export declare class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordConfig, GetRecordRequest, GetRecordContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordConfig, import("@salesforce/lds-adapters-uiapi").RecordRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordRequest, context: GetRecordContext): GetRecordRequest;
+    transformForSave(request: GetRecordRequest): GetRecordRequest;
+    canCombine(reqA: GetRecordConfig, reqB: GetRecordConfig): boolean;
+    combineRequests(reqA: GetRecordConfig, reqB: GetRecordConfig): GetRecordConfig;
+    isContextDependent(context: GetRecordContext, request: GetRecordRequest): boolean;
+    transformForSaveSimilarRequest(request: GetRecordRequest): GetRecordRequest;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import type { GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRecordsRequest = {
+    adapterName: 'getRecords';
+    config: GetRecordsConfig;
+};
+type GetRecordsContext = {
+    recordId: string;
+};
+export declare const GET_RECORDS_ADAPTER_NAME = "getRecords";
+export declare class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordsConfig, GetRecordsRequest, GetRecordsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordsConfig, import("@salesforce/lds-adapters-uiapi").BatchRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordsRequest, context: GetRecordsContext): GetRecordsRequest;
+    isContextDependent(context: GetRecordsContext, request: GetRecordsRequest): boolean;
+    transformForSaveSimilarRequest(request: GetRecordsRequest): GetRecordsRequest;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-related-list-actions-request-strategy.d.ts

@@ -0,0 +1,21 @@
+import type { GetRelatedListActionsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRelatedListActionsRequest = {
+    adapterName: 'getRelatedListActions';
+    config: GetRelatedListActionsConfig;
+};
+type GetRelatedListActionsContext = {
+    recordId: string;
+};
+export declare const GET_RELATED_LIST_ACTIONS_ADAPTER_NAME = "getRelatedListActions";
+export declare class GetRelatedListActionsRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListActionsConfig, GetRelatedListActionsRequest, GetRelatedListActionsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListActionsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ActionRepresentation").ActionRepresentation>;
+    buildConcreteRequest(similarRequest: GetRelatedListActionsRequest, context: GetRelatedListActionsContext): GetRelatedListActionsRequest;
+    transformForSave(request: GetRelatedListActionsRequest): GetRelatedListActionsRequest;
+    transformForSaveSimilarRequest(request: GetRelatedListActionsRequest): GetRelatedListActionsRequest;
+    isContextDependent(context: GetRelatedListActionsContext, { config }: GetRelatedListActionsRequest): boolean;
+    canCombine(reqA: GetRelatedListActionsConfig, reqB: GetRelatedListActionsConfig): boolean;
+    combineRequests(reqA: GetRelatedListActionsConfig, _reqB: GetRelatedListActionsConfig): GetRelatedListActionsConfig;
+}
+export {};

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

@@ -0,0 +1,24 @@
+import type { GetRelatedListInfoBatchConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRelatedListInfoBatchRequest = {
+    adapterName: 'getRelatedListInfoBatch';
+    config: GetRelatedListInfoBatchConfig;
+};
+type GetRelatedListInfoBatchContext = {
+    objectApiName: string;
+    recordTypeId: string;
+};
+export declare const GET_RELATED_LIST_INFO_BATCH_ADAPTER_NAME = "getRelatedListInfoBatch";
+export declare class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListInfoBatchConfig, GetRelatedListInfoBatchRequest, GetRelatedListInfoBatchContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListInfoBatchConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/RelatedListInfoBatchRepresentation").RelatedListInfoBatchRepresentation>;
+    buildConcreteRequest(similarRequest: GetRelatedListInfoBatchRequest, _context: GetRelatedListInfoBatchContext): GetRelatedListInfoBatchRequest;
+    /**
+     * @override
+     */
+    transformForSave(request: GetRelatedListInfoBatchRequest): GetRelatedListInfoBatchRequest;
+    isContextDependent(context: GetRelatedListInfoBatchContext, request: GetRelatedListInfoBatchRequest): boolean;
+    canCombine(reqA: GetRelatedListInfoBatchConfig, reqB: GetRelatedListInfoBatchConfig): boolean;
+    combineRequests(reqA: GetRelatedListInfoBatchConfig, reqB: GetRelatedListInfoBatchConfig): GetRelatedListInfoBatchConfig;
+}
+export {};