@salesforce/lds-runtime-aura 0.1.0-dev1

package/dist/types/__mocks__/@salesforce/lds-ads-bridge.d.ts

@@ -0,0 +1,2 @@
+export default function (): void;
+export declare function instrument(): void;

package/dist/types/__mocks__/@salesforce/lds-aura-storage.d.ts

@@ -0,0 +1 @@
+export declare function clearStorages(): Promise<void>;

package/dist/types/__mocks__/@salesforce/lds-instrumentation.d.ts

@@ -0,0 +1,15 @@
+export declare function setupInstrumentation(): void;
+export declare function LRUCache(): Map<any, any>;
+export declare function incrementCounterMetric(): void;
+export declare function updatePercentileHistogramMetric(): void;
+export declare function instrumentAdapter<_C, _D>(adapter: any, _metadata: any): any;
+export declare function instrumentLuvio(): void;
+export declare function instrumentStoreMethods(): void;
+export declare function setLdsAdaptersUiapiInstrumentation(): void;
+export declare function setLdsNetworkAdapterInstrumentation(): void;
+export declare function logObjectInfoChanged(): void;
+export declare function executeAsyncActivity(_name: string, execute: (act: any) => Promise<void>, _options?: any): Promise<void>;
+export declare const METRIC_KEYS: {
+    PREDICTIVE_DATA_LOADING_PREDICT: string;
+    PREDICTIVE_DATA_LOADING_SAVE_REQUEST: string;
+};

package/dist/types/__mocks__/@salesforce/lds-network-aura.d.ts

@@ -0,0 +1,4 @@
+export default function (): void;
+export declare function instrument(): void;
+export declare function ldsNetworkAdapterInstrument(): void;
+export declare const forceRecordTransactionsDisabled = false;

package/dist/types/__mocks__/@salesforce/lds-network-fetch.d.ts

@@ -0,0 +1,2 @@
+export declare function setupLexNetworkAdapter(): void;
+export declare function instrument(): void;

package/dist/types/__mocks__/aura.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jest" />
+declare const executeGlobalControllerRawResponse: jest.Mock<any, any, any>;
+export { executeGlobalControllerRawResponse };

package/dist/types/__mocks__/force/ldsGraphqlParser.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jest" />
+declare const astResolver: jest.Mock<any, any, any>;
+export { astResolver };

package/dist/types/__mocks__/instrumentation/service.d.ts

@@ -0,0 +1,33 @@
+export declare function counter(): {
+    increment(): void;
+    decrement(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function gauge(): {
+    setValue(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function mark(): void;
+export declare function markStart(): void;
+export declare function markEnd(): void;
+export declare function perfStart(): void;
+export declare function perfEnd(): void;
+export declare function percentileHistogram(): {
+    update(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function time(): void;
+export declare function timer(): {
+    addDuration(): void;
+    getValue(): void;
+    time(): void;
+};
+export declare function registerCacheStats(): {
+    logHits(): void;
+    logMisses(): void;
+};
+export declare function registerPlugin(): void;
+export declare function registerPeriodicLogger(): void;

package/dist/types/__mocks__/instrumentation:beaconLib.d.ts

@@ -0,0 +1,7 @@
+declare function registerHandler(_cmp: any, _name: string, _loadedCheck: () => boolean): void;
+declare function markLoaded(_cmp: any): void;
+export declare const ThirdPartyTracker: {
+    registerHandler: typeof registerHandler;
+    markLoaded: typeof markLoaded;
+};
+export {};

package/dist/types/__mocks__/lwc.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="jest" />
+export declare const setTrustedSignalSet: jest.Mock<any, any, any>;
+export declare const setTrustedContextSet: jest.Mock<any, any, any>;
+export declare const setContextKeys: jest.Mock<any, any, any>;
+export declare const __dangerous_do_not_use_addTrustedContext: jest.Mock<any, any, any>;
+export declare const isTrustedSignal: jest.Mock<any, any, any>;

package/dist/types/__mocks__/o11y/activity.d.ts

@@ -0,0 +1,12 @@
+declare function stop(_userSchemaOrText?: any | string, _userData?: any): void;
+declare function error(_error: Error, _userSchemaOrText?: any | string, _userData?: any): void;
+declare function discard(): void;
+declare function terminate(): void;
+export declare const activity: {
+    stop: typeof stop;
+    error: typeof error;
+    discard: typeof discard;
+    terminate: typeof terminate;
+    getId: () => string;
+};
+export {};

package/dist/types/__mocks__/o11y/client.d.ts

@@ -0,0 +1,11 @@
+export { activity } from './activity';
+export { instrumentation } from './instrumentation';
+export { idleDetector } from './idleDetector';
+export declare function getInstrumentation(_name: string): {
+    log: (_schema: any, _data?: any) => void;
+    error: (_error: unknown, _userSchemaOrText?: any, _userData?: any) => void;
+    startActivity: (_name: string) => any;
+    incrementCounter: (_operation: string, _increment?: number | undefined, _hasError?: boolean | undefined, _tags?: any) => void;
+    trackValue: (_operation: string, _value: number, _hasError?: boolean | undefined, _tags?: any) => void;
+    bucketValue: (_operation: string, _value: number, _buckets: number[]) => void;
+};

package/dist/types/__mocks__/o11y/idleDetector.d.ts

@@ -0,0 +1,18 @@
+declare function requestIdleDetectedCallback(_callback: any): void;
+declare function declareNotifierTaskSingle(_name: string): {
+    isBusy: boolean;
+    done: () => void;
+};
+declare function declareNotifierTaskMulti(_name: string, _existingBusyCount?: number): {
+    isBusy: boolean;
+    add: () => void;
+    done: () => void;
+};
+declare function declarePollableTaskMulti(_name: string, _isBusyChecker: any): void;
+export declare const idleDetector: {
+    requestIdleDetectedCallback: typeof requestIdleDetectedCallback;
+    declareNotifierTaskSingle: typeof declareNotifierTaskSingle;
+    declareNotifierTaskMulti: typeof declareNotifierTaskMulti;
+    declarePollableTaskMulti: typeof declarePollableTaskMulti;
+};
+export {};

package/dist/types/__mocks__/o11y/instrumentation.d.ts

@@ -0,0 +1,15 @@
+declare function log(_schema: any, _data?: any): void;
+declare function error(_error: unknown, _userSchemaOrText?: any | string, _userData?: any): void;
+declare function startActivity(_name: string): any;
+declare function incrementCounter(_operation: string, _increment?: number, _hasError?: boolean, _tags?: any): void;
+declare function trackValue(_operation: string, _value: number, _hasError?: boolean, _tags?: any): void;
+declare function bucketValue(_operation: string, _value: number, _buckets: number[]): void;
+export declare const instrumentation: {
+    log: typeof log;
+    error: typeof error;
+    startActivity: typeof startActivity;
+    incrementCounter: typeof incrementCounter;
+    trackValue: typeof trackValue;
+    bucketValue: typeof bucketValue;
+};
+export {};

package/dist/types/__mocks__/o11y_schema/sf_lds.d.ts

@@ -0,0 +1 @@
+export declare const adapterUnfulfilledErrorSchema: {};

package/dist/types/aura-instrumentation/main.d.ts

@@ -0,0 +1,181 @@
+import type { FetchResponse, Luvio, InMemoryStore, Adapter, UnfulfilledSnapshot } from '@luvio/engine';
+import type { AdapterMetadata } from '@salesforce/lds-bindings';
+import { ADAPTER_UNFULFILLED_ERROR } from '@salesforce/lds-bindings';
+import type { CacheStatsLogger, Timer } from 'instrumentation/service';
+import { onIdleDetected, executeAsyncActivity } from '@salesforce/lds-instrumentation';
+export { onIdleDetected, executeAsyncActivity };
+export interface AdapterUnfulfilledError {
+    [ADAPTER_UNFULFILLED_ERROR]: boolean;
+    adapterName: string;
+    missingPaths: UnfulfilledSnapshot<any, any>['missingPaths'];
+    missingLinks: UnfulfilledSnapshot<any, any>['missingLinks'];
+}
+export declare const APEX_ADAPTER_NAME = "getApex";
+export declare const NORMALIZED_APEX_ADAPTER_NAME: string;
+export declare const REFRESH_APEX_KEY = "refreshApex";
+export declare const REFRESH_UIAPI_KEY = "refreshUiApi";
+export declare const SUPPORTED_KEY = "refreshSupported";
+export declare const UNSUPPORTED_KEY = "refreshUnsupported";
+type refreshApiNames = {
+    refreshApex: string;
+    refreshUiApi: string;
+};
+export interface LightningInteractionSchema {
+    target: string;
+    scope: string;
+    context: unknown;
+    eventSource: string;
+    eventType: string;
+    attributes: unknown;
+}
+export declare class Instrumentation {
+    private adapterUnfulfilledErrorCounters;
+    private recordApiNameChangeCounters;
+    private refreshAdapterEvents;
+    private refreshApiCallEventStats;
+    private lastRefreshApiCall;
+    private weakEtagZeroEvents;
+    private adapterCacheMisses;
+    constructor();
+    /**
+     * Instruments an existing adapter to log argus metrics and cache stats.
+     * @param adapter The adapter function.
+     * @param metadata The adapter metadata.
+     * @param wireConfigKeyFn Optional function to transform wire configs to a unique key.
+     * @returns The wrapped adapter.
+     */
+    instrumentAdapter<C, D>(adapter: Adapter<C, D>, metadata: AdapterMetadata): Adapter<C, D>;
+    /**
+     * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
+     * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
+     * @param name The wire adapter name.
+     * @param config The config passed into wire adapter.
+     * @param ttlMissStats CacheStatsLogger to log misses out of TTL.
+     * @param currentCacheMissTimestamp Timestamp for when the request was made.
+     * @param ttl TTL for the wire adapter.
+     */
+    private logAdapterCacheMissOutOfTtlDuration;
+    /**
+     * Injected to LDS for Luvio specific instrumentation.
+     *
+     * @param context The transaction context.
+     */
+    instrumentLuvio(context: unknown): void;
+    /**
+     * Returns whether or not this is a RefreshAdapterEvent.
+     * @param context The transaction context.
+     * @returns Whether or not this is a RefreshAdapterEvent.
+     */
+    private isRefreshAdapterEvent;
+    /**
+     * Returns whether or not this is an AdapterUnfulfilledError.
+     * @param context The transaction context.
+     * @returns Whether or not this is an AdapterUnfulfilledError.
+     */
+    private isAdapterUnfulfilledError;
+    /**
+     * Specific instrumentation for getRecordNotifyChange.
+     * temporary implementation to match existing aura call for now
+     *
+     * @param uniqueWeakEtags whether weakEtags match or not
+     * @param error if dispatchResourceRequest fails for any reason
+     */
+    notifyChangeNetwork(uniqueWeakEtags: boolean | null, error?: boolean): void;
+    /**
+     * Parses and aggregates weakETagZero events to be sent in summarized log line.
+     * @param context The transaction context.
+     */
+    aggregateWeakETagEvents(incomingWeakEtagZero: boolean, existingWeakEtagZero: boolean, apiName: string): void;
+    /**
+     * Aggregates refresh adapter events to be sent in summarized log line.
+     *   - how many times refreshApex is called
+     *   - how many times refresh from lightning/uiRecordApi is called
+     *   - number of supported calls: refreshApex called on apex adapter
+     *   - number of unsupported calls: refreshApex on non-apex adapter
+     *          + any use of refresh from uiRecordApi module
+     *   - count of refresh calls per adapter
+     * @param context The refresh adapter event.
+     */
+    private aggregateRefreshAdapterEvents;
+    /**
+     * Increments call stat for incoming refresh api call, and sets the name
+     * to be used in {@link aggregateRefreshCalls}
+     * @param from The name of the refresh function called.
+     */
+    handleRefreshApiCall(apiName: keyof refreshApiNames): void;
+    /**
+     * W-7302241
+     * Logs refresh call summary stats as a LightningInteraction.
+     */
+    logRefreshStats(): void;
+    /**
+     * Resets the stat trackers for refresh call events.
+     */
+    private resetRefreshStats;
+    /**
+     * W-7801618
+     * Counter for occurrences where the incoming record to be merged has a different apiName.
+     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
+     *
+     * @param context The transaction context.
+     *
+     * Note: Short-lived metric candidate, remove at the end of 230
+     */
+    incrementRecordApiNameChangeCount(_incomingApiName: string, existingApiName: string): void;
+    /**
+     * W-8620679
+     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
+     *
+     * @param context The transaction context.
+     */
+    private incrementAdapterRequestErrorCount;
+}
+/**
+ * Calls instrumentation/service interaction API. Function name and parameters mapped to `o11y`
+ * implementation for Log Lines.
+ * @param schema Expected shape of the payload (Currently unused)
+ * @param payload Content to be logged, shape matches schema
+ */
+export declare function log(_schema: any, payload: LightningInteractionSchema): void;
+/**
+ * Calls instrumentation/service telemetry timer
+ * @param name Name of the metric
+ * @param duration number to update backing percentile histogram, negative numbers ignored
+ */
+export declare function updateTimerMetric(name: string, duration: number): void;
+export declare function timerMetricAddDuration(timer: Timer, duration: number): void;
+export declare function incrementRequestResponseCount(cb: () => FetchResponse<unknown>): void;
+/**
+ * Add a mark to the metrics service.
+ *
+ * @param name The mark name.
+ * @param content The mark content.
+ */
+export declare function mark(name: string, content?: any): void;
+export declare function logObjectInfoChanged(): void;
+/**
+ * Create a new instrumentation cache stats and return it.
+ *
+ * @param name The cache logger name.
+ */
+export declare function registerLdsCacheStats(name: string): CacheStatsLogger;
+/**
+ * Add or overwrite hooks that require aura implementations
+ */
+export declare function setAuraInstrumentationHooks(): void;
+export declare function setStateManagerInstrumentationHooks(): void;
+/**
+ * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ *
+ * @param luvio The Luvio instance to instrument.
+ * @param store The InMemoryStore to instrument.
+ */
+export declare function setupInstrumentation(luvio: Luvio, store: InMemoryStore): void;
+/**
+ * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
+ * disable all crud operations if it is on.
+ * @param eventSource - Source of the logging event.
+ * @param attributes - Free form object of attributes to log.
+ */
+export declare function logCRUDLightningInteraction(eventSource: string, attributes: object): void;
+export declare const instrumentation: Instrumentation;

package/dist/types/aura-instrumentation/utils/observability.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Observability / Critical Availability Program (230+)
+ *
+ * This file is intended to be used as a consolidated place for all definitions, functions,
+ * and helpers related to "M1"[1].
+ *
+ * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
+ *
+ * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
+ */
+import type { MetricsKey } from 'instrumentation/service';
+export declare const OBSERVABILITY_NAMESPACE = "LIGHTNING.lds.service";
+export declare const ADAPTER_INVOCATION_COUNT_METRIC_NAME = "request";
+export declare const ADAPTER_ERROR_COUNT_METRIC_NAME = "error";
+export declare const NETWORK_ADAPTER_RESPONSE_METRIC_NAME = "network-response";
+/**
+ * W-8379680
+ * Counter for number of getApex requests.
+ */
+export declare const GET_APEX_REQUEST_COUNT: MetricsKey;
+/**
+ * W-8379680
+ * Counter for number of getApex errors.
+ */
+export declare const GET_APEX_ERROR_COUNT: MetricsKey;
+/**
+ * W-8828410
+ * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
+ */
+export declare const TOTAL_ADAPTER_ERROR_COUNT: MetricsKey;
+/**
+ * W-8828410
+ * Counter for the number of invocations made into LDS by a wire adapter.
+ */
+export declare const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT: MetricsKey;

package/dist/types/aura-instrumentation/utils/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}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @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 isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;

package/dist/types/jwt-authorized-fetch-service.d.ts

@@ -0,0 +1,14 @@
+import { type FetchServiceDescriptor } from '@luvio/service-fetch-network/v1';
+import { type LoggerService } from '@luvio/utils';
+export declare function buildJwtAuthorizedSfapFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
+/**
+ * Returns a service descriptor for a fetch service that includes one-off copilot
+ * hacks. This fetch service is not intended for use by anything other than
+ * copilot commands.
+ */
+export declare function buildCopilotFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
+export declare const lightningJwtResolver: {
+    getJwt(): Promise<any>;
+};
+export declare function buildJwtAuthorizedLightningFetchServiceDescriptor(): FetchServiceDescriptor;
+export declare function buildUnauthorizedFetchServiceDescriptor(): FetchServiceDescriptor;

package/dist/types/language.d.ts

@@ -0,0 +1,23 @@
+declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, hasOwnProperty: (v: PropertyKey) => boolean, entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+declare const isArray: (arg: any) => arg is any[], from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+    <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+};
+declare const stringify: {
+    (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;
+};
+export { create as ObjectCreate, keys as ObjectKeys, hasOwnProperty as ObjectHasOwnProperty, entries as ObjectEntries, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, };

package/dist/types/lex-fetch-service.d.ts

@@ -0,0 +1,3 @@
+import { type LoggerService } from '@luvio/utils';
+import { type FetchServiceDescriptor } from '@luvio/service-fetch-network/v1';
+export declare function buildLexRuntimeFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;

package/dist/types/main.d.ts

@@ -0,0 +1,63 @@
+import { Luvio } from '@luvio/engine';
+import { KeyParamsRecord } from '@salesforce/lds-adapters-uiapi';
+import { ObjectHomePageContext, type RecordHomePageContext } from './predictive-loading';
+import type { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
+import { type LexRequest } from './predictive-loading/lex';
+export { PdlRequestPriority } from './predictive-loading';
+export { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
+/**
+ * Registers a request strategy to be utilized by PDL.
+ * @param requestStrategy - {@link LexRequestStrategy} The request strategy/strategies to register.
+ * @returns boolean | boolean[] - true/false depending on registration success.
+ */
+export declare function registerRequestStrategy(...requestStrategy: LexRequestStrategy[]): boolean | boolean[];
+/**
+ * Unregisters a request strategy to be utilized by PDL.
+ * @param requestStrategy - {@link LexRequestStrategy} The request strategy to unregister.
+ * @returns boolean | boolean[] - true/false depending on unregistration success.
+ */
+export declare function unregisterRequestStrategy(...requestStrategy: LexRequestStrategy[]): boolean | boolean[];
+export declare function whenPredictionsReady(callback: () => void): void;
+export declare function saveRequestAsPrediction(request: LexRequest): void;
+export declare const notifyUpdateAvailableFactory: (luvio: Luvio) => (configs: Partial<KeyParamsRecord>[]) => Promise<void>;
+/**
+ * @typedef {Object} RecordHomePageContext
+ * @property {string} objectApiName - The API name of the object.
+ * @property {string} recordId - The unique identifier for the record.
+ * @property {string} actionName - The name of the action being performed.
+ * @property {'recordPage'} type - The type of the context, specifically for a record page.
+ */
+/**
+ * Builds a predictor for a given record home page context. This predictor is responsible for
+ * preloading data based on predictions for the current context and create new predictions based
+ * on page requests of this context.
+ *
+ * @param {RecordHomePageContext} context - The context for which the predictor is to be built.
+ * @returns {{
+ *     hasPredictions: () => boolean,
+ *     watchPageLoadForPredictions: () => void,
+ *     runPredictions: () => ReturnType<Promise<void>>,
+ *     getPredictionSummary: () => Map<String,Number>
+ * }} An object containing methods to handle predictions:
+ *  - hasPredictions: Checks if there are any predictions available.
+ *  - watchPageLoadForPredictions: Starts recording the page request for prediction purposes.
+ *  - runPredictions: Executes the predictions based on the recorded data and returns a promise
+ *    of when those predictions are completed.
+ *  - getPredictionSummary: Returns the count of exact and similar prediction requests
+ */
+export declare function buildPredictorForContext(context: RecordHomePageContext | ObjectHomePageContext): {
+    hasPredictions(): boolean;
+    watchPageLoadForPredictions(): void;
+    runPredictions(): Promise<void>;
+    getPredictionSummary(): {
+        exact: number;
+        similar: number;
+        totalRequestCount: Number;
+    };
+} | undefined;
+export declare function initializeLDS(): Luvio;
+export declare function initializeOneStore(luvio: Luvio): void;
+declare function ldsEngineCreator(): {
+    name: string;
+};
+export default ldsEngineCreator;

package/dist/types/metadata.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio } from '@luvio/engine';
+/**
+ * Watch a Luvio instance for metadata changes.
+ */
+export declare function setupMetadataWatcher(luvio: Luvio): void;

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

@@ -0,0 +1,2 @@
+declare const composedNetworkAdapter: import("@luvio/engine").NetworkAdapter;
+export default composedNetworkAdapter;

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

@@ -0,0 +1,7 @@
+import { type ResourceRequest } from '@luvio/engine';
+import type { RequestLogger } from '@salesforce/lds-network-fetch';
+export declare const requestLogger: RequestLogger;
+export declare const composedFetchNetworkAdapter: {
+    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,17 @@
+import type { FetchResponse, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+import type { JwtResolver } from '@luvio/jwt-manager';
+export declare const SFAPController = "SalesforceApiPlatformController";
+export declare const SFAPJwtMethod = "getSFAPLightningJwtService";
+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/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';