@salesforce/lds-runtime-mobile 0.1.0-dev1

package/sfdc/types/graphql/syntheticFields.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentNode } from '@luvio/graphql-parser';
+import type { DraftFunctions } from './types';
+import type { GraphQLRepresentationData } from '@salesforce/lds-adapters-uiapi';
+import type { ObjectInfoService, ObjectInfoMap } from './types';
+export declare function injectSyntheticFields(originalAST: DocumentNode, objectInfoService: ObjectInfoService, draftFunctions: DraftFunctions, variables?: Record<string, any>): Promise<{
+    modifiedAST: DocumentNode;
+    objectInfos: ObjectInfoMap;
+    unmappedDraftIDs: Set<string>;
+}>;
+export declare function removeSyntheticFields(result: GraphQLRepresentationData, query: DocumentNode): GraphQLRepresentationData;

package/sfdc/types/graphql/typeguards.d.ts

@@ -0,0 +1,19 @@
+import type { FieldNode, ObjectFieldNode, OperationDefinitionNode, SelectionNode, ASTNode, DefinitionNode, ObjectValueNode, InlineFragmentNode, StringValueNode, VariableNode, IntValueNode } from '@luvio/graphql-parser';
+import type { DateTimeInput } from './dateTimePredication';
+import type { CompoundPredicate, PredicateValue, SinglePredicate, NotPredicate } from './query';
+export declare function isObjectValueNode(node: ASTNode): node is ObjectValueNode;
+export declare function isStringValueNode(node: ASTNode): node is StringValueNode;
+export declare function isIntValueNode(node: ASTNode): node is IntValueNode;
+export declare function isVariableNode(node: ASTNode): node is VariableNode;
+export declare function isObjectFieldNode(node: ASTNode): node is ObjectFieldNode;
+export declare function isFieldNode(node: ASTNode): node is FieldNode;
+export declare function isFieldOrInlineFragmentNode(node: ASTNode): node is FieldNode | InlineFragmentNode;
+export declare function isInlineFragmentNode(node: ASTNode): node is InlineFragmentNode;
+export declare function isCompoundPredicate(predicate: PredicateValue): predicate is CompoundPredicate;
+export declare function isSinglePredicate(predicate: PredicateValue): predicate is SinglePredicate;
+export declare function isNotPredicate(predicate: PredicateValue): predicate is NotPredicate;
+export declare function isDateTimeInput(object: any): object is DateTimeInput;
+export declare function nodeIsNamed(name: string): (node: FieldNode) => boolean;
+export declare function extractFieldSelections(accu: SelectionNode[], item: FieldNode): SelectionNode[];
+export declare function extractSelections(accu: SelectionNode[], item: FieldNode | InlineFragmentNode): SelectionNode[];
+export declare function isOperationDefinitionNode(node: DefinitionNode): node is OperationDefinitionNode;

package/sfdc/types/instrumentation/instrumentDraftQueue.d.ts

@@ -0,0 +1,5 @@
+import type { DraftQueue } from '@salesforce/lds-drafts';
+/**
+ * A HOF that returns an instrumented DraftQueue
+ */
+export declare function instrumentDraftQueue(queue: DraftQueue): DraftQueue;

package/sfdc/types/instrumentation/instrumentGraphQLEval.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from '@luvio/engine';
+export declare function instrumentGraphQLEval<C, D>(adapter: Adapter<C, D>): Adapter<C, D>;

package/sfdc/types/instrumentation/instrumentMobileAdapter.d.ts

@@ -0,0 +1,6 @@
+import type { ReportObserver } from '@salesforce/lds-instrumentation';
+import type { Luvio, InMemoryStore } from '@luvio/engine';
+type Unsubscribe = () => void;
+export declare function setupMobileInstrumentation(luvio: Luvio, store: InMemoryStore): void;
+export declare function registerReportObserver(reportObserver: ReportObserver): Unsubscribe;
+export {};

package/sfdc/types/instrumentation/instrumentPrimingSession.d.ts

@@ -0,0 +1,2 @@
+import type { PrimingSession } from '../priming';
+export declare function instrumentPrimingSession(session: PrimingSession): PrimingSession;

package/sfdc/types/instrumentation/instrumentationContentDocumentVersionAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from '@luvio/engine';
+export declare function instrumentContentDocumentVersionAdapter<C, D>(adapter: Adapter<C, D>): Adapter<C, D>;

package/sfdc/types/instrumentation/instrumentationUtils.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterRequestContext, LuvioAdapterEventObserver } from '@luvio/engine';
+export declare function attachObserversToAdapterRequestContext(observers: LuvioAdapterEventObserver[], adapterRequestContext?: AdapterRequestContext): AdapterRequestContext;
+/**
+ * Use this method to sanitize the unknown error object when
+ * we are unsure of the type of the error thrown
+ *
+ * @param err Unknown object to sanitize
+ * @returns an instance of error
+ */
+export declare function normalizeError(err: unknown): Error;

package/sfdc/types/instrumentation/metrics.d.ts

@@ -0,0 +1,26 @@
+import type { QueryInstrumentation } from '../graphql/instrumentLimits';
+export declare const O11Y_NAMESPACE_LDS_MOBILE = "lds-mobile";
+export declare const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = "draft-queue-total-mergeActions-calls";
+export declare const ldsMobileInstrumentation: any;
+export declare function reportGraphqlQueryParseError(err: unknown): void;
+export declare function reportGraphqlSqlEvalPreconditionError(err: unknown): void;
+export declare function reportGraphqlCreateSnapshotError(err: unknown): void;
+export declare function reportGraphQlEvalDbReadDuration(duration: number): void;
+export declare function reportGraphqlAdapterError(errorCode: string): void;
+export declare function reportGraphqlQueryInstrumentation(data: QueryInstrumentation): void;
+export declare function incrementGraphQLRefreshUndfined(): void;
+export declare function reportDraftActionEvent(state: 'added' | 'uploading' | 'completed' | 'deleted' | 'updated' | 'failed', draftCount: number, message?: string): void;
+export declare function reportDraftQueueState(state: 'started' | 'error' | 'waiting' | 'stopped', draftCount: number): void;
+export declare function reportDraftAwareContentDocumentVersionSynthesizeError(err: unknown): void;
+export declare function reportDraftAwareContentVersionSynthesizeCalls(mimeType: string): void;
+/** Priming */
+export declare function reportPrimingSessionCreated(): void;
+export declare function reportPrimingError(errorType: string, recordCount: number): void;
+export declare function reportPrimingSuccess(recordCount: number): void;
+export declare function reportPrimingConflict(resolutionType: string, recordCount: number): void;
+/** Network */
+export declare function reportChunkCandidateUrlLength(urlLength: number): void;
+/** Garbage Collection */
+export declare function reportAggressiveTrimTriggered(trimCount: number, beforeTrimRecordCount: number, totalRecordsTrimmed: number): void;
+export declare function reportOneStoreRecordsPurgedFromCache(recordsPurged: number): void;
+export declare function reportOneStoreCachePurgingError(error: unknown): void;

package/sfdc/types/instrumentation/withInstrumentation.d.ts

@@ -0,0 +1,12 @@
+export type WithInstrumentation = (operation: () => Promise<any>, config: InstrumentationConfig) => Promise<any>;
+export interface InstrumentationConfig {
+    tags: Record<string, string>;
+    metricName: string;
+    logError: boolean;
+}
+/**
+ * HOF (high-order-function) that instruments any async operation.  If the operation
+ * has an error then the hasError param will be set on the call to o11y.incrementCounter
+ * and an "errorMessage" tag containing the Error.message will be added to the tags.
+ */
+export declare const withInstrumentation: <T>(operation: () => Promise<T>, config?: InstrumentationConfig) => Promise<T>;

package/sfdc/types/localization/formatDisplayValue.d.ts

@@ -0,0 +1,6 @@
+export declare const FORMATTABLE_DISPLAY_VALUE_TYPES: string[];
+/**
+ * Formats the display value for a draft field
+ * @param value the value to format
+ */
+export declare function formatDisplayValue(value: boolean | number | string | null, datatype: string): null | string;

package/sfdc/types/main.d.ts

@@ -0,0 +1,11 @@
+import { getRuntime } from './runtime';
+import { O11Y_NAMESPACE_LDS_MOBILE } from './instrumentation/metrics';
+export { getRuntime, O11Y_NAMESPACE_LDS_MOBILE };
+export type { ObjectInfoService } from './utils/ObjectInfoService';
+export type { ObservabilityContext } from '@salesforce/nimbus-plugin-lds';
+export { registerReportObserver } from './instrumentation/instrumentMobileAdapter';
+export { reportGraphqlQueryParseError } from './instrumentation/metrics';
+export type { PrimingSession } from './priming';
+export { ingest as ingestDenormalizedRecordRepresentation } from './adapters/raml-artifacts/types/RecordRepresentation/ingest';
+export type { RecordRepresentation, RecordRepresentationNormalized, } from './adapters/types/RecordRepresentation';
+export { initializeOneStore } from './onestore';

package/sfdc/types/mocks.d.ts

@@ -0,0 +1 @@
+export { MockNimbusBinaryStorePlugin, mockNimbusBinaryStorePlugin, } from '@salesforce/nimbus-plugin-lds';

package/sfdc/types/observer/setupObserver.d.ts

@@ -0,0 +1 @@
+export declare function setupObserver(): void;

package/sfdc/types/onestore/index.d.ts

@@ -0,0 +1,10 @@
+import { SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
+export declare function initializeOneStore(sqliteStore: SqliteStorePlugin): void;
+/**
+ * Manually purges the OneStore cache by days.
+ * Until we have real cache eviction in one store.
+ *
+ * @param days - The number of days to purge the cache by.
+ * @param sqliteStore - The SqliteStorePlugin to purge the cache from.
+ */
+export declare function purgeDurableCacheByDays(days: number, sqliteStore: SqliteStorePlugin): Promise<void>;

package/sfdc/types/onestore/nimbusDurableCacheInclusionPolicy.d.ts

@@ -0,0 +1,15 @@
+import { type CacheInclusionPolicyServiceDescriptor, type CacheQuery, type CacheUpdate, DurableCacheInclusionPolicy } from '@luvio/service-cache-inclusion-policy/v1';
+import type { Cache, CacheEntry, Key, NamedCacheService } from '@luvio/service-cache/v1';
+import { type DeepReadonly, type SyncOrAsync } from '@luvio/utils';
+import { NimbusSqliteOneStoreCache } from './nimbusSqliteStoreCache';
+export declare class NimbusDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
+    private readonly services;
+    private readonly store;
+    constructor(services: NamedCacheService, store: NimbusSqliteOneStoreCache);
+    revive(keys: Set<Key>, l1: Cache): SyncOrAsync<Set<Key>>;
+    syncToL2Cache(changedKeys: Set<Key>, l1: Cache): SyncOrAsync<void>;
+    find(_query: CacheQuery): AsyncGenerator<[key: Key, value: DeepReadonly<CacheEntry<unknown>>], void, unknown>;
+    findAndModify(_query: CacheQuery, _cacheUpdate: CacheUpdate): AsyncGenerator<Key, void, unknown>;
+    private registerListener;
+}
+export declare function buildNimbusDurableCacheInclusionPolicyService(cache: Cache, store: NimbusSqliteOneStoreCache): CacheInclusionPolicyServiceDescriptor;

package/sfdc/types/onestore/nimbusNetworkDescriptor.d.ts

@@ -0,0 +1,3 @@
+import { IFetchService } from '@luvio/service-fetch-network/v1';
+import { type ServiceDescriptor } from '@luvio/utils';
+export declare function buildNimbusFetchServiceDescriptor(): ServiceDescriptor<IFetchService, 'fetch', '1.0'>;

package/sfdc/types/onestore/nimbusSqliteStoreCache.d.ts

@@ -0,0 +1,19 @@
+import type { CacheEntry, Key } from '@luvio/service-cache/v1';
+import type { SqliteStorePlugin, SqliteStoreChange } from '@salesforce/nimbus-plugin-lds';
+export type NimbusSqliteOneStoreCacheEntry<T> = {
+    key: Key;
+    entry: CacheEntry<T>;
+};
+type OneStoreChangeListener = (changes: SqliteStoreChange[]) => Promise<void>;
+export declare class NimbusSqliteOneStoreCache {
+    private readonly sqlStore;
+    constructor(sqlStore: SqliteStorePlugin);
+    getEntry<T>(key: Key): Promise<NimbusSqliteOneStoreCacheEntry<T> | undefined>;
+    getEntries<T>(keys: Set<Key>): Promise<NimbusSqliteOneStoreCacheEntry<T>[] | undefined>;
+    setEntry<T>(key: Key, entry: CacheEntry<T>): Promise<void>;
+    setEntries<T>(entries: NimbusSqliteOneStoreCacheEntry<T>[]): Promise<void>;
+    registerOnChangedListener(listener: OneStoreChangeListener): () => Promise<void>;
+    private batchQuery;
+    private query;
+}
+export {};

package/sfdc/types/priming/ConflictPool.d.ts

@@ -0,0 +1,31 @@
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { PrimingStore } from './PrimingStore';
+import type { PrimingWork } from './types';
+import type { ObjectInfoLoader } from './ObjectInfoLoader';
+type ConflictResolutionError = 'object-info-missing';
+export interface ConflictResolutionResult {
+    additionalWork: PrimingWork;
+    recordsToWrite: DurableRecordRepresentation[];
+    resolvedRecords: string[];
+    recordsNeedingRefetch: Map<string, {
+        ids: string[];
+        fields: string[];
+    }>;
+    errors: {
+        id: string;
+        reason: ConflictResolutionError;
+    }[];
+}
+/**
+ * A pool of workers that resolve conflicts between incoming records and records in the store.
+ */
+export declare class ConflictPool {
+    private readonly store;
+    private readonly objectInfoLoader;
+    private pool;
+    constructor(store: PrimingStore, objectInfoLoader: ObjectInfoLoader);
+    enqueueConflictedRecords(records: DurableRecordRepresentation[], abortController: LdsAbortController): Promise<ConflictResolutionResult>;
+    private resolveConflicts;
+}
+export {};

package/sfdc/types/priming/Emitter.d.ts

@@ -0,0 +1,16 @@
+type EventPayloadMap = {
+    [eventName: string]: any;
+};
+type EventCallback<T extends keyof EventPayloadMap> = (payload: EventPayloadMap[T]) => void;
+export declare abstract class EventEmitter<T extends EventPayloadMap> {
+    private listeners;
+    private addListener;
+    private removeListener;
+    on<K extends Extract<keyof T, string>>(eventName: K, callback: (payload: T[K]) => void): this;
+    once<K extends Extract<keyof T, string>>(eventName: K, callback: (payload: T[K]) => void): this;
+    off<K extends Extract<keyof T, string>>(eventName: K, callback: (payload: T[K]) => void): this;
+    protected emit<K extends Extract<keyof T, string>>(eventName: K, payload: T[K]): boolean;
+    protected listenerCount<K extends Extract<keyof T, string>>(eventName: K): number;
+    protected rawListeners<K extends Extract<keyof T, string>>(eventName: K): { [K_1 in keyof T]: EventCallback<K_1>[]; }[K];
+}
+export {};

package/sfdc/types/priming/LdsPrimingRecordRefresher.d.ts

@@ -0,0 +1,14 @@
+import type { Adapter } from '@luvio/engine';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+import type { LdsRecordRefresher } from '../priming';
+export declare class LdsPrimingRecordRefresher implements LdsRecordRefresher {
+    private getRecordsAdapter;
+    constructor(getRecordsAdapter: Adapter<GetRecordsConfig, BatchRepresentation>);
+    loadRecords(records: Map<string, {
+        ids: string[];
+        fields: string[];
+    }>): Promise<{
+        loaded: string[];
+        errored: string[];
+    }>;
+}

package/sfdc/types/priming/LdsRecordRefresher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * When the priming session cannot resolve a record due to an unsupported conflict (i.e. draft conflict or spanning record conflict) the record
+ * must be refreshed via a tradition LDS adapter.
+ */
+export interface LdsRecordRefresher {
+    /**
+     * Refreshes a set of records through an LDS adapter
+     * @param records a map of apiName to ids and fields being requested
+     */
+    loadRecords(records: Map<string, {
+        ids: string[];
+        fields: string[];
+    }>): Promise<{
+        loaded: string[];
+        errored: string[];
+    }>;
+}

package/sfdc/types/priming/NimbusPrimingNetworkAdapter.d.ts

@@ -0,0 +1,10 @@
+import { type PrimingNetworkAdapter } from '../priming';
+import type { ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { Request, Response } from '@salesforce/nimbus-plugin-lds';
+export declare class NimbusPrimingNetworkAdapter implements PrimingNetworkAdapter {
+    private sendRequestWithAbort;
+    sendRequest(request: Request, abortController: LdsAbortController): Promise<Response>;
+    getObjectInfoDirectory(abortController: LdsAbortController): Promise<ObjectInfoDirectoryRepresentation>;
+    getObjectInfos(apiName: string[], abortController: LdsAbortController): Promise<Map<string, ObjectInfoRepresentation>>;
+}

package/sfdc/types/priming/ObjectInfoLoader.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectInfoRepresentation, ObjectInfoDirectoryRepresentation } from '@salesforce/lds-adapters-uiapi';
+interface ObjectInfoStatus {
+    expiration: number;
+}
+export interface ObjectInfoLoader {
+    getObjectInfos(apiNames: string[]): Promise<Record<string, ObjectInfoRepresentation>>;
+    getObjectInfoDirectory(): Promise<ObjectInfoDirectoryRepresentation | undefined>;
+    getCachedObjectInfoStatus(): Promise<Map<string, ObjectInfoStatus>>;
+}
+export {};

package/sfdc/types/priming/PrimingNetworkAdapter.d.ts

@@ -0,0 +1,5 @@
+import type { Request, Response } from '@salesforce/nimbus-plugin-lds';
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+export interface PrimingNetworkAdapter {
+    sendRequest(request: Request, abortController: LdsAbortController): Promise<Response>;
+}

package/sfdc/types/priming/PrimingNetworkError.d.ts

@@ -0,0 +1,5 @@
+export declare class PrimingNetworkError extends Error {
+    httpCode: number;
+    constructor(message: string, httpCode: number);
+    isServiceProtectionError(): Boolean;
+}

package/sfdc/types/priming/PrimingSession.d.ts

@@ -0,0 +1,76 @@
+import type { RecordIngestor } from './RecordIngestor';
+import type { RecordLoader } from './recordLoaders';
+import type { PrimingWork } from './types';
+import type { ObjectInfoLoader } from './ObjectInfoLoader';
+import type { PrimingStore } from './PrimingStore';
+import type { LdsRecordRefresher } from './LdsRecordRefresher';
+import type { ObservabilityContext } from '@salesforce/nimbus-plugin-lds';
+import { EventEmitter } from './Emitter';
+export declare const instrumentation: any;
+export interface PrimingSessionConfig {
+    store: PrimingStore;
+    recordLoader: RecordLoader;
+    recordIngestor: RecordIngestor;
+    objectInfoLoader: ObjectInfoLoader;
+    ldsRecordRefresher: LdsRecordRefresher;
+    batchSize?: number;
+    concurrency?: number;
+}
+export interface PrimingEvents {
+    error: EventErrorPayload;
+    primed: EventPrimedPayload;
+    conflict: ConflictEventPayload;
+    'metadata-fetched': {
+        availableTypes: string[];
+        unavailableTypes: string[];
+        duration: number;
+    };
+    'batch-starting': {
+        queuedTime: number;
+    };
+    'batch-fetched': {
+        ids: string[];
+        duration: number;
+    };
+    'batch-written': {
+        written: string[];
+        conflicted: string[];
+        errors: string[];
+        duration: number;
+    };
+    'retry-limit-reached': {
+        ids: string[];
+    };
+}
+interface EventErrorPayload {
+    ids: string[];
+    code: 'precondition-error' | 'service-protection-error' | 'not-found' | 'service-unavailable' | 'unknown' | 'canceled';
+    message: string;
+}
+interface ConflictEventPayload {
+    ids: string[];
+    resolution: 'priming-merge' | 'priming-refresh' | 'lds-refresh';
+}
+type EventPrimedPayload = Array<string>;
+export declare class PrimingSession extends EventEmitter<PrimingEvents> {
+    private batchSize;
+    private concurrency;
+    private recordLoader;
+    private recordIngestor;
+    private objectInfoLoader;
+    private networkWorkerPool;
+    private conflictPool;
+    private ldsRecordRefresher;
+    private retryTracker;
+    constructor(config: PrimingSessionConfig);
+    enqueue(work: PrimingWork, context?: ObservabilityContext): Promise<void>;
+    cancel(): void;
+    private handleInstrumentation;
+    private enqueueBatches;
+    private handlePaginations;
+    private processFetchedRecords;
+    private handleWriteConflicts;
+    private applyRetryLimits;
+    private fetchMetadata;
+}
+export {};

package/sfdc/types/priming/PrimingStore.d.ts

@@ -0,0 +1,27 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { StoreMetadata } from '@luvio/engine';
+export interface RecordWithMetadata {
+    record: DurableRecordRepresentation;
+    metadata: StoreMetadata;
+}
+export interface WriteResult {
+    written: string[];
+    conflicted: string[];
+    errors: {
+        ids: string[];
+        message: string;
+    }[];
+}
+export interface PrimingStore {
+    /**
+     * Writes records to the store
+     * @param records list of records to insert
+     * @returns list of ids that were written and list of ids that were not written due to already being present in the store
+     */
+    writeRecords(records: RecordWithMetadata[], overwrite: boolean): Promise<WriteResult>;
+    /**
+     * Reads records from the store
+     * @param ids
+     */
+    readRecords(ids: string[]): Promise<RecordWithMetadata[]>;
+}

package/sfdc/types/priming/RecordIngestor.d.ts

@@ -0,0 +1,14 @@
+import type { Luvio } from '@luvio/engine';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { PrimingStore, WriteResult } from './PrimingStore';
+export declare class RecordIngestor {
+    private store;
+    private getLuvio;
+    constructor(store: PrimingStore, getLuvio: () => Luvio);
+    /**
+     * Inserts records into the store
+     * @param syntheticRecords list of records to insert
+     * @returns list of ids that were written and list of ids that were not written due to already being present in the store
+     */
+    insertRecords(syntheticRecords: DurableRecordRepresentation[], overwrite?: boolean): Promise<WriteResult>;
+}

package/sfdc/types/priming/SqlitePrimingStore.d.ts

@@ -0,0 +1,11 @@
+import type { PrimingStore, RecordWithMetadata, WriteResult } from '../priming';
+import type { Luvio } from '@luvio/engine';
+import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
+export declare class SqlitePrimingStore implements PrimingStore {
+    private readonly getLuvio;
+    private readonly store;
+    constructor(getLuvio: () => Luvio, store: NimbusSqliteStore);
+    readRecords(ids: string[]): Promise<RecordWithMetadata[]>;
+    writeRecords(records: RecordWithMetadata[], overwrite: boolean): Promise<WriteResult>;
+    private writeBatch;
+}

package/sfdc/types/priming/index.d.ts

@@ -0,0 +1,10 @@
+export { PrimingSession } from './PrimingSession';
+export { RecordIngestor } from './RecordIngestor';
+export { PrimingStore, RecordWithMetadata, WriteResult } from './PrimingStore';
+export { MetadataHandler } from './metadata/MetadataHandler';
+export { PrimingNetworkError } from './PrimingNetworkError';
+export { RecordLoaderGraphQL, RecordLoaderGraphQLBatch, RecordLoaderSOQLComposite, } from './recordLoaders';
+export type { RecordLoader } from './recordLoaders';
+export type { LdsRecordRefresher } from './LdsRecordRefresher';
+export type { PrimingEvents } from './PrimingSession';
+export type { PrimingNetworkAdapter } from './PrimingNetworkAdapter';

package/sfdc/types/priming/metadata/MetadataHandler.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from '../Emitter';
+import type { ObjectInfoLoader } from '../ObjectInfoLoader';
+export interface MetadataEvents {
+    progress: number;
+    error: MetadataError;
+    starting: {
+        cached: Set<string>;
+        expired: Set<string>;
+        missing: Set<string>;
+    };
+    primed: {
+        apiNames: Set<string>;
+    };
+    complete: {
+        apiNames: Map<string, CacheStatus>;
+    };
+}
+interface ErrorCouldNotFetchDirectory {
+    type: 'directory-error';
+}
+interface ErrorCouldNotFetchObjectInfos {
+    type: 'object-info-error';
+    apiNames: Set<string>;
+}
+interface ErrorAlreadyStarted {
+    type: 'already-started';
+}
+type MetadataError = ErrorCouldNotFetchDirectory | ErrorCouldNotFetchObjectInfos | ErrorAlreadyStarted;
+type CacheStatus = 'not-cached' | 'cached' | 'expired' | 'fetching' | 'error';
+export declare class MetadataHandler extends EventEmitter<MetadataEvents> {
+    private objectInfoLoader;
+    private config;
+    private apiNames;
+    private progress;
+    private started;
+    private workPool;
+    private batchSize;
+    private concurrency;
+    constructor(objectInfoLoader: ObjectInfoLoader, config: {
+        batchSize?: number;
+        concurrency?: number;
+    });
+    start(): Promise<void>;
+    cancel(): void;
+    private getBatches;
+    private executeBatchedWork;
+    private updateProgress;
+}
+export {};

package/sfdc/types/priming/primingSessionFactory.d.ts

@@ -0,0 +1,14 @@
+import { PrimingSession } from '../priming';
+import type { Adapter, Luvio } from '@luvio/engine';
+import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
+import type { ObjectInfoService } from '../main';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+export interface PrimingSessionFactoryConfig {
+    store: NimbusSqliteStore;
+    objectInfoService: ObjectInfoService;
+    getLuvio: () => Luvio;
+    concurrency?: number;
+    batchSize?: number;
+    getRecords: Adapter<GetRecordsConfig, BatchRepresentation>;
+}
+export declare function primingSessionFactory(config: PrimingSessionFactoryConfig): PrimingSession;

package/sfdc/types/priming/recordLoaders/NetworkRecordLoader.d.ts

@@ -0,0 +1,18 @@
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { ObservabilityContext, Request } from '@salesforce/nimbus-plugin-lds';
+import type { AvailableTypedBatch } from '../types';
+import type { RecordFetchResult, RecordLoader } from './RecordLoader';
+import type { PrimingNetworkAdapter } from '../PrimingNetworkAdapter';
+export declare abstract class NetworkRecordLoader implements RecordLoader {
+    private readonly networkAdapter;
+    constructor(networkAdapter: PrimingNetworkAdapter);
+    fetchRecordData(batch: AvailableTypedBatch, abortController: LdsAbortController, observabilityContext?: ObservabilityContext): Promise<RecordFetchResult[]>;
+    isResultWithPagination(result: RecordFetchResult): boolean;
+    getMissingIdsWithPagination(results: RecordFetchResult[]): Set<string>;
+    private sendRequest;
+    protected abstract makeRequest<T>(batch: AvailableTypedBatch, observabilityContext?: ObservabilityContext): {
+        request: Request;
+        context: T;
+    };
+    protected abstract generateFetchResults<T>(body: any, batchInput: AvailableTypedBatch, context: T): RecordFetchResult[];
+}

package/sfdc/types/priming/recordLoaders/RecordLoader.d.ts

@@ -0,0 +1,25 @@
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { AvailableTypedBatch } from '../types';
+import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
+import type { ObservabilityContext } from '@salesforce/nimbus-plugin-lds';
+interface RecordFetchResultSuccess {
+    ok: true;
+    records: DurableRecordRepresentation[];
+    missingIds: string[];
+}
+export interface RecordFetchResultSuccessWithPagination extends RecordFetchResultSuccess {
+    paginationToken: string;
+}
+interface RecordFetchResultFailure {
+    ok: false;
+    error: 'network-error' | 'service-protection-error' | 'request-error' | 'unknown';
+    messages: string[];
+    missingIds: string[];
+}
+export type RecordFetchResult = RecordFetchResultSuccess | RecordFetchResultSuccessWithPagination | RecordFetchResultFailure;
+export interface RecordLoader {
+    fetchRecordData(batch: AvailableTypedBatch, abortController: LdsAbortController, observabilityContext?: ObservabilityContext): Promise<RecordFetchResult[]>;
+    isResultWithPagination(result: RecordFetchResult): boolean;
+    getMissingIdsWithPagination(results: RecordFetchResult[]): Set<string>;
+}
+export {};

package/sfdc/types/priming/recordLoaders/RecordLoaderGraphQL.d.ts

@@ -0,0 +1,37 @@
+import type { ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { DurableRecordRepresentation } from '@salesforce/lds-durable-records';
+import type { ObservabilityContext, Request } from '@salesforce/nimbus-plugin-lds';
+import type { RecordFetchResult } from './RecordLoader';
+import type { AvailableTypedBatch, TypedBatch } from '../types';
+import { NetworkRecordLoader } from './NetworkRecordLoader';
+type GraphQLNode = {
+    Id: string;
+    ApiName: string;
+    DisplayValue: {
+        value: string | null;
+    };
+    LastModifiedById: {
+        value: string | null;
+    };
+    LastModifiedDate: {
+        value: string | null;
+    };
+    RecordTypeId: {
+        value: string | null;
+    };
+    SystemModstamp: {
+        value: string | null;
+    };
+    WeakEtag: number;
+    [field: string]: any;
+};
+export declare class RecordLoaderGraphQL extends NetworkRecordLoader {
+    protected makeRequest(batch: TypedBatch, observabilityContext?: ObservabilityContext): {
+        request: Request;
+        context: any;
+    };
+    protected generateFetchResults(repResult: any, batchInput: AvailableTypedBatch, _context: any): RecordFetchResult[];
+    protected generateGraphQLQuery(type: string, fields: string[]): string;
+    protected generateDurableRecordRepresentation(node: GraphQLNode, objectInfo: ObjectInfoRepresentation): DurableRecordRepresentation;
+}
+export {};

package/sfdc/types/priming/recordLoaders/RecordLoaderGraphQLBatch.d.ts

@@ -0,0 +1,11 @@
+import type { ObservabilityContext, Request } from '@salesforce/nimbus-plugin-lds';
+import type { AvailableTypedBatch, TypedBatch } from '../types';
+import type { RecordFetchResult } from './RecordLoader';
+import { RecordLoaderGraphQL } from './RecordLoaderGraphQL';
+export declare class RecordLoaderGraphQLBatch extends RecordLoaderGraphQL {
+    makeRequest(batch: TypedBatch, observabilityContext?: ObservabilityContext): {
+        request: Request;
+        context: string[][];
+    };
+    protected generateFetchResults(body: any, batchInput: AvailableTypedBatch, context: string[][]): RecordFetchResult[];
+}