@salesforce/lds-runtime-mobile 1.318.0 → 1.320.0

package/dist/types/graphql/dataloader.d.ts

@@ -0,0 +1,26 @@
+type BatchLoadFn<Key> = (keys: Key[]) => Promise<any>;
+type Batch<Key, Value> = {
+    hasDispatched: boolean;
+    keys: Array<Key>;
+    callbacks: Array<{
+        resolve: (value: Value) => void;
+        reject: (error: Error) => void;
+    }>;
+    cacheHits?: Array<() => void>;
+};
+export declare class DataLoader<Key, Value> {
+    private _batch;
+    private _batchLoadFn;
+    private _batchScheduleFn;
+    private _cacheMap;
+    private _maxBatchSize;
+    constructor(batchLoadFn: BatchLoadFn<Key>, options?: {
+        maxBatchSize?: number;
+    });
+    load(key: Key): Promise<Value>;
+    getCurrentBatch(): Batch<Key, Value>;
+    dispatchBatch(batch: Batch<Key, Value>): void;
+    failedDispatch(batch: Batch<Key, Value>, error: Error): void;
+    clear(key: Key): void;
+}
+export {};

package/dist/types/graphql/dateLiteral.d.ts

@@ -0,0 +1,28 @@
+import type { Operator, SinglePredicate } from './query';
+import type { FieldRepresentation } from './types';
+export declare enum DateLiteral {
+    NEXT_YEAR = "NEXT_YEAR",
+    LAST_WEEK = "LAST_WEEK",
+    THIS_MONTH = "THIS_MONTH",
+    THIS_QUARTER = "THIS_QUARTER",
+    LAST_MONTH = "LAST_MONTH",
+    LAST_90_DAYS = "LAST_90_DAYS",
+    LAST_QUARTER = "LAST_QUARTER",
+    THIS_YEAR = "THIS_YEAR",
+    NEXT_QUARTER = "NEXT_QUARTER",
+    NEXT_MONTH = "NEXT_MONTH",
+    TOMORROW = "TOMORROW",
+    TODAY = "TODAY",
+    LAST_YEAR = "LAST_YEAR",
+    NEXT_90_DAYS = "NEXT_90_DAYS",
+    THIS_WEEK = "THIS_WEEK",
+    YESTERDAY = "YESTERDAY",
+    NEXT_WEEK = "NEXT_WEEK"
+}
+export interface DateRange {
+    lowerBound: string;
+    upperBound: string;
+}
+export declare function quarterStart(date: Date): string;
+export declare function dateLiteralRange(literal: DateLiteral): DateRange;
+export declare function dateLiteral(literal: DateLiteral, op: Operator, field: FieldRepresentation, alias: string): SinglePredicate;

package/dist/types/graphql/dateTimePredication.d.ts

@@ -0,0 +1,33 @@
+import type { Operator, SinglePredicate } from './query';
+import type { FieldRepresentation } from './types';
+import { DateLiteral } from './dateLiteral';
+export declare enum DateRange {
+    last_n_days = "last_n_days",
+    next_n_days = "next_n_days",
+    n_days_ago = "n_days_ago",
+    last_n_weeks = "last_n_weeks",
+    next_n_weeks = "next_n_weeks",
+    n_weeks_ago = "n_weeks_ago",
+    last_n_months = "last_n_months",
+    next_n_months = "next_n_months",
+    n_months_ago = "n_months_ago",
+    last_n_quarters = "last_n_quarters",
+    next_n_quarters = "next_n_quarters",
+    n_quarters_ago = "n_quarters_ago",
+    last_n_fiscal_quarters = "last_n_fiscal_quarters",
+    next_n_fiscal_quarters = "next_n_fiscal_quarters",
+    last_n_years = "last_n_years",
+    next_n_years = "next_n_years",
+    n_years_ago = "n_years_ago",
+    last_n_fiscal_years = "last_n_fiscal_years",
+    next_n_fiscal_years = "next_n_fiscal_years"
+}
+type DateTime = string;
+export type DateTimeInput = {
+    value: DateTime | null;
+    literal: DateLiteral;
+    range: DateRangeInput;
+};
+type DateRangeInput = Record<string, number>;
+export declare function dateTimePredicate(input: Partial<DateTimeInput>, operator: Operator, field: FieldRepresentation, alias: string): SinglePredicate;
+export {};

package/dist/types/graphql/evaluate.d.ts

@@ -0,0 +1,12 @@
+import { type CachedGraphQLSchema } from './schema';
+import type { AvailableSnapshot, LuvioAdapterEventObserver } from '@luvio/engine';
+import type { GraphQLConfig, GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+import type { DraftFunctions, LocalEvaluationRuntimeSettings, ObjectInfoMap } from './types';
+type LocalEvaluationResult = {
+    result: GraphQLRepresentation;
+    seenRecordIds: string[];
+    possibleStaleRecordMap: Map<string, string[]>;
+};
+export declare function evaluate(config: GraphQLConfig, observers: LuvioAdapterEventObserver[], settings: LocalEvaluationRuntimeSettings, objectInfos: ObjectInfoMap, store: SqliteStore, snapshot: AvailableSnapshot<GraphQLRepresentation>, cache: CachedGraphQLSchema, draftFunctions?: DraftFunctions, mappedCursors?: Map<string, string>): Promise<LocalEvaluationResult>;
+export {};

package/dist/types/graphql/events.d.ts

@@ -0,0 +1,37 @@
+import type { CustomAdapterEvent } from '@luvio/engine';
+import type { SqliteType } from '@salesforce/lds-store-sql';
+import type { QueryInstrumentation } from './instrumentLimits';
+export declare const GRAPHQL_EVAL_NAMESPACE = "graphql-eval";
+interface GraphQLEvalStartCustomEventData {
+    type: 'graphql-eval-start';
+}
+interface GraphQLEvalPreconditionsMetCustomEventData {
+    type: 'graphql-eval-preconditions-met';
+}
+interface GraphQLEvalEndCustomEventData {
+    type: 'graphql-eval-end';
+}
+interface GraphQLDbReadCustomEventData {
+    type: 'graphql-db-read';
+    sql: string;
+    bindings: SqliteType[];
+    duration: number;
+}
+interface GraphQLEvalPreconditionErrorCustomEventData {
+    type: 'graphql-eval-precondition-error';
+    error: unknown;
+}
+interface GraphQLCreateSnapshotErrorCustomEventData {
+    type: 'graphql-create-snapshot-error';
+    error: unknown;
+}
+interface GraphQLQueryInstrumentationCustomEventData {
+    type: 'graphql-query-instrumentation';
+    data: QueryInstrumentation;
+}
+interface GraphQLSnapshotRefreshUndefined {
+    type: 'graphql-luvio-refresh-undefined';
+}
+export type GraphQLEvalCustomAdapterEventData = GraphQLEvalStartCustomEventData | GraphQLEvalPreconditionsMetCustomEventData | GraphQLEvalEndCustomEventData | GraphQLCreateSnapshotErrorCustomEventData | GraphQLEvalPreconditionErrorCustomEventData | GraphQLDbReadCustomEventData | GraphQLQueryInstrumentationCustomEventData | GraphQLSnapshotRefreshUndefined;
+export declare function isGraphQLEvalEvent(customEvent: CustomAdapterEvent<unknown>): customEvent is CustomAdapterEvent<GraphQLEvalCustomAdapterEventData>;
+export {};

package/dist/types/graphql/filterParser.d.ts

@@ -0,0 +1,6 @@
+import type { DraftFunctions, ObjectInfoMap } from './types';
+import { type Join } from './query';
+import type { PredicateValue, SqlAndBindings } from './query';
+export declare function filterToPredicates(where: any, recordType: string, alias: string, objectInfoMap: ObjectInfoMap, joins: Join[], draftFunctions?: DraftFunctions): PredicateValue[];
+export declare function predicateToSQL(predicate: PredicateValue, defaultAlias: string, isChildNotPredicate?: boolean): SqlAndBindings;
+export declare function predicatesToSqls(predicates: PredicateValue[], defaultAlias: string, isChildNotPredicate?: boolean): SqlAndBindings[];

package/dist/types/graphql/index.d.ts

@@ -0,0 +1,9 @@
+export { evaluate } from './evaluate';
+export { injectSyntheticFields, removeSyntheticFields } from './syntheticFields';
+export { DateLiteral } from './dateLiteral';
+export { DateRange } from './dateTimePredication';
+export { createSchemaWithCache, extendSchemaWithObjectInfos, CachedGraphQLSchema } from './schema';
+export type { ObjectInfoService, IDMapper, DraftFunctions } from './types';
+export { draftAwareGraphQLAdapterFactory, environmentAwareGraphQLBatchAdapterFactory, graphqlEvalAdapterFactory, } from './adapterFactory';
+export { isLocalEvalSnapshot } from './snapshot';
+export { isGraphQLEvalEvent } from './events';

package/dist/types/graphql/instrumentLimits.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentNode } from '@luvio/graphql-parser';
+export type QueryInstrumentation = {
+    rootQueryCount: number;
+    totalQueryCount: number;
+    maxChildRelationships: number;
+    requestedRecordCount: number;
+};
+export declare function instrumentLimits(ast: DocumentNode, variables: Record<string, any>): QueryInstrumentation;

package/dist/types/graphql/language.d.ts

@@ -0,0 +1,33 @@
+declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, values: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
+}, entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+}, assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+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;
+}, parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => 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[];
+};
+export { create as ObjectCreate, keys as ObjectKeys, values as ObjectValues, entries as ObjectEntries, assign as ObjectAssign, stringify as JSONStringify, parse as JSONParse, isArray as ArrayIsArray, from as ArrayFrom, };

package/dist/types/graphql/lib.d.ts

@@ -0,0 +1,52 @@
+import type { FieldNode, InlineFragmentNode, SelectionNode, ArgumentNode, OperationDefinitionNode, ASTNode } from '@luvio/graphql-parser';
+import type { FieldRepresentation, ObjectInfoRepresentation, RelationshipType } from './types';
+import type { QueryFunction } from './context';
+export declare const POLYMORPHIC_PARENT_RELATIONSHIP = "polymorphicParentRelationship";
+export declare const PARENT_RELATIONSHIP = "parentRelationship";
+export declare const CHILD_RELATIONSHIP = "childRelationship";
+declare const RECORD_QUERY = "recordQuery";
+type CategoryType = typeof POLYMORPHIC_PARENT_RELATIONSHIP | typeof PARENT_RELATIONSHIP | typeof CHILD_RELATIONSHIP | typeof RECORD_QUERY;
+export declare function requestsDraftsField(recordFieldNode: FieldNode): boolean;
+type RecordQueryPathInfo = {
+    node: FieldNode | InlineFragmentNode | undefined;
+    parentIndex: number;
+};
+export declare function fieldHasCategory(field: FieldNode, categories: ReadonlyArray<CategoryType>): boolean;
+export declare function isRecordQuery(field: FieldNode | undefined): boolean;
+export declare function isChildRelationshipQuery(field: FieldNode): boolean;
+export declare function isParentRelationshipQuery(field: FieldNode): boolean;
+export declare function findNearestConnection(ancestors: ReadonlyArray<any>): FieldNode | undefined;
+export declare function findNearestConnectionWithPath(ancestors: ReadonlyArray<any>): {
+    connection: FieldNode | undefined;
+    path: string | undefined;
+};
+export declare function findNearestAncesterPath(ancestors: ReadonlyArray<any>, connectionOnly: boolean): RecordQueryPathInfo;
+export declare function findAncesterPath(ancesters: ReadonlyArray<any>): string;
+/**
+ * checks if the 'SelectionNode' has the potential to have relationship(parent or child) with its ancestor.
+ * @param node
+ * @returns
+ */
+export declare function isCapableRelationship(node: SelectionNode): boolean;
+/**
+ * checks if the 'ArgumentNode' is a specific scope type
+ * @param node
+ * @param scopeType
+ * @param variables
+ * @returns
+ */
+export declare function isScopeArgumentNodeWithType(node: ArgumentNode, scopeType: string, variables?: Record<string, any>): boolean;
+export declare function getRelation(node: FieldNode | InlineFragmentNode): RelationshipType;
+export declare function isFieldSpanning(node: SelectionNode, parentNode?: FieldNode | InlineFragmentNode): boolean;
+export declare function isInlineFragmentFieldSpanning(node: SelectionNode): boolean;
+export declare function isRelationship(node: FieldNode | InlineFragmentNode, relationship: RelationshipType): boolean;
+export declare function isFieldAvailable(field: string, objectInfo: ObjectInfoRepresentation): boolean;
+export declare function mergeFieldNode(node1: FieldNode, node2: FieldNode): FieldNode;
+export declare function mergeInLineFragmentNode(node1: InlineFragmentNode, node2: InlineFragmentNode): InlineFragmentNode;
+export declare function depth(json: any, currentLevel?: number): number;
+export declare function flatten<T>(previous: T[], current: T[]): T[];
+export declare function findFieldInfo(objectInfo: ObjectInfoRepresentation, fieldName: string): FieldRepresentation | undefined;
+export declare function readIngestionTimestampForKey(key: string, query: QueryFunction): Promise<number>;
+export declare function isObjectDefinitionNode(node: ASTNode): node is OperationDefinitionNode;
+export declare function operationNodeAncestor(ancestors: ReadonlyArray<any>): OperationDefinitionNode | undefined;
+export {};

package/dist/types/graphql/limit.d.ts

@@ -0,0 +1,9 @@
+import { type DocumentNode } from 'graphql';
+import type { ObjectInfoMap } from './types';
+type EnforcedLimits = {
+    maxFieldCount: number;
+    maxRecordLimit: number;
+    singleRecordField: string;
+};
+export declare function enforceFieldLimitOnAST(ast: DocumentNode, variables: Record<string, any>, objectInfos: ObjectInfoMap, enforcedLimits?: EnforcedLimits): DocumentNode;
+export {};

package/dist/types/graphql/orderByParser.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectInfoMap } from './types';
+import type { Join } from './query';
+export type OrderByPredicate = {
+    alias: string;
+    path: string;
+    order?: 'ASC' | 'DESC';
+    nulls?: 'FIRST' | 'LAST';
+    joins?: Join[];
+};
+export declare function orderByToPredicate(orderBy: any, recordType: string, alias: string, objectInfoMap: ObjectInfoMap, joins?: Join[]): OrderByPredicate[];

package/dist/types/graphql/pagination.d.ts

@@ -0,0 +1,10 @@
+import type { QueryFunction } from './context';
+import type { DocumentNode } from '@luvio/graphql-parser';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+export type PaginationMetadata = Record<string, number | undefined>;
+export declare function mapCursorValue(originalValue: string | null | undefined, paginationMetadata: PaginationMetadata): string | null;
+export declare function mapPaginationCursors(originalAST: DocumentNode, variables: Record<string, any>, store: SqliteStore): Promise<{
+    ast: DocumentNode;
+    mappedCursors: Map<string, string>;
+}>;
+export declare function readPaginationMetadataForKeys(keys: string[], query: QueryFunction): Promise<Map<string, PaginationMetadata>>;

package/dist/types/graphql/query.d.ts

@@ -0,0 +1,56 @@
+import type { OrderByPredicate } from './orderByParser';
+import type { SQLStatement } from './types';
+export type PredicatePath = {
+    leftPath: string;
+    rightPath: string;
+};
+export type DataType = 'Boolean' | 'String' | 'Double' | 'Date' | 'DateTime' | 'Int' | 'WeakEtag' | 'Reference' | 'Picklist' | 'Currency' | 'MultiPicklist' | 'Time' | 'Phone' | 'Url' | 'TextArea' | 'Email' | 'Percent';
+export type PredicateValue = CompoundPredicate | SinglePredicate | NotPredicate;
+export type NotPredicate = {
+    type: PredicateType.not;
+    operator: NotOperator;
+    children: (CompoundPredicate | SinglePredicate)[];
+};
+export type CompoundPredicate = {
+    type: PredicateType.compound;
+    operator: CompoundOperator;
+    children: PredicateValue[];
+};
+export type SinglePredicate = {
+    type: PredicateType.single;
+    alias?: string;
+    leftPath: string;
+    operator: Operator;
+    value: unknown;
+    bindings?: unknown[];
+    dataType?: DataType;
+    isCaseSensitive?: boolean;
+};
+export type CompoundOperator = 'and' | 'or';
+export type NotOperator = 'not';
+export type Operator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'IN' | 'NOT IN' | 'LIKE' | 'NOT LIKE' | 'BETWEEN' | 'NOT BETWEEN' | 'IS' | 'IS NOT';
+export declare enum PredicateType {
+    compound = "compound",
+    single = "single",
+    not = "not"
+}
+export type SqlAndBindings = {
+    sql: string;
+    binding: any[];
+};
+export type Join = {
+    type: 'INNER' | 'LEFT';
+    alias: string;
+    to: string;
+    apiName?: string;
+    conditions: (PredicatePath | PredicateValue)[];
+};
+export type QueryBuilderConfig = {
+    alias: string;
+    joins?: Join[];
+    predicates?: PredicateValue[];
+    limit?: number;
+    offset?: number;
+    orderBy?: OrderByPredicate[];
+};
+export declare function buildQuery(config: QueryBuilderConfig): SQLStatement;

package/dist/types/graphql/recordLoader.d.ts

@@ -0,0 +1,4 @@
+import { DataLoader } from './dataloader';
+import type { SqliteResult, SqliteType } from '@salesforce/lds-store-sql';
+import type { RecordRepresentation } from './types';
+export declare function recordLoaderFactory(query: (sql: string, params: SqliteType[]) => Promise<SqliteResult>): DataLoader<string, RecordRepresentation>;

package/dist/types/graphql/resolvers/basic.d.ts

@@ -0,0 +1 @@
+export declare function passThroughResolver(source: any): any;

package/dist/types/graphql/resolvers/connection.d.ts

@@ -0,0 +1,31 @@
+import type { RecordQueryArgs, RecordRepresentation } from '../types';
+import type { ArgumentNode, GraphQLResolveInfo, OperationDefinitionNode } from 'graphql';
+import type { ResolverContext } from '../context';
+export type RecordInformation = {
+    recordRepresentation: RecordRepresentation;
+    ingestionTimestamp: number;
+};
+export type IndexedRecordInformation = RecordInformation & {
+    index: number;
+    earlyEnd?: boolean;
+};
+export type RecordConnectionInformation = {
+    records: IndexedRecordInformation[];
+    hasNextPage: boolean;
+    earlyEnd: boolean;
+    offset: number;
+};
+export declare function connectionResolver(obj: Partial<RecordInformation>, args: RecordQueryArgs, context: ResolverContext, info: GraphQLResolveInfo): Promise<RecordConnectionInformation>;
+/**
+ * Returns just the records array of a connection result, used for edges field
+ */
+export declare function edgesResolver(obj: RecordConnectionInformation): IndexedRecordInformation[];
+/**
+ * Builds the top level record query key based on AST data
+ * @param operation
+ * @param variables
+ * @param argumentNodes
+ * @param currentFieldName
+ * @returns
+ */
+export declare function buildKeyStringForRecordQuery(operation: OperationDefinitionNode, variables: Record<string, any>, argumentNodes: Readonly<ArgumentNode[]>, currentFieldName: string): string;

package/dist/types/graphql/resolvers/index.d.ts

@@ -0,0 +1,8 @@
+import type { GraphQLSchema } from '@luvio/graphql-parser';
+/**
+ *
+ * @param schema GraphQL Schema generated from ObjectInfos
+ * @param polyFields The record types which support polymorphic fields. For example, 'Owner' has the 'Record' interface which is a polymorphic fields. The 'User' and 'Group' are the concrete types which support 'Owner' interface.
+ * @returns Updated schema
+ */
+export declare function addResolversToSchema(schema: GraphQLSchema, polyFields: string[]): GraphQLSchema;

package/dist/types/graphql/resolvers/pagination.d.ts

@@ -0,0 +1,29 @@
+import type { IndexedRecordInformation, RecordConnectionInformation } from './connection';
+import type { FragmentDefinitionNode, SelectionNode } from 'graphql';
+export declare function cursorResolver(source: IndexedRecordInformation): string;
+export declare function pageInfoResolver(source: RecordConnectionInformation): {
+    startCursor: null;
+    endCursor: string;
+    hasNextPage: boolean;
+} | {
+    startCursor: null;
+    endCursor: null;
+    hasNextPage: boolean;
+} | {
+    startCursor: string;
+    endCursor: string;
+    hasNextPage: boolean;
+};
+export declare function pageResultCountResolver(source: RecordConnectionInformation): number;
+export interface LocalCursor {
+    i: number;
+    e?: unknown;
+}
+export declare function encodeV1Cursor(cursor: LocalCursor): string;
+export declare function decodeV1Cursor(base64cursor: string): LocalCursor;
+/**
+ * Check the selections for any selection matching `pageInfo { hasNextPage }`
+ */
+export declare function selectionIncludesHasNextPage(selections: ReadonlyArray<SelectionNode>, fragments: {
+    [key: string]: FragmentDefinitionNode;
+}): boolean;

package/dist/types/graphql/schema.d.ts

@@ -0,0 +1,51 @@
+import { type GraphQLSchema } from '@luvio/graphql-parser';
+import type { ObjectInfoMap } from './types';
+export declare class CachedGraphQLSchema {
+    private _schema;
+    private _polymorphicFieldTypeNames;
+    constructor();
+    getSchema(): GraphQLSchema;
+    setSchema(value: GraphQLSchema): void;
+    getPolymorphicFieldTypeNames(): string[];
+    setPolymorphicFieldTypeNames(value: string[]): void;
+    set(schema: GraphQLSchema, polymorphicFieldTypeNames: string[]): void;
+}
+/**
+ * Looks at the injected object info map and checks to see if the existing objects
+ * are within the current schema. It will extend the cached schema if it is not included.
+ * @param objectInfos
+ * @param cache
+ * @returns GraphQLSchema
+ */
+export declare function createSchemaWithCache(objectInfos: ObjectInfoMap, cache: CachedGraphQLSchema): GraphQLSchema;
+/**
+ * Extends the current GraphQL Schema with new types based on the given object info map
+ *
+ * @param cache the existing cached schema object
+ * @param objectInfoMap map of object info and apiname for key
+ * @returns CachedGraphQLSchema
+ */
+export declare function extendSchemaWithObjectInfos(cache: CachedGraphQLSchema, objectInfoMap: ObjectInfoMap): CachedGraphQLSchema;
+/**
+ * Builds the base schema from uiapi graphql adapter with resolvers attached
+ * @returns GraphQLSchema
+ */
+export declare function buildBaseSchema(): GraphQLSchema;
+/**
+ * Given the existing schema and the object infos it will create a new type for the schema
+ * or extend an existing type to add new fields to it.
+ *
+ * Extends RecordQuery to add new top level queries
+ * extend type RecordQuery {
+ *   Account(predicates): AccountConnection
+ * }
+ * @param schema
+ * @param objectInfoMap
+ * @returns
+ */
+export declare function generateRecordQueries(schema: GraphQLSchema, objectInfoMap: ObjectInfoMap): {
+    recordQueries: string;
+    recordConnections: string;
+    recordExtensions: string;
+    polyFieldTypeNameArr: string[];
+};

package/dist/types/graphql/scopeParser.d.ts

@@ -0,0 +1,4 @@
+import type { Join, PredicateValue } from './query';
+import type { LocalEvaluationRuntimeSettings } from './types';
+export declare function scopeToJoins(scope: string | undefined, settings: LocalEvaluationRuntimeSettings): Join[];
+export declare function scopeToPredicates(scope: string | undefined, settings: LocalEvaluationRuntimeSettings): PredicateValue[];

package/dist/types/graphql/snapshot.d.ts

@@ -0,0 +1,26 @@
+import type { Snapshot, ErrorSnapshot, AvailableSnapshot, NormalizedKeyMetadata, SnapshotRefresh } from '@luvio/engine';
+import { StoreKeySet } from '@luvio/engine';
+import type { GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+export type StaleRefreshLocalEvalSnapshot = LocalEvalSnapshot & {
+    refreshStaleRecords: (keys: Set<string>) => Promise<void>;
+};
+export type LocalEvalSnapshot = AvailableSnapshot<GraphQLRepresentation> & {
+    rebuildWithLocalEval: (originalSnapshot: AvailableSnapshot<GraphQLRepresentation>) => Promise<LocalEvalSnapshot>;
+};
+export declare function isLocalEvalSnapshot(snapshot: Snapshot<unknown>): snapshot is LocalEvalSnapshot;
+export declare function createSeenRecords(ids: string[], currentSnapshot: AvailableSnapshot<unknown>): StoreKeySet<string | NormalizedKeyMetadata>;
+export declare function createErrorSnapshot(result: Partial<{
+    errors: any[];
+}>, snapshot: Snapshot<unknown>): ErrorSnapshot;
+export declare function createLocalEvalSnapshot<D>(data: GraphQLRepresentation, seenRecords: StoreKeySet<string | NormalizedKeyMetadata>, recordId: string, rebuildWithLocalEval: LocalEvalSnapshot['rebuildWithLocalEval'], refresh?: SnapshotRefresh<any>): LocalEvalSnapshot;
+/**
+ * If we can't reach the server or if we get back a 504 (which means only-if-cached
+ * cache policy was used but this query hasn't been cached) then we still want to
+ * attempt an eval.  All other errors should be returned to caller.
+ */
+export declare function isErrorSnapshotThatShouldGetReturnedToCaller(snapshot: Snapshot<GraphQLRepresentation>): boolean;
+/**
+ * Checks a GraphQL-shaped network response for errors, returning true if it does
+ * and false otherwise
+ */
+export declare function hasGraphQlErrors(response: GraphQLRepresentation | undefined): boolean;

package/dist/types/graphql/staleRecords/batchingStaleRecordsAdapter.d.ts

@@ -0,0 +1,10 @@
+import { type Adapter, type Luvio } from '@luvio/engine';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+/**
+ * Adapter for limiting the number of record ids to a maximum of 100 and sending them
+ * out in batches to the getRecords adapter
+ *
+ * @param luvio
+ * @returns
+ */
+export declare function batchingGetRecordsAdapterFactory(luvio: Luvio): Adapter<GetRecordsConfig, BatchRepresentation>;

package/dist/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/dist/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/dist/types/instrumentation/instrumentPrimingSession.d.ts

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

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

@@ -1,4 +1,4 @@
-import type { QueryInstrumentation } from '@salesforce/lds-graphql-local-evaluation/dist/types/instrumentLimits';
+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: import("o11y/dist/modules/o11y/client/interfaces").Instrumentation;

package/dist/types/main.d.ts

@@ -5,3 +5,4 @@ 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';

package/dist/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';
+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/dist/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/dist/types/priming/LdsPrimingRecordRefresher.d.ts

@@ -1,6 +1,6 @@
 import type { Adapter } from '@luvio/engine';
 import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
-import type { LdsRecordRefresher } from '@salesforce/lds-priming';
+import type { LdsRecordRefresher } from '../priming';
 export declare class LdsPrimingRecordRefresher implements LdsRecordRefresher {
     private getRecordsAdapter;
     constructor(getRecordsAdapter: Adapter<GetRecordsConfig, BatchRepresentation>);