@salesforce/lds-adapters-uiapi 1.100.2

package/dist/types/src/raml-artifacts/adapters/getRecordAvatars/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Fragment, Luvio, NormalizedKeyMetadata, Selector } from '@luvio/engine';
+import type { GetRecordAvatarsConfig as BaseGetRecordAvatarsConfig } from '../../../generated/adapters/getRecordAvatars';
+export declare const KEY: string;
+export interface GetRecordAvatarsConfig extends BaseGetRecordAvatarsConfig {
+    uncachedRecordIds?: Array<string | NormalizedKeyMetadata>;
+}
+export type BuildSnapshotContext = {
+    luvio: Luvio;
+    config: GetRecordAvatarsConfig;
+    uncachedRecordIds?: (string | NormalizedKeyMetadata)[];
+};
+export declare function recordAvatarsFragment(recordIds: string[]): Fragment;
+export declare function recordAvatarsSelector(recordIds: string[]): Selector;

package/dist/types/src/raml-artifacts/adapters/getRecords/GetRecordsConfig.d.ts

@@ -0,0 +1,15 @@
+export type GetRecordsEntityConfiguration = {
+    recordIds: string[];
+} & ({
+    fields: string[];
+    optionalFields: string[];
+} | {
+    fields?: void;
+    optionalFields: string[];
+} | {
+    fields: string[];
+    optionalFields?: void;
+});
+export interface GetRecordsConfig {
+    records: GetRecordsEntityConfiguration[];
+}

package/dist/types/src/raml-artifacts/adapters/getRecords/adapterFragment.d.ts

@@ -0,0 +1,3 @@
+import type { Fragment, Luvio } from '@luvio/engine';
+import type { GetRecordsConfig } from './GetRecordsConfig';
+export declare function adapterFragment(luvio: Luvio, config: GetRecordsConfig): Fragment;

package/dist/types/src/raml-artifacts/adapters/getRecords/createChildResourceParams.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceRequestConfig } from '../../../generated/resources/getUiApiRecordsByRecordId';
+import type { GetRecordsConfig } from './GetRecordsConfig';
+export declare function createChildResourceParams(config: GetRecordsConfig): ResourceRequestConfig[];

package/dist/types/src/raml-artifacts/adapters/getRecords/createResourceParams.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceRequestConfig } from '../../../generated/resources/getUiApiRecordsBatchByRecordIds';
+import type { GetRecordsConfig } from './GetRecordsConfig';
+export declare function createResourceParams(config: GetRecordsConfig): ResourceRequestConfig;

package/dist/types/src/raml-artifacts/adapters/getRecords/getRecords_ConfigPropertyNames.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterValidationConfig } from '../../../generated/adapters/adapter-utils';
+export declare const getRecords_ConfigPropertyNames: AdapterValidationConfig;

package/dist/types/src/raml-artifacts/adapters/getRecords/onFetchResponseSuccess.d.ts

@@ -0,0 +1,5 @@
+import type { FulfilledSnapshot, Luvio, FetchResponse } from '@luvio/engine';
+import type { ResourceRequestConfig } from '../../../generated/resources/getUiApiRecordsBatchByRecordIds';
+import type { BatchRepresentation } from '../../../generated/types/BatchRepresentation';
+import type { GetRecordsConfig } from './GetRecordsConfig';
+export declare function onFetchResponseSuccess(luvio: Luvio, config: GetRecordsConfig, resourceParams: ResourceRequestConfig, response: FetchResponse<BatchRepresentation>, serverRequestCount?: number): Promise<FulfilledSnapshot<BatchRepresentation, any>>;

package/dist/types/src/raml-artifacts/adapters/getRecords/typeCheckConfig.d.ts

@@ -0,0 +1,5 @@
+import type { UncoercedConfiguration, Untrusted } from '../../../generated/adapters/adapter-utils';
+import type { GetRecordsConfig } from './GetRecordsConfig';
+export declare function coerceRecordId18Array(value: unknown): Array<string> | undefined;
+export declare function coerceConfig(config: UncoercedConfiguration<GetRecordsConfig, any>): Untrusted<GetRecordsConfig>;
+export declare function typeCheckConfig(untrustedConfig: Untrusted<GetRecordsConfig>): Untrusted<GetRecordsConfig>;

package/dist/types/src/raml-artifacts/adapters/getRecords/validateAdapterConfig.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterValidationConfig } from '../../../generated/adapters/adapter-utils';
+import type { GetRecordsConfig, GetRecordsEntityConfiguration } from './GetRecordsConfig';
+export declare function checkFieldsObjectApiName(fields: string[], apiName: string): boolean;
+export declare function getObjectApiName(fields: GetRecordsEntityConfiguration['fields'], optionalFields: GetRecordsEntityConfiguration['optionalFields']): string;
+export declare function validateFieldsObjectApiName(config: GetRecordsConfig): void;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: AdapterValidationConfig): GetRecordsConfig | null;

package/dist/types/src/raml-artifacts/getPicklistValues/index.d.ts

@@ -0,0 +1,17 @@
+import type { Luvio, Snapshot, StoreLookup, CoercedAdapterRequestContext, DispatchResourceRequestContext } from '@luvio/engine';
+import type { AdapterValidationConfig } from '../../generated/adapters/adapter-utils';
+import type { PicklistValuesRepresentation } from '../../generated/types/PicklistValuesRepresentation';
+export interface GetPicklistValuesConfig {
+    recordTypeId: string;
+    fieldApiName: string;
+}
+export declare function buildNetworkSnapshot(luvio: Luvio, config: GetPicklistValuesConfig, options?: DispatchResourceRequestContext): Promise<Snapshot<PicklistValuesRepresentation>>;
+export declare function buildCachedSnapshot(luvio: Luvio, config: GetPicklistValuesConfig): Snapshot<PicklistValuesRepresentation, unknown>;
+type BuildSnapshotContext = {
+    config: GetPicklistValuesConfig;
+    luvio: Luvio;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: CoercedAdapterRequestContext): Promise<Snapshot<PicklistValuesRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: StoreLookup<PicklistValuesRepresentation>): Snapshot<PicklistValuesRepresentation, any>;
+export declare function validateAdapterConfig(untrusted: unknown, _config: AdapterValidationConfig): import("../../generated/adapters/getPicklistValues").GetPicklistValuesConfig | null;
+export {};

package/dist/types/src/raml-artifacts/resources/getUiApiRecordAvatarsBatchByRecordIds/ingestSuccess.d.ts

@@ -0,0 +1,12 @@
+import type { FulfilledSnapshot, Luvio, PendingSnapshot, FetchResponse, SnapshotRefresh, StaleSnapshot } from '@luvio/engine';
+import type { RecordAvatarBulkMapRepresentation } from '../../../generated/types/RecordAvatarBulkMapRepresentation';
+interface ResourceRequestConfig {
+    urlParams: {
+        recordIds: Array<string>;
+    };
+    queryParams: {
+        formFactor?: string;
+    };
+}
+export declare function ingestSuccess(luvio: Luvio, resourceParams: ResourceRequestConfig, response: FetchResponse<RecordAvatarBulkMapRepresentation>, snapshotRefresh?: SnapshotRefresh<RecordAvatarBulkMapRepresentation>): Promise<FulfilledSnapshot<RecordAvatarBulkMapRepresentation, {}> | StaleSnapshot<RecordAvatarBulkMapRepresentation, {}> | PendingSnapshot<RecordAvatarBulkMapRepresentation, any>>;
+export {};

package/dist/types/src/raml-artifacts/resources/getUiApiRecordDefaultsTemplateCloneByRecordId/select.d.ts

@@ -0,0 +1,2 @@
+import type { select as generatedSelect } from '../../../generated/resources/getUiApiRecordDefaultsTemplateCloneByRecordId';
+export declare const select: typeof generatedSelect;

package/dist/types/src/raml-artifacts/resources/getUiApiRecordsBatchByRecordIds/ingestSuccessChildResourceParams.d.ts

@@ -0,0 +1,17 @@
+import type { Luvio, NormalizedKeyMetadata } from '@luvio/engine';
+import { StoreKeySet } from '@luvio/engine';
+import type { ResourceRequestConfig as getUiApiRecordsByRecordId_ResourceRequestConfig } from '../../../generated/resources/getUiApiRecordsByRecordId';
+import type { BatchRepresentation } from '../../../generated/types/BatchRepresentation';
+import type { BatchResultRepresentation } from '../../../generated/types/BatchResultRepresentation';
+export declare const nonCachedErrors: {
+    [key: string]: {
+        expiration: number;
+        response: any;
+        status: number;
+    } | undefined;
+};
+export declare function ingestSuccessChildResourceParams(luvio: Luvio, childResourceParamsArray: getUiApiRecordsByRecordId_ResourceRequestConfig[], childEnvelopes: BatchResultRepresentation[], serverRequestCount?: number): {
+    childSnapshotData: BatchRepresentation;
+    seenRecords: StoreKeySet<string | NormalizedKeyMetadata>;
+    snapshotState: string;
+};

package/dist/types/src/raml-artifacts/resources/getUiApiRecordsBatchByRecordIds/selectChildResourceParams.d.ts

@@ -0,0 +1,4 @@
+import type { Fragment, Luvio } from '@luvio/engine';
+import type { ResourceRequestConfig as getUiApiRecordsByRecordId_ResourceRequestConfig } from '../../../generated/resources/getUiApiRecordsByRecordId';
+import type { ResourceRequestConfig as getUiApiRecordsBatchByRecordIds_ResourceRequestConfig } from '../../../generated/resources/getUiApiRecordsBatchByRecordIds';
+export declare function selectChildResourceParams(luvio: Luvio, childResources: getUiApiRecordsByRecordId_ResourceRequestConfig[], resourceParams: getUiApiRecordsBatchByRecordIds_ResourceRequestConfig): Fragment;

package/dist/types/src/raml-artifacts/resources/getUiApiRecordsByRecordId/createResourceRequest.d.ts

@@ -0,0 +1,2 @@
+import { createResourceRequest as generatedCreateResourceRequest } from '../../../generated/resources/getUiApiRecordsByRecordId';
+export declare const createResourceRequest: typeof generatedCreateResourceRequest;

package/dist/types/src/raml-artifacts/resources/getUiApiRelatedListInfoBatchByParentObjectApiNameAndRelatedListNames/createChildResourceParams.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceRequestConfig as Batch_ResourceRequestConfig } from '../../../generated/resources/getUiApiRelatedListInfoBatchByParentObjectApiNameAndRelatedListNames';
+import type { ResourceRequestConfig as Single_ResourceRequestConfig } from '../../../generated/resources/getUiApiRelatedListInfoByParentObjectApiNameAndRelatedListId';
+export declare function createChildResourceParams(resourceParams: Batch_ResourceRequestConfig): Single_ResourceRequestConfig[];

package/dist/types/src/raml-artifacts/resources/postGraphql/createResourceRequest.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentNode } from '@luvio/graphql-parser';
+import type { ResourceRequest } from '@luvio/engine';
+import type { ResourceRequestConfig } from '../../../generated/resources/postGraphql';
+export declare function stripDocumentOfMetaschema(documentNode: DocumentNode): DocumentNode;
+export declare function createResourceRequest(config: ResourceRequestConfig): ResourceRequest;

package/dist/types/src/raml-artifacts/types/FieldValueRepresentation/ingest.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceIngest } from '@luvio/engine';
+import type { RecordConflictMap } from '../../../helpers/RecordRepresentation/resolveConflict';
+import type { RecordFieldTrie } from '../../../util/records';
+export declare function makeIngest(fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap): ResourceIngest;

package/dist/types/src/raml-artifacts/types/QuickActionDefaultsRepresentation/dynamicIngest.d.ts

@@ -0,0 +1,2 @@
+import type { dynamicIngest as generatedDynamicIngest } from '../../../generated/types/QuickActionDefaultsRepresentation';
+export declare const dynamicIngest: typeof generatedDynamicIngest;

package/dist/types/src/raml-artifacts/types/RecordAvatarBulkMapRepresentation/ingest.d.ts

@@ -0,0 +1,2 @@
+import type { ingest as generatedIngest } from '../../../generated/types/RecordAvatarBulkMapRepresentation';
+export declare const ingest: typeof generatedIngest;

package/dist/types/src/raml-artifacts/types/RecordRepresentation/getTypeCacheKeys.d.ts

@@ -0,0 +1,2 @@
+import type { getTypeCacheKeys as generatedGetTypeCacheKeys } from '../../../generated/types/RecordRepresentation';
+export declare const getTypeCacheKeys: typeof generatedGetTypeCacheKeys;

package/dist/types/src/raml-artifacts/types/RecordRepresentation/ingest.d.ts

@@ -0,0 +1,4 @@
+import type { ingest as generatedIngest } from '../../../generated/types/RecordRepresentation';
+import type { RecordFieldTrie } from '../../../util/records';
+export declare const createIngestRecordWithFields: (fields: RecordFieldTrie, optionalFields: RecordFieldTrie) => typeof generatedIngest;
+export declare const ingest: typeof generatedIngest;

package/dist/types/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.d.ts

@@ -0,0 +1,2 @@
+import { keyBuilderFromType as generatedKeyBuilderFromType } from '../../../generated/types/RecordRepresentation';
+export declare const keyBuilderFromType: typeof generatedKeyBuilderFromType;

package/dist/types/src/selectors/record.d.ts

@@ -0,0 +1,15 @@
+import type { PathSelection } from '@luvio/engine';
+import type { RecordFieldTrie } from '../util/records';
+import type { RecordRepresentation } from '../generated/types/RecordRepresentation';
+import type { FieldMapRepresentation } from '../util/fields';
+export declare function isSpanningRecord(fieldValue: null | string | number | boolean | RecordRepresentation): fieldValue is RecordRepresentation;
+export declare function createRecordSelection(fieldDefinition: RecordFieldTrie): PathSelection[];
+/**
+ * Convert a list of fields and optional fields into RecordRepresentation its equivalent
+ * selection.
+ */
+export declare function buildSelectionFromFields(fields: string[], optionalFields?: string[]): PathSelection[];
+/**
+ * Convert a RecordRepresentationLike into its equivalent selection.
+ */
+export declare function buildSelectionFromRecord(record: FieldMapRepresentation): PathSelection[];

package/dist/types/src/sfdc-util/throttle.d.ts

@@ -0,0 +1,15 @@
+interface ThrottleOptions {
+    allowFunction: Function;
+    dropFunction: Function;
+}
+/**
+ * Limit the frequency and the duration that a function is invoked.
+ *
+ * @param invokeLimit The frequency a function could be invoked.
+ * @param timeLimit The duration a function could be invoked with the rate limit, in milliseconds.
+ * @param fn The function to be invoked.
+ * @param options Extra options for instrumentation, logging, or bookkeeping purposes.
+ * @returns The wrapped rate limited function.
+ */
+export declare function throttle<T extends any[], R extends any>(invokeLimit: number, timeLimit: number, fn: (...args: T) => R, options?: ThrottleOptions): (...args: T) => R | void;
+export {};

package/dist/types/src/sfdc_graphql.d.ts

@@ -0,0 +1,13 @@
+export * from './generated/artifacts/sfdc_graphqlAdapters';
+import { configurationForGraphQLAdapters } from './configuration';
+import type { ConfigurationForGraphQLAdapters } from './configuration';
+import type { Instrument } from './instrumentation';
+import { refresh } from '@salesforce/lds-bindings';
+export type Registration = {
+    id: '@salesforce/lds-adapters-uiapi/graphql';
+    configuration: ConfigurationForGraphQLAdapters;
+    instrument: Instrument;
+};
+export { ConfigurationForGraphQLAdapters as Configuration, configurationForGraphQLAdapters as configuration, };
+export { refresh as refreshGraphQL };
+export { graphqlAdapterFactory } from './main';

package/dist/types/src/sfdc_rest.d.ts

@@ -0,0 +1,20 @@
+import { updateRelatedListInfoAdapterFactory, updateRelatedListPreferencesAdapterFactory } from './main';
+export { MRU } from './wire/getListUi';
+export * from './generated/artifacts/sfdc_restAdapters';
+export declare const refresh: <D>(data: D) => Promise<undefined> | undefined;
+export declare const updateLayoutUserState: (apiName: unknown, recordTypeId: unknown, layoutType: unknown, mode: unknown, layoutUserStateInput: unknown) => Promise<undefined>;
+export declare const updateRelatedListInfo: (config: Parameters<ReturnType<typeof updateRelatedListInfoAdapterFactory>>[0]) => Promise<import("./generated/types/RelatedListInfoRepresentation").RelatedListInfoRepresentation | undefined> | undefined;
+export declare const updateRelatedListPreferences: (config: Parameters<ReturnType<typeof updateRelatedListPreferencesAdapterFactory>>[0]) => Promise<import("./generated/types/RelatedListUserPreferencesRepresentation").RelatedListUserPreferencesRepresentation | undefined> | undefined;
+/** SFDC utils */
+export declare let getRecordNotifyChange: any;
+export declare let notifyRecordUpdateAvailable: any;
+export { createRecordInputFilteredByEditedFields, generateRecordInputForCreate, generateRecordInputForUpdate, getFieldDisplayValue, getFieldValue, getRecordInput, } from './uiapi-static-functions';
+export { keyBuilder as keyBuilderRecord } from './generated/types/RecordRepresentation';
+export { ingest as ingestRecord, createIngestRecordWithFields, } from './raml-artifacts/types/RecordRepresentation/ingest';
+export { keyBuilder as keyBuilderObjectInfo, ingest as ingestObjectInfo, } from './generated/types/ObjectInfoRepresentation';
+export { keyBuilder as keyBuilderQuickActionExecutionRepresentation, ingest as ingestQuickActionExecutionRepresentation, } from './generated/types/QuickActionExecutionRepresentation';
+export { ConfigurationForRestAdapters as Configuration, configurationForRestAdapters as configuration, } from './configuration';
+export { instrument, Instrument, Registration } from './main';
+export { CachePolicy, CachePolicyCacheAndNetwork, CachePolicyCacheThenNetwork, CachePolicyNoCache, CachePolicyOnlyIfCached, CachePolicyStaleWhileRevalidate, CachePolicyValidAt, } from './main';
+export { getRecordId18, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getTypeCacheKeysRecord, RecordRepresentationVersion, RecordRepresentationTTL, RecordRepresentationType, ObjectInfoRepresentationType, RecordRepresentationRepresentationType, keyBuilderFromTypeRecordRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, keyBuilderContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, } from './main';
+export { UiApiNamespace, InMemoryRecordRepresentationQueryEvaluator } from './main';

package/dist/types/src/uiapi-static-functions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Record Util Pure Functions
+ * These functions are in their own module
+ * because we need compat transform to apply
+ * to these functions
+ */
+export { createRecordInputFilteredByEditedFields, generateRecordInputForCreate, generateRecordInputForUpdate, getFieldDisplayValue, getRecordInput, getFieldValue, } from './util/records';

package/dist/types/src/util/cache-policy.d.ts

@@ -0,0 +1,10 @@
+import type { BuildNetworkSnapshot, Luvio } from '@luvio/engine';
+/**
+ * Returns a BuildNetworkSnapshot function that always returns a Promise<ErrorSnapshot>.
+ *
+ * @param luvio Luvio instance
+ * @param status status code for ErrorSnapshot, defaults to 400
+ * @param statusText status text for ErrorSnapshot, defaults to 'data is not fetchable'
+ * @returns BuildNetworkSnapshot that always returns Promise<ErrorSnapshot>
+ */
+export declare function buildNotFetchableNetworkSnapshot<C, D>(luvio: Luvio, status?: number, statusText?: string): BuildNetworkSnapshot<C, D>;

package/dist/types/src/util/deep-freeze.d.ts

@@ -0,0 +1,3 @@
+export declare function deepFreeze<U extends {
+    [key: string]: any;
+}>(value: U): void;

package/dist/types/src/util/fields.d.ts

@@ -0,0 +1,31 @@
+import type { PathSelection, StoreLink } from '@luvio/engine';
+import type { FieldValueRepresentation } from '../generated/types/FieldValueRepresentation';
+import type { RecordFieldTrie } from '../util/records';
+export type FieldMapRepresentationNormalized = {
+    apiName: string;
+    fields: {
+        [key: string]: StoreLink;
+    };
+};
+export type FieldMapRepresentation = {
+    apiName: string;
+    fields: {
+        [key: string]: FieldValueRepresentation;
+    };
+};
+export declare const MAX_RECORD_DEPTH = 5;
+export declare function convertRecordFieldsArrayToTrie(fields: string[], optionalFields?: string[]): RecordFieldTrie;
+export declare function createPathSelection(propertyName: string, fieldDefinition: RecordFieldTrie): PathSelection;
+/**
+ * Convert a RecordRepresentationLike into its equivalent selection.
+ */
+export declare function createPathSelectionFromValue(fields: FieldMapRepresentation['fields']): PathSelection;
+/**
+ * Returns a list of fields for a RecordRepresentationLike.
+ *
+ * TODO [W-6900271]: Remove this function once getRelatedList don't depend on it anymore. Always prefer
+ * generating a selection out of a record, than convert a record to a field list and back to a
+ * selection.
+ */
+export declare function extractFields(value: FieldMapRepresentation): string[];
+export declare function insertFieldsIntoTrie(root: RecordFieldTrie, fields: string[], optional?: boolean): void;

package/dist/types/src/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>;
+}, 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, 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/dist/types/src/util/layout.d.ts

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

package/dist/types/src/util/layouts.d.ts

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

package/dist/types/src/util/lists.d.ts

@@ -0,0 +1,69 @@
+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 { ListUiRepresentation } from '../generated/types/ListUiRepresentation';
+import type { RecordRepresentation } from '../generated/types/RecordRepresentation';
+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;
+/**
+ * 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, serverResponse: ListUiRepresentation, 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>;

package/dist/types/src/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/dist/types/src/util/promise.d.ts

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

package/dist/types/src/util/record-ingest.d.ts

@@ -0,0 +1,5 @@
+import type { ResourceIngest } from '@luvio/engine';
+import type { RecordFieldTrie } from './records';
+import type { RecordConflictMap } from '../helpers/RecordRepresentation/resolveConflict';
+export declare function createFieldsIngestion(fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap): ResourceIngest;
+export declare const createRecordIngest: (fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap) => ResourceIngest;

package/dist/types/src/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/dist/types/src/util/records.d.ts

@@ -0,0 +1,117 @@
+import type { ProxyGraphNode, GraphNode, Luvio, NormalizedKeyMetadata } 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';
+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 FieldValueRepresentationLinkState {
+    fields: string[];
+}
+export interface RecordLayoutFragment {
+    apiName: RecordRepresentation['apiName'];
+    recordTypeId: RecordRepresentation['recordTypeId'];
+}
+/**
+ * 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 extractTrackedFields(node: ProxyGraphNode<RecordRepresentationNormalized, RecordRepresentation>, parentFieldName: string, fieldsList?: string[], visitedRecordIds?: Record<string, boolean>, depth?: number): string[];
+export declare function extractTrackedFieldsToTrie(recordId: string | NormalizedKeyMetadata, node: ProxyGraphNode<FieldMapRepresentationNormalized, FieldMapRepresentation>, root: RecordFieldTrie, config: TrackedFieldsConfig, visitedRecordIds?: Record<string, boolean>, depth?: number): 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 {};

package/dist/types/src/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/dist/types/src/util/supported-entities.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A set of the string names of known ui-api supported entities.
+ *
+ * Generated
+ *     from: //app/main/core/ui-services-private/java/resources/module-config/ui-services-private-object-allow-list.yaml#113 (changelist 38739779)
+ *     API version: 57
+ *     at: Thu, 08 Dec 2022 21:09:56 GMT
+ */
+export declare const UIAPI_SUPPORTED_ENTITY_API_NAMES: {
+    [key: string]: true;
+};