@salesforce/lds-runtime-mobile 1.314.0 → 1.316.0

package/sfdc/types/adapters/util/language.d.ts

@@ -0,0 +1,42 @@
+declare const 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;
+}, create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, freeze: {
+    <T extends Function>(f: T): T;
+    <T_1 extends {
+        [idx: string]: object | U | null | undefined;
+    }, U extends string | number | bigint | boolean | symbol>(o: T_1): Readonly<T_1>;
+    <T_2>(o: T_2): Readonly<T_2>;
+}, isFrozen: (o: any) => boolean, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+declare const hasOwnProperty: (v: PropertyKey) => boolean;
+declare const split: {
+    (separator: string | RegExp, limit?: number | undefined): string[];
+    (splitter: {
+        [Symbol.split](string: string, limit?: number | undefined): string[];
+    }, limit?: number | undefined): string[];
+}, endsWith: (searchString: string, endPosition?: number | undefined) => boolean;
+declare const isArray: (arg: any) => arg is any[];
+declare const concat: {
+    (...items: ConcatArray<any>[]): any[];
+    (...items: any[]): any[];
+}, filter: {
+    <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[];
+    (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[];
+}, includes: (searchElement: any, fromIndex?: number | undefined) => boolean, push: (...items: any[]) => number, reduce: {
+    (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any;
+    (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any;
+    <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U;
+};
+declare const parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any, 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 { assign as ObjectAssign, create as ObjectCreate, freeze as ObjectFreeze, isFrozen as ObjectIsFrozen, keys as ObjectKeys, hasOwnProperty as ObjectPrototypeHasOwnProperty, isArray as ArrayIsArray, concat as ArrayPrototypeConcat, filter as ArrayPrototypeFilter, includes as ArrayPrototypeIncludes, push as ArrayPrototypePush, reduce as ArrayPrototypeReduce, split as StringPrototypeSplit, endsWith as StringPrototypeEndsWith, parse as JSONParse, stringify as JSONStringify, };

package/sfdc/types/adapters/util/layout.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The master record type id.
+ */
+export declare const MAIN_RECORD_TYPE_ID = "012000000000000AAA";

package/sfdc/types/adapters/util/layouts.d.ts

@@ -0,0 +1,8 @@
+import type { RecordLayoutRepresentation } from '../generated/types/RecordLayoutRepresentation';
+import type { ObjectInfoRepresentation } from '../generated/types/ObjectInfoRepresentation';
+export interface FieldsAndOptionalFields {
+    fields: string[];
+    optionalFields: string[];
+}
+export declare function getNameField(objectInfo: ObjectInfoRepresentation, fieldApiName: string): string;
+export declare function getQualifiedFieldApiNamesFromLayout(layout: RecordLayoutRepresentation, objectInfo: ObjectInfoRepresentation): FieldsAndOptionalFields;

package/sfdc/types/adapters/util/lists.d.ts

@@ -0,0 +1,88 @@
+import type { Luvio, PathSelection, AdapterContext, Snapshot, FulfilledSnapshot, StaleSnapshot, StoreLookup } from '@luvio/engine';
+import type { ListInfoRepresentation } from '../generated/types/ListInfoRepresentation';
+import type { ListReferenceRepresentation } from '../generated/types/ListReferenceRepresentation';
+import type { RecordRepresentation } from '../generated/types/RecordRepresentation';
+import type { ListRecordCollectionRepresentation } from '../generated/types/ListRecordCollectionRepresentation';
+export interface ListReferenceQuery {
+    listViewId?: string;
+    objectApiName?: string;
+    listViewApiName?: string;
+}
+/**
+ * Adds a list reference so it can be retrieved with #getListReference later.
+ *
+ * @param listRef list reference
+ */
+export declare function addListReference(listRef: ListReferenceRepresentation, context: AdapterContext): void;
+/**
+ * Adds a list reference with some specified key so it can be retrieved with #getListReference later.
+ *
+ * @param listRef
+ * @param context
+ * @param id - Specified Id to use in the context key
+ */
+export declare function addListReferenceWithId(listRef: ListReferenceRepresentation, context: AdapterContext, id: string | null): void;
+/**
+ * Returns a list reference from the store if it's present.
+ *
+ * @param query list view to look for
+ * @param luvio Luvio
+ */
+export declare function getListReference(query: ListReferenceQuery, context: AdapterContext): ListReferenceRepresentation | undefined;
+/**
+ * Reader selections to copy a list info
+ */
+export declare const LIST_INFO_SELECTIONS: PathSelection[];
+/**
+ * List info private memebers
+ */
+export declare const LIST_INFO_PRIVATES: string[];
+/**
+ * Retrieves the snapshot of the list info corresponding to the specified list
+ * reference from the store.
+ *
+ * @param listRef list reference
+ * @param luvio Luvio
+ */
+export declare function getListInfo(luvio: Luvio, listRef: ListReferenceRepresentation, storeLookup: StoreLookup<ListInfoRepresentation>): Snapshot<ListInfoRepresentation>;
+export interface ServerDefaultable {
+    sortBy?: string[];
+}
+export interface ServerDefaults {
+    sortBy?: string[];
+}
+/**
+ * Update the default values based on a server response.
+ *
+ * @param config getListUi config
+ * @param serverResponse ListUiRepresentation from the server
+ */
+export declare function addServerDefaults(config: ListReferenceQuery & ServerDefaultable, records: ListRecordCollectionRepresentation, listReference: ListReferenceRepresentation, context: AdapterContext): void;
+/**
+ * Returns default values observed on previous requests for a list.
+ *
+ * @param config getListUi config
+ * @returns defaults from previous requests for this list, or {} if no defaults are known
+ */
+export declare function getServerDefaults(config: ListReferenceQuery, context: AdapterContext): ServerDefaults;
+export interface ListFields {
+    getRecordSelectionFieldSets: () => [string[], string[]];
+    processRecords: (records: RecordRepresentation[]) => ListFields;
+}
+export declare function listFields(luvio: Luvio, { fields, optionalFields, sortBy, }: {
+    fields?: string[];
+    optionalFields?: string[];
+    sortBy?: string[];
+}, listInfo: ListInfoRepresentation): ListFields;
+export declare function isListInfoSnapshotWithData(snapshot: Snapshot<unknown>): snapshot is FulfilledSnapshot<ListInfoRepresentation> | StaleSnapshot<ListInfoRepresentation>;
+interface notifyAllListRecordInput {
+    objectApiName: string;
+    listViewApiName: string;
+}
+export declare function setupNotifyAllListRecordUpdateAvailable(luvio: Luvio): (notifyInput: notifyAllListRecordInput) => Promise<void>;
+interface notifyAllListInfoSummaryInput {
+    objectApiName: string;
+    recentLists: boolean | undefined;
+}
+export declare function setupNotifyAllListInfoSummaryUpdateAvailable(luvio: Luvio): (notifyInput: notifyAllListInfoSummaryInput) => Promise<void>;
+export {};

package/sfdc/types/adapters/util/pagination.d.ts

@@ -0,0 +1,26 @@
+import type { PaginationMetadata, offsetFromToken, tokenForAtMost } from '../generated/pagination/cursor';
+/**
+ * Examines a set of paginated data & metadata from an UnfulfilledSnapshot and computes a
+ * pageToken and pageSize that will minimize the amount of data requested while still
+ * satisfying the original request.
+ *
+ * @param config.name name of the field within data that contains the items
+ * @param conifg.data paginated data/metadata from an UnfulfilledSnapshot
+ * @param config.pageSize requested pageSize
+ * @param config.pagination pagination data/functions from engine
+ * @returns pageToken & pageSize to fill in the missing data
+ */
+export declare function minimizeRequest(config: {
+    name: string;
+    data: any | null;
+    pageToken: string | undefined;
+    pageSize: number;
+    pagination: {
+        offsetFromToken: typeof offsetFromToken;
+        tokenForAtMost: typeof tokenForAtMost;
+        paginationMetadata: PaginationMetadata;
+    };
+}): {
+    pageToken: string | undefined;
+    pageSize: number;
+};

package/sfdc/types/adapters/util/promise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise<T>(value: Promise<T> | T): value is Promise<T>;

package/sfdc/types/adapters/util/record-ingest.d.ts

@@ -0,0 +1,8 @@
+import type { ResourceIngest, IngestPath, Luvio, Store } from '@luvio/engine';
+import type { RecordRepresentation } from '../generated/types/RecordRepresentation';
+import type { RecordFieldTrie } from './records';
+import type { RecordConflictMap } from '../helpers/RecordRepresentation/resolveConflict';
+import type { RecordRepresentationNormalized } from '../generated/types/RecordRepresentation';
+export declare function createFieldsIngestion(fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap): ResourceIngest;
+export declare function createChildRecordNormalize(fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap): (input: RecordRepresentation, existing: RecordRepresentationNormalized | undefined, path: IngestPath, luvio: Luvio, store: Store, timestamp: number) => RecordRepresentationNormalized;
+export declare const createRecordIngest: (fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap) => ResourceIngest;

package/sfdc/types/adapters/util/record-ui.d.ts

@@ -0,0 +1,4 @@
+import type { RecordUiRepresentation } from '../generated/types/RecordUiRepresentation';
+export declare function getRecordUiMissingRecordLookupFields(recordUi: RecordUiRepresentation): {
+    [key: string]: string[];
+};

package/sfdc/types/adapters/util/records.d.ts

@@ -0,0 +1,119 @@
+import type { ProxyGraphNode, GraphNode, NormalizedKeyMetadata, FetchResponse, Luvio, ResourceIngest, Snapshot, StoreRecordError } from '@luvio/engine';
+import type { FieldValueRepresentation } from '../generated/types/FieldValueRepresentation';
+import type { RecordCreateDefaultRecordRepresentation } from '../generated/types/RecordCreateDefaultRecordRepresentation';
+import type { ObjectInfoRepresentation } from '../generated/types/ObjectInfoRepresentation';
+import type { RecordInputRepresentation } from '../generated/types/RecordInputRepresentation';
+import type { RecordRepresentation, RecordRepresentationNormalized } from '../generated/types/RecordRepresentation';
+import type { FieldId } from '../primitives/FieldId';
+import type { FieldMapRepresentation, FieldMapRepresentationNormalized } from './fields';
+import type { RecordConflictMap } from '../helpers/RecordRepresentation/resolveConflict';
+type FieldValueRepresentationValue = FieldValueRepresentation['value'];
+export declare const RECORD_REPRESENTATION_ERROR_VERSION = "RECORD_REPRESENTATION_ERROR_VERSION_1";
+export declare const RECORD_REPRESENTATION_ERROR_STORE_METADATA_PARAMS: {
+    representationName: string;
+    namespace: string;
+    ttl: number;
+    version: string;
+};
+export interface LinkState {
+    fields: string[];
+}
+export interface RecordLayoutFragment {
+    apiName: RecordRepresentation['apiName'];
+    recordTypeId: RecordRepresentation['recordTypeId'];
+}
+export declare function isErrorEntry(entry: RecordRepresentationNormalized | StoreRecordError | undefined): entry is StoreRecordError;
+/**
+ * A trie data structure representing where each node represents a field on a RecordRepresentation.
+ */
+export interface RecordFieldTrie {
+    name: string;
+    children: {
+        [name: string]: RecordFieldTrie;
+    };
+    scalar?: boolean;
+    optional?: boolean;
+}
+export interface TrackedFieldsConfig {
+    maxDepth: number;
+    onlyFetchLeafNodeIdAndName: boolean;
+}
+export declare function isGraphNode(node: ProxyGraphNode<unknown>): node is GraphNode<unknown>;
+export declare function extractTrackedFieldsToTrie(recordId: string | NormalizedKeyMetadata, node: ProxyGraphNode<FieldMapRepresentationNormalized, FieldMapRepresentation>, root: RecordFieldTrie): void;
+export declare function convertTrieToFields(root: RecordFieldTrie): string[];
+export declare function convertTrieToFieldsRecursively(root: RecordFieldTrie): string[];
+export declare const BLANK_RECORD_FIELDS_TRIE: Readonly<{
+    name: "";
+    children: {};
+}>;
+export declare const convertFieldsToTrie: (fields?: string[], isOptional?: boolean) => RecordFieldTrie;
+export declare function getTrackedFields(key: string | NormalizedKeyMetadata, graphNode: ProxyGraphNode<FieldMapRepresentationNormalized, FieldMapRepresentation>, config: TrackedFieldsConfig, fieldsFromConfig?: string[]): string[];
+/**
+ * Returns a new object that has a list of fields that has been filtered by
+ * edited fields. Only contains fields that have been edited from their original
+ * values (excluding Id which is always copied over).
+ * @param input The RecordInputRepresentation object to filter.
+ * @param original The Record object that contains the original field values.
+ * @returns RecordInputRepresentation, see the description
+ */
+export declare function createRecordInputFilteredByEditedFields(input: RecordInputRepresentation, original: RecordRepresentation): RecordInputRepresentation;
+/**
+ * Returns an object with its data populated from the given record. All fields
+ * with values that aren't nested records will be assigned. This object can be
+ * used to create a record.
+ * @param record The record that contains the source data.
+ * @param objectInfo The ObjectInfo corresponding to the apiName on the record.
+ *        If provided, only fields that are createable=true (excluding Id) will
+ *        be assigned to the object return value.
+ * @returns RecordInputRepresentation See description.
+ */
+export declare function generateRecordInputForCreate(record: RecordRepresentation, objectInfo?: ObjectInfoRepresentation): RecordInputRepresentation;
+/**
+ * Returns an object with its data populated from the given record. All fields
+ * with values that aren't nested records will be assigned. This object can be
+ * used to update a record.
+ * @param record The record that contains the source data.
+ * @param objectInfo The ObjectInfo corresponding to the apiName on the record.
+ *        If provided, only fields that are updateable=true (excluding Id) will
+ *        be assigned to the object return value.
+ * @returns RecordInputRepresentation See description.
+ */
+export declare function generateRecordInputForUpdate(record: RecordRepresentation, objectInfo?: ObjectInfoRepresentation): RecordInputRepresentation;
+/**
+ * Gets a new Record Input.
+ */
+export declare function getRecordInput(): RecordInputRepresentation;
+/**
+ * Gets a field's value from a record.
+ * @param record The record.
+ * @param field The qualified API name of the field to return.
+ * @returns The field's value (which may be a record in the case of spanning
+ *          fields), or undefined if the field isn't found.
+ */
+export declare function getFieldValue(record: RecordRepresentation, field: FieldId | string): FieldValueRepresentationValue | undefined;
+/**
+ * Gets a field's display value from a record.
+ * @param record The record.
+ * @param field The qualified API name of the field to return.
+ * @returns The field's display value, or undefined if the field isn't found.
+ */
+export declare function getFieldDisplayValue(record: RecordRepresentation, field: FieldId | string): FieldValueRepresentationValue | undefined;
+export declare function getRecordTypeId(record: RecordRepresentation | RecordLayoutFragment): string;
+export declare function markMissingOptionalFields(record: ProxyGraphNode<FieldMapRepresentationNormalized, FieldMapRepresentation>, optionalFields: string[]): void;
+export declare function markNulledOutRequiredFields(record: ProxyGraphNode<RecordRepresentationNormalized, RecordRepresentation>, fields: string[]): void;
+/**
+ * Tells you if an objectApiName is supported by UI API or not.
+ * Note: Luvio does not currently support all the entities, the list is limited to UI API supported entities
+ * @param objectApiName the object API name from a record.
+ * @return True if the provided objectApiName is supported in UI API.
+ */
+export declare function isSupportedEntity(objectApiName: string): boolean;
+/** Return true if a >= b */
+export declare function isSuperset(a: string[], b: string[]): boolean;
+/** return true if a and b start with the same root name and a contains all nodes in b */
+export declare function isSuperRecordFieldTrie(a: RecordFieldTrie, b: RecordFieldTrie): boolean;
+export declare function extractRecordIds(record: RecordRepresentation | RecordCreateDefaultRecordRepresentation, luvio: Luvio): {
+    [key: string]: boolean;
+};
+export declare function ingestRecordResponse(luvio: Luvio, response: FetchResponse<RecordRepresentation>, recordId: string, recordIngest: ResourceIngest, conflictMap: RecordConflictMap): Snapshot<RecordRepresentation>;
+export {};

package/sfdc/types/adapters/util/snapshot.d.ts

@@ -0,0 +1,5 @@
+import type { Snapshot, ErrorSnapshot, FulfilledSnapshot, UnfulfilledSnapshot, StaleSnapshot } from '@luvio/engine';
+export declare function isFulfilledSnapshot<T, U>(snapshot: Snapshot<T, U>): snapshot is FulfilledSnapshot<T, U>;
+export declare function isUnfulfilledSnapshot<T, U>(snapshot: Snapshot<T, U>): snapshot is UnfulfilledSnapshot<T, U>;
+export declare function isStaleSnapshot<T, U>(snapshot: Snapshot<any>): snapshot is StaleSnapshot<T, U>;
+export declare function isErrorSnapshot(snapshot: Snapshot<any>): snapshot is ErrorSnapshot;

package/sfdc/types/adapters/util/store-utils.d.ts

@@ -0,0 +1,9 @@
+export declare const API_NAMESPACE = "UiApi";
+export declare const RECORD_REPRESENTATION_NAME = "RecordRepresentation";
+export declare const RECORD_VIEW_ENTITY_REPRESENTATION_NAME = "RecordViewEntityRepresentation";
+export declare const RECORD_ID_PREFIX: string;
+export declare const RECORD_VIEW_ENTITY_ID_PREFIX: string;
+export declare const RECORD_FIELDS_KEY_JUNCTION = "__fields__";
+export declare function extractRecordIdFromStoreKey(key: string): string | undefined;
+export declare function isStoreKeyRecordViewEntity(key: string): boolean;
+export declare function buildRecordRepKeyFromId(recordId: string): string;

package/sfdc/types/adapters/util/supported-entities.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A set of the string names of known entities.
+ *
+ * Generated
+ *     from: ui-services-private-object-allow-list.yaml
+ *     API version: 60
+ *     at: Fri, 10 Nov 2023 19:35:20 GMT
+ */
+export declare const UIAPI_SUPPORTED_ENTITY_API_NAMES: Set<string>;
+/**
+ * A set of the string names of known entities.
+ *
+ * Generated
+ *     from: ui-services-private-object-deny-list.yaml
+ *     API version: 60
+ *     at: Fri, 10 Nov 2023 19:35:20 GMT
+ */
+export declare const UIAPI_DENIED_ENTITY_API_NAMES: Set<string>;

package/sfdc/types/adapters/validation/utils.d.ts

@@ -0,0 +1,24 @@
+export declare function isString(value: any): value is string;
+/**
+ * Converts a value to an array. If the value is null/undefined, an empty array is returned.
+ * @param value The value to convert to an array.
+ * @returns value if it's an array; an empty array if value is null/undefined; otherwise value wrapped in an array.
+ */
+export declare function toArray<T>(value: T | T[] | undefined): T[];
+/**
+ * @param value The array to inspect.
+ * @returns True if the array is non-empty and contains only non-empty strings.
+ */
+export declare function isArrayOfNonEmptyStrings(value: any[]): value is string[];
+/**
+ * @param value The array to dedupe
+ * @returns An array without duplicates.
+ */
+export declare function dedupe<T extends string>(value: T[]): T[];
+/**
+ * @param source The array of string to filter
+ * @param compare The array to filter against
+ * @returns An array with values from source that do not exist in compare
+ * If the "compare" array is empty, "source" array itself is returned, not a shallow copy
+ */
+export declare function difference(source: string[], compare: string[]): string[];

package/sfdc/types/adapters/wire/getListRecordsByName/index.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterFactory } from '@luvio/engine';
+import type { GetListRecordsByNameConfig } from '../../generated/adapters/getListRecordsByName';
+import type { ListRecordCollectionRepresentation } from '../../generated/types/ListRecordCollectionRepresentation';
+export declare const factory: AdapterFactory<GetListRecordsByNameConfig, ListRecordCollectionRepresentation>;

package/sfdc/types/adapters/wire/getListUi/index.d.ts

@@ -0,0 +1,12 @@
+import type { AdapterFactory } from '@luvio/engine';
+import type { GetListUiByApiNameConfig } from '../../generated/adapters/getListUiByApiName';
+import type { GetListUiByListViewIdConfig } from '../../generated/adapters/getListUiByListViewId';
+import type { GetListViewSummaryCollectionConfig } from '../../generated/adapters/getListViewSummaryCollection';
+import type { GetMruListUiConfig } from '../../generated/adapters/getMruListUi';
+import type { ListUiRepresentation } from '../../generated/types/ListUiRepresentation';
+import type { ListViewSummaryCollectionRepresentation } from '../../generated/types/ListViewSummaryCollectionRepresentation';
+type GetListUiConfig = GetListUiByApiNameConfig | GetListUiByListViewIdConfig;
+export declare function validateGetListUiConfig(untrustedConfig: unknown): GetListUiConfig | null;
+export declare const MRU: unique symbol;
+export declare const factory: AdapterFactory<GetListViewSummaryCollectionConfig | GetListUiByApiNameConfig | GetListUiByListViewIdConfig | GetMruListUiConfig, ListUiRepresentation | ListViewSummaryCollectionRepresentation>;
+export {};

package/sfdc/types/adapters/wire/getLookupRecords/index.d.ts

@@ -0,0 +1,22 @@
+import type { AdapterFactory, Luvio, FulfilledSnapshot, DispatchResourceRequestContext } from '@luvio/engine';
+import type { LookupValuesRepresentation } from '../../generated/types/LookupValuesRepresentation';
+import type { GetLookupRecordsConfig } from '../../generated/adapters/getLookupRecords';
+import type { FieldId } from '../../primitives/FieldId';
+import type { RecordInputRepresentation as types_RecordInputRepresentation_RecordInputRepresentation } from '../../generated/types/RecordInputRepresentation';
+interface GetLookupRecordsConfigRequestParams {
+    q?: string;
+    page?: number;
+    pageSize?: number;
+    dependentFieldBindings?: string[];
+    searchType?: 'Recent' | 'Search' | 'TypeAhead';
+    sourceRecordId?: string;
+    targetApiName?: string;
+    sourceRecord?: types_RecordInputRepresentation_RecordInputRepresentation | null;
+}
+export interface GetLookupRecordsAdapterConfig {
+    fieldApiName: string | FieldId;
+    requestParams?: GetLookupRecordsConfigRequestParams;
+}
+export declare function buildNetworkSnapshot(luvio: Luvio, config: GetLookupRecordsConfig, options?: DispatchResourceRequestContext): Promise<import("@luvio/engine").ErrorSnapshot | FulfilledSnapshot<LookupValuesRepresentation, {}>>;
+export declare const factory: AdapterFactory<GetLookupRecordsConfig, LookupValuesRepresentation>;
+export {};

package/sfdc/types/adapters/wire/getMruListUi/index.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterFactory, Luvio, Snapshot, StoreLookup } from '@luvio/engine';
+import type { GetMruListUiConfig } from '../../generated/adapters/getMruListUi';
+import type { ListInfoRepresentation } from '../../generated/types/ListInfoRepresentation';
+import type { ListUiRepresentation } from '../../generated/types/ListUiRepresentation';
+import type { ListFields } from '../../util/lists';
+export declare function buildCachedSnapshot(luvio: Luvio, storeLookup: StoreLookup<ListUiRepresentation>, config: GetMruListUiConfig, listInfo: ListInfoRepresentation, fields?: ListFields): Snapshot<ListUiRepresentation>;
+export declare const factory: AdapterFactory<GetMruListUiConfig, ListUiRepresentation>;

package/sfdc/types/adapters/wire/getRecord/GetRecordFields.d.ts

@@ -0,0 +1,14 @@
+import type { Luvio, Selector, Snapshot, SnapshotRefresh, FetchResponse, AdapterRequestContext, StoreLookup, DispatchResourceRequestContext, ErrorResponse, NormalizedKeyMetadata } from '@luvio/engine';
+import type { GetRecordConfig } from '../../generated/adapters/getRecord';
+import type { RecordRepresentation } from '../../generated/types/RecordRepresentation';
+export declare function buildRecordSelector(luvio: Luvio, recordId: string, fields: string[], optionalFields: string[]): Selector;
+export declare function ingestSuccess(luvio: Luvio, config: GetRecordConfig, key: string | NormalizedKeyMetadata, allTrackedFields: string[], response: FetchResponse<RecordRepresentation>, serverRequestCount: number): Snapshot<RecordRepresentation, unknown>;
+export declare function ingestError(luvio: Luvio, config: GetRecordConfig, key: string | NormalizedKeyMetadata, err: ErrorResponse): import("@luvio/engine").ErrorSnapshot;
+export declare function buildNetworkSnapshot(luvio: Luvio, config: GetRecordConfig, serverRequestCount?: number, options?: DispatchResourceRequestContext): Promise<import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<RecordRepresentation, unknown> | import("@luvio/engine").UnfulfilledSnapshot<RecordRepresentation, unknown> | import("@luvio/engine").StaleSnapshot<RecordRepresentation, unknown> | import("@luvio/engine").PendingSnapshot<RecordRepresentation, unknown>>;
+export declare function buildCachedSnapshot(luvio: Luvio, config: GetRecordConfig, refresh?: SnapshotRefresh<RecordRepresentation>): Snapshot<RecordRepresentation, unknown>;
+export type BuildSnapshotContext = {
+    config: GetRecordConfig;
+    luvio: Luvio;
+};
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: StoreLookup<RecordRepresentation>): Snapshot<RecordRepresentation>;
+export declare function getRecordByFields(luvio: Luvio, config: GetRecordConfig, requestContext?: AdapterRequestContext): Snapshot<RecordRepresentation> | Promise<Snapshot<RecordRepresentation>>;

package/sfdc/types/adapters/wire/getRecord/GetRecordLayoutType.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterContext, AdapterRequestContext, Luvio, Snapshot } from '@luvio/engine';
+import type { RecordRepresentation } from '../../generated/types/RecordRepresentation';
+import { LayoutMode } from '../../primitives/LayoutMode';
+import type { LayoutType } from '../../primitives/LayoutType';
+export interface GetRecordLayoutTypeConfig {
+    recordId: string;
+    layoutTypes: LayoutType[];
+    modes?: LayoutMode[];
+    optionalFields?: string[];
+}
+/**
+ * W-14696113
+ * Merge fields into optionalFields and return the whole list.
+ * @param {string[]} fields
+ * @param {string[]} [optionalFields]
+ */
+export declare function convertToImplicitFields(fields: string[], optionalFields?: string[]): string[];
+export declare function getRecordLayoutType(luvio: Luvio, config: GetRecordLayoutTypeConfig, adapterContext: AdapterContext, requestContext?: AdapterRequestContext): Snapshot<RecordRepresentation> | Promise<Snapshot<RecordRepresentation>>;

package/sfdc/types/adapters/wire/getRecord/index.d.ts

@@ -0,0 +1,5 @@
+import type { AdapterFactory, Luvio } from '@luvio/engine';
+import type { GetRecordConfig } from '../../generated/adapters/getRecord';
+import type { KeyParams, RecordRepresentation } from '../../generated/types/RecordRepresentation';
+export declare const notifyChangeFactory: (luvio: Luvio) => (configs: KeyParams[]) => void;
+export declare const factory: AdapterFactory<GetRecordConfig, RecordRepresentation>;

package/sfdc/types/adapters/wire/getRecordCreateDefaults/index.d.ts

@@ -0,0 +1,8 @@
+import type { AdapterFactory, Luvio, Selector, Snapshot, AdapterContext, DispatchResourceRequestContext } from '@luvio/engine';
+import type { RecordDefaultsRepresentation } from '../../generated/types/RecordDefaultsRepresentation';
+import type { GetRecordCreateDefaultsConfig } from '../../generated/adapters/getRecordCreateDefaults';
+type GetRecordCreateDefaultsConfigWithDefaults = Required<GetRecordCreateDefaultsConfig>;
+export declare function buildNetworkSnapshot(luvio: Luvio, context: AdapterContext, config: GetRecordCreateDefaultsConfigWithDefaults, options?: DispatchResourceRequestContext): Promise<import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<RecordDefaultsRepresentation, unknown> | import("@luvio/engine").UnfulfilledSnapshot<RecordDefaultsRepresentation, unknown> | import("@luvio/engine").StaleSnapshot<RecordDefaultsRepresentation, unknown> | import("@luvio/engine").PendingSnapshot<RecordDefaultsRepresentation, unknown>>;
+export declare function buildCachedSnapshot(sel: Selector, luvio: Luvio, context: AdapterContext, config: GetRecordCreateDefaultsConfigWithDefaults): Snapshot<RecordDefaultsRepresentation, unknown>;
+export declare const factory: AdapterFactory<GetRecordCreateDefaultsConfig, RecordDefaultsRepresentation>;
+export {};

package/sfdc/types/adapters/wire/getRecordTemplateClone/index.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterFactory } from '@luvio/engine';
+import type { GetRecordTemplateCloneConfig } from '../../generated/adapters/getRecordTemplateClone';
+import type { RecordDefaultsTemplateCloneRepresentation } from '../../generated/types/RecordDefaultsTemplateCloneRepresentation';
+export declare const factory: AdapterFactory<GetRecordTemplateCloneConfig, RecordDefaultsTemplateCloneRepresentation>;

package/sfdc/types/adapters/wire/getRecordTemplateCreate/index.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterFactory } from '@luvio/engine';
+import type { GetRecordTemplateCreateConfig } from '../../generated/adapters/getRecordTemplateCreate';
+import type { RecordDefaultsTemplateCreateRepresentation } from '../../generated/types/RecordDefaultsTemplateCreateRepresentation';
+export declare const factory: AdapterFactory<GetRecordTemplateCreateConfig, RecordDefaultsTemplateCreateRepresentation>;

package/sfdc/types/adapters/wire/getRecordUi/index.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterFactory, DispatchResourceRequestContext, Luvio, Selector, Snapshot, UnfulfilledSnapshot } from '@luvio/engine';
+import type { GetRecordUiConfig } from '../../generated/adapters/getRecordUi';
+import type { RecordUiRepresentation } from '../../generated/types/RecordUiRepresentation';
+import type { LayoutType } from '../../primitives/LayoutType';
+import type { LayoutMode } from '../../primitives/LayoutMode';
+type GetRecordUiConfigWithDefaults = Omit<Required<GetRecordUiConfig>, 'formFactor' | 'childRelationships' | 'pageSize' | 'updateMru'> & {
+    layoutTypes: LayoutType[];
+    modes: LayoutMode[];
+};
+export declare function buildCachedSnapshot(luvio: Luvio, config: GetRecordUiConfigWithDefaults): Snapshot<RecordUiRepresentation> | null | UnfulfilledSnapshot<RecordUiRepresentation | Selector, any>;
+export declare function buildNetworkSnapshot(luvio: Luvio, config: GetRecordUiConfigWithDefaults, dispatchContext?: DispatchResourceRequestContext): Promise<Snapshot<RecordUiRepresentation>>;
+export declare function coerceConfigWithDefaults(untrustedConfig: unknown): GetRecordUiConfigWithDefaults | null;
+export declare const factory: AdapterFactory<GetRecordUiConfig, RecordUiRepresentation>;
+export {};

package/sfdc/types/adapters/wire/getRecordUi/selectors.d.ts

@@ -0,0 +1,10 @@
+import type { Selector } from '@luvio/engine';
+import type { RecordRepresentation } from '../../generated/types/RecordRepresentation';
+export interface RecordDef {
+    recordId: string;
+    recordData: RecordRepresentation;
+    recordTypeId: string;
+}
+export declare function buildRecordUiSelector(recordDefs: RecordDef[], layoutTypes: string[], modes: string[], recordOptionalFields: {
+    [key: string]: string[];
+}): Selector<any>['node'];

package/sfdc/types/adapters/wire/getRecords/GetRecordsFields.d.ts

@@ -0,0 +1,4 @@
+import type { Luvio, Snapshot, DispatchResourceRequestContext } from '@luvio/engine';
+import type { GetRecordsConfig } from '../../raml-artifacts/adapters/getRecords/GetRecordsConfig';
+import type { BatchRepresentation } from '../../generated/types/BatchRepresentation';
+export declare function buildNetworkSnapshot(luvio: Luvio, config: GetRecordsConfig, serverRequestCount?: number, options?: DispatchResourceRequestContext): Promise<Snapshot<BatchRepresentation, any>>;

package/sfdc/types/adapters/wire/getRelatedListRecordsBatch/createChildResourceParams.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceRequestConfig as compositeWireResourceRequestConfig } from '../../generated/resources/postUiApiRelatedListRecordsBatchByParentRecordId';
+import type { ResourceRequestConfig as singleWireResourceRequestConfig } from '../../generated/resources/postUiApiRelatedListRecordsByParentRecordIdAndRelatedListId';
+declare function createChildResourceParams(resourceParams: compositeWireResourceRequestConfig): singleWireResourceRequestConfig[];
+export default createChildResourceParams;

package/sfdc/types/adapters/wire/graphqlBatch/index.d.ts

@@ -0,0 +1,26 @@
+import type { AdapterValidationConfig, Untrusted as Untrusted } from '../../generated/adapters/adapter-utils';
+import type { Luvio, Fragment, Snapshot, FetchResponse, ErrorResponse, DispatchResourceRequestContext, CoercedAdapterRequestContext, StoreLookup, AdapterFactory } from '@luvio/engine';
+import type { ResourceRequestConfig, GraphQLBatchRepresentation } from './postGraphqlBatch';
+import type { GraphqlConfig } from '../../generated/adapters/graphql';
+export interface GraphqlBatchConfig {
+    batchQuery: Array<GraphqlConfig>;
+}
+export declare function createResourceParams(config: GraphqlBatchConfig): ResourceRequestConfig;
+export declare function transformConfiguration(config: GraphqlBatchConfig): GraphqlBatchConfig;
+export declare function typeCheckConfig(untrustedConfig: Untrusted<GraphqlBatchConfig>): Untrusted<GraphqlBatchConfig>;
+export declare const factory: AdapterFactory<GraphqlBatchConfig, GraphQLBatchRepresentation>;
+export declare const adapterName = "graphqlBatch";
+export declare const graphqlBatch_ConfigPropertyNames: AdapterValidationConfig;
+export declare function keyBuilder(luvio: Luvio, config: GraphqlBatchConfig): string;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: AdapterValidationConfig): GraphqlBatchConfig | null;
+export declare function adapterFragment(luvio: Luvio, config: GraphqlBatchConfig): Fragment;
+export declare function buildCachedSnapshot(luvio: Luvio, config: GraphqlBatchConfig): Snapshot<GraphQLBatchRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: Luvio, config: GraphqlBatchConfig, resourceParams: ResourceRequestConfig, response: FetchResponse<GraphQLBatchRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<GraphQLBatchRepresentation, any> | import("@luvio/engine").StaleSnapshot<GraphQLBatchRepresentation, any> | import("@luvio/engine").PendingSnapshot<GraphQLBatchRepresentation, any>>;
+export declare function onFetchResponseError(luvio: Luvio, config: GraphqlBatchConfig, resourceParams: ResourceRequestConfig, response: ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: Luvio, config: GraphqlBatchConfig, options?: DispatchResourceRequestContext): Promise<Snapshot<GraphQLBatchRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: Luvio;
+    config: GraphqlBatchConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: CoercedAdapterRequestContext): Promise<Snapshot<GraphQLBatchRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: StoreLookup<GraphQLBatchRepresentation>): Snapshot<GraphQLBatchRepresentation, any>;

package/sfdc/types/adapters/wire/graphqlBatch/postGraphqlBatch.d.ts

@@ -0,0 +1,43 @@
+import type { FetchResponse as $64$luvio_engine_FetchResponse, Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest, NormalizedKeyMetadata, HttpStatusCode } from '@luvio/engine';
+import { StoreKeySet } from '@luvio/engine';
+import type { ResourceRequestConfig as postGraphql_ResourceRequestConfig } from '../../generated/resources/postGraphql';
+import type { GraphQLRepresentation } from '../../generated/types/GraphQLRepresentation';
+import type { GraphqlConfig } from '../../generated/adapters/graphql';
+export interface ResourceRequestConfig {
+    body: {
+        batchQuery: Array<GraphqlConfig>;
+    };
+}
+interface NormalizedGraphQLRequest {
+    query: String;
+    variables?: any;
+    operationName?: string;
+}
+interface NormalizedResourceRequestConfig {
+    body: {
+        batchQuery: Array<NormalizedGraphQLRequest>;
+    };
+}
+export type GraphQLBatchRepresentation = {
+    results: Array<GraphQLCompositeResult>;
+};
+type GraphQLCompositeResult = {
+    statusCode: HttpStatusCode;
+    result: GraphQLRepresentation;
+};
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export declare function stripDocumentsOfMetaschema(config: ResourceRequestConfig): NormalizedResourceRequestConfig;
+export declare function createChildResourceParams(resourceParams: ResourceRequestConfig): postGraphql_ResourceRequestConfig[];
+export declare function selectChildResourceParams(luvio: $64$luvio_engine_Luvio, childResources: postGraphql_ResourceRequestConfig[], resourceParams: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function select(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(keys: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: GraphQLBatchRepresentation): void;
+export declare function ingestSuccessChildResourceParams(luvio: $64$luvio_engine_Luvio, childConfigs: GraphqlConfig[], childResourceParamsArray: postGraphql_ResourceRequestConfig[], childEnvelopes: Array<any>): {
+    childSnapshotData: GraphQLBatchRepresentation;
+    seenRecords: StoreKeySet<string | NormalizedKeyMetadata>;
+    snapshotState: string;
+};
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<GraphQLBatchRepresentation>, snapshotRefresh: $64$luvio_engine_SnapshotRefresh<GraphQLBatchRepresentation>): $64$luvio_engine_FulfilledSnapshot<GraphQLBatchRepresentation, any> | $64$luvio_engine_StaleSnapshot<GraphQLBatchRepresentation, any> | $64$luvio_engine_PendingSnapshot<GraphQLBatchRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<GraphQLBatchRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export default createResourceRequest;