@salesforce/lds-runtime-mobile 0.1.0-dev1

package/dist/types/adapters/types/SearchFilterOutputRepresentation.d.ts

@@ -0,0 +1,34 @@
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ad91d41fef86d335ecd5766a23c8634d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchFilterOutputRepresentation, _existing: SearchFilterOutputRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): SearchFilterOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchFilterOutputRepresentationNormalized, incoming: SearchFilterOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchFilterOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Search filter output response.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchFilterOutputRepresentationNormalized {
+    /** Field path where we should apply the filter */
+    fieldPath: string;
+    /** Operator for the filter */
+    operator: string;
+    /** Values applied for the filter */
+    values: Array<string>;
+}
+/**
+ * Search filter output response.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchFilterOutputRepresentation {
+    fieldPath: string;
+    operator: string;
+    values: Array<string>;
+}

package/dist/types/adapters/types/SearchObjectOptionsOutputRepresentation.d.ts

@@ -0,0 +1,33 @@
+import type { SearchDataCategoryOutputRepresentation as SearchDataCategoryOutputRepresentation_SearchDataCategoryOutputRepresentation } from './SearchDataCategoryOutputRepresentation';
+import type { SearchFilterOutputRepresentation as SearchFilterOutputRepresentation_SearchFilterOutputRepresentation } from './SearchFilterOutputRepresentation';
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "de195c61e2bd28d1656f4f9603ce6d27";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchObjectOptionsOutputRepresentation, _existing: SearchObjectOptionsOutputRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): SearchObjectOptionsOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchObjectOptionsOutputRepresentationNormalized, incoming: SearchObjectOptionsOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchObjectOptionsOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * search object options like filters and data categories
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchObjectOptionsOutputRepresentationNormalized {
+    /** List of Data categories applied */
+    dataCategories: Array<SearchDataCategoryOutputRepresentation_SearchDataCategoryOutputRepresentation>;
+    /** List of filters applied */
+    filters: Array<SearchFilterOutputRepresentation_SearchFilterOutputRepresentation>;
+}
+/**
+ * search object options like filters and data categories
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchObjectOptionsOutputRepresentation {
+    dataCategories: Array<SearchDataCategoryOutputRepresentation_SearchDataCategoryOutputRepresentation>;
+    filters: Array<SearchFilterOutputRepresentation_SearchFilterOutputRepresentation>;
+}

package/dist/types/adapters/types/SearchObjectOptionsRepresentation.d.ts

@@ -0,0 +1,33 @@
+import type { SearchDataCategoryInputRepresentation as SearchDataCategoryInputRepresentation_SearchDataCategoryInputRepresentation } from './SearchDataCategoryInputRepresentation';
+import type { SearchFilterInputRepresentation as SearchFilterInputRepresentation_SearchFilterInputRepresentation } from './SearchFilterInputRepresentation';
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "779d7cafc5ae45253068affa652ed120";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchObjectOptionsRepresentation, _existing: SearchObjectOptionsRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): SearchObjectOptionsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchObjectOptionsRepresentationNormalized, incoming: SearchObjectOptionsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchObjectOptionsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input parameters for search object options
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchObjectOptionsRepresentationNormalized {
+    /** Data Categories to apply on our results */
+    dataCategories: Array<SearchDataCategoryInputRepresentation_SearchDataCategoryInputRepresentation>;
+    /** Filters to apply on our results */
+    filters: Array<SearchFilterInputRepresentation_SearchFilterInputRepresentation>;
+}
+/**
+ * Input parameters for search object options
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchObjectOptionsRepresentation {
+    dataCategories: Array<SearchDataCategoryInputRepresentation_SearchDataCategoryInputRepresentation>;
+    filters: Array<SearchFilterInputRepresentation_SearchFilterInputRepresentation>;
+}

package/dist/types/adapters/types/SearchRecordHighlightRepresentation.d.ts

@@ -0,0 +1,35 @@
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "6b569c4f017c79193b8498dc140d37ae";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchRecordHighlightRepresentation, _existing: SearchRecordHighlightRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): SearchRecordHighlightRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchRecordHighlightRepresentationNormalized, incoming: SearchRecordHighlightRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchRecordHighlightRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Record-level search information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchRecordHighlightRepresentationNormalized {
+    /** Map of fields with the highlighting */
+    fields: {
+        [key: string]: string;
+    };
+    /** Message to represent the record where we highlight some terms */
+    snippet: string | null;
+}
+/**
+ * Record-level search information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchRecordHighlightRepresentation {
+    fields: {
+        [key: string]: string;
+    };
+    snippet: string | null;
+}

package/dist/types/adapters/types/SearchRecordInfoRepresentation.d.ts

@@ -0,0 +1,31 @@
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "cb1cfeddedbb84c1b38aeb5d3548a79b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchRecordInfoRepresentation, _existing: SearchRecordInfoRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): SearchRecordInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchRecordInfoRepresentationNormalized, incoming: SearchRecordInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchRecordInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Record-level search information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchRecordInfoRepresentationNormalized {
+    /** Is the record promoted? */
+    isPromoted: boolean | null;
+    /** Did we find the record by applying the spell correction? */
+    isSpellCorrected: boolean;
+}
+/**
+ * Record-level search information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchRecordInfoRepresentation {
+    isPromoted: boolean | null;
+    isSpellCorrected: boolean;
+}

package/dist/types/adapters/types/SearchResultCollectionRepresentation.d.ts

@@ -0,0 +1,64 @@
+import type { ErrorMessageRepresentation as ErrorMessageRepresentation_ErrorMessageRepresentation } from './ErrorMessageRepresentation';
+import type { ListOrderByInfoRepresentation as ListOrderByInfoRepresentation_ListOrderByInfoRepresentation } from './ListOrderByInfoRepresentation';
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import type { SearchResultRepresentation as SearchResultRepresentation_SearchResultRepresentation } from './SearchResultRepresentation';
+export declare const VERSION = "f22cddc44a1446bc43aa8f8d15476599";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchResultCollectionRepresentation, existing: SearchResultCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SearchResultCollectionRepresentationNormalized;
+export interface DynamicIngestParams {
+    records: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: SearchResultCollectionRepresentation, existing: SearchResultCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => SearchResultCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    records?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchResultCollectionRepresentationNormalized, incoming: SearchResultCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchResultCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Search results for one object
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchResultCollectionRepresentationNormalized {
+    /** The token of the current page of records. */
+    currentPageToken: string;
+    /** Error description if we were not able to load the records on the object */
+    error: ErrorMessageRepresentation_ErrorMessageRepresentation | null;
+    /** The token of the next page of records. */
+    nextPageToken: string | null;
+    /** Object API name. */
+    objectApiName: string;
+    /** The sortBy field requested when these records were fetched. */
+    orderBy: Array<ListOrderByInfoRepresentation_ListOrderByInfoRepresentation>;
+    /** The pageSize given in the query parameter.  If no pageSize is provided, this contains the default value used. */
+    pageSize: number;
+    /** The token of the previous page of records. */
+    previousPageToken: string | null;
+    /** List of records with search metadata */
+    records: Array<$64$luvio_engine_StoreLink>;
+    /** Which objects are associated to the current object based on the Search layout. (e.g. Contacts with Contact.Account.Name) */
+    relatedObjectApiNames: Array<string>;
+}
+/**
+ * Search results for one object
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchResultCollectionRepresentation {
+    currentPageToken: string;
+    error: ErrorMessageRepresentation_ErrorMessageRepresentation | null;
+    nextPageToken: string | null;
+    objectApiName: string;
+    orderBy: Array<ListOrderByInfoRepresentation_ListOrderByInfoRepresentation>;
+    pageSize: number;
+    previousPageToken: string | null;
+    records: Array<SearchResultRepresentation_SearchResultRepresentation>;
+    relatedObjectApiNames: Array<string>;
+}

package/dist/types/adapters/types/SearchResultRepresentation.d.ts

@@ -0,0 +1,46 @@
+import type { SearchRecordHighlightRepresentation as SearchRecordHighlightRepresentation_SearchRecordHighlightRepresentation } from './SearchRecordHighlightRepresentation';
+import type { SearchRecordInfoRepresentation as SearchRecordInfoRepresentation_SearchRecordInfoRepresentation } from './SearchRecordInfoRepresentation';
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import type { RecordRepresentation as RecordRepresentation_RecordRepresentation } from './RecordRepresentation';
+export declare const VERSION = "b0dfc742bb2dab1c3c2399eab4c13412";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SearchResultRepresentation, existing: SearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SearchResultRepresentationNormalized;
+export interface DynamicIngestParams {
+    record: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: SearchResultRepresentation, existing: SearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => SearchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    record?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SearchResultRepresentationNormalized, incoming: SearchResultRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Record with search metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchResultRepresentationNormalized {
+    /** Related search highlight */
+    highlightInfo?: SearchRecordHighlightRepresentation_SearchRecordHighlightRepresentation;
+    /** Record found in Search */
+    record: $64$luvio_engine_StoreLink;
+    /** Related search info */
+    searchInfo: SearchRecordInfoRepresentation_SearchRecordInfoRepresentation;
+}
+/**
+ * Record with search metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SearchResultRepresentation {
+    highlightInfo?: SearchRecordHighlightRepresentation_SearchRecordHighlightRepresentation;
+    record: RecordRepresentation_RecordRepresentation;
+    searchInfo: SearchRecordInfoRepresentation_SearchRecordInfoRepresentation;
+}

package/dist/types/adapters/types/SearchResultsSummaryRepresentation.d.ts

@@ -0,0 +1,67 @@
+import type { KeywordSearchResultsRepresentation as KeywordSearchResultsRepresentation_KeywordSearchResultsRepresentation } from './KeywordSearchResultsRepresentation';
+import type { SearchAnswersResultRepresentation as SearchAnswersResultRepresentation_SearchAnswersResultRepresentation } from './SearchAnswersResultRepresentation';
+import type { NLSResultsRepresentation as NLSResultsRepresentation_NLSResultsRepresentation } from './NLSResultsRepresentation';
+import type { SearchObjectOptionsOutputRepresentation as SearchObjectOptionsOutputRepresentation_SearchObjectOptionsOutputRepresentation } from './SearchObjectOptionsOutputRepresentation';
+import type { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 200;
+export declare const VERSION = "c3b86b51e83e00857929bc3dd6742a85";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    query: string;
+    configurationName: string | null;
+}
+export type SearchResultsSummaryRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialSearchResultsSummaryRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): SearchResultsSummaryRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: SearchResultsSummaryRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: SearchResultsSummaryRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: SearchResultsSummaryRepresentation, _existing: SearchResultsSummaryRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): SearchResultsSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: SearchResultsSummaryRepresentationNormalized, incoming: SearchResultsSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SearchResultsSummaryRepresentation, _fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Root of the search response
+ *
+ * Keys:
+ *    query (string): query
+ *    configurationName (string | null): configurationName
+ */
+export interface SearchResultsSummaryRepresentationNormalized {
+    /** Configuration Name to be applied */
+    configurationName: string | null;
+    /** Keyword Search Results Response */
+    keywordSearchResults: $64$luvio_engine_StoreLink | null;
+    /** Natural Language Search Results Response */
+    nlsResults: $64$luvio_engine_StoreLink | null;
+    /** Search Answers Response */
+    qnaResult: SearchAnswersResultRepresentation_SearchAnswersResultRepresentation | null;
+    /** Search query that yielded the search results */
+    query: string;
+    /** Search’s request ID */
+    queryId: string;
+    /** Search object options applied */
+    searchObjectOptions: {
+        [key: string]: SearchObjectOptionsOutputRepresentation_SearchObjectOptionsOutputRepresentation;
+    };
+}
+/**
+ * Root of the search response
+ *
+ * Keys:
+ *    query (string): query
+ *    configurationName (string | null): configurationName
+ */
+export interface SearchResultsSummaryRepresentation {
+    configurationName: string | null;
+    keywordSearchResults: KeywordSearchResultsRepresentation_KeywordSearchResultsRepresentation | null;
+    nlsResults: NLSResultsRepresentation_NLSResultsRepresentation | null;
+    qnaResult: SearchAnswersResultRepresentation_SearchAnswersResultRepresentation | null;
+    query: string;
+    queryId: string;
+    searchObjectOptions: {
+        [key: string]: SearchObjectOptionsOutputRepresentation_SearchObjectOptionsOutputRepresentation;
+    };
+}

package/dist/types/adapters/types/ThemeInfoRepresentation.d.ts

@@ -0,0 +1,31 @@
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "2fd4bb345487199bb654769daae6d414";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ThemeInfoRepresentation, _existing: ThemeInfoRepresentationNormalized, _path: $64$luvio_engine_IngestPath, _luvio: $64$luvio_engine_Luvio, _store: $64$luvio_engine_Store, _timestamp: number): ThemeInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ThemeInfoRepresentationNormalized, incoming: ThemeInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ThemeInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Theme info.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ThemeInfoRepresentationNormalized {
+    /** Color. */
+    color: string;
+    /** Icon URL. */
+    iconUrl: string | null;
+}
+/**
+ * Theme info.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ThemeInfoRepresentation {
+    color: string;
+    iconUrl: string | null;
+}

package/dist/types/adapters/types/VisualforceLayoutComponentRepresentation.d.ts

@@ -0,0 +1,42 @@
+import type { AbstractRecordLayoutComponentRepresentation as AbstractRecordLayoutComponentRepresentation_AbstractRecordLayoutComponentRepresentation } from './AbstractRecordLayoutComponentRepresentation';
+import type { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "e2dd1c316486452be66eaf3104063f7d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: VisualforceLayoutComponentRepresentation, existing: VisualforceLayoutComponentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): VisualforceLayoutComponentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: VisualforceLayoutComponentRepresentationNormalized, incoming: VisualforceLayoutComponentRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: VisualforceLayoutComponentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Visualforce record layout component.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VisualforceLayoutComponentRepresentationNormalized extends AbstractRecordLayoutComponentRepresentation_AbstractRecordLayoutComponentRepresentation {
+    /** Height */
+    height: string;
+    /** Indicates whether to show the section label with this VF component. */
+    showLabel: boolean;
+    /** Show scroll */
+    showScroll: boolean;
+    /** Visualforce URL. */
+    visualforceUrl: string;
+    /** Width */
+    width: string;
+}
+/**
+ * Visualforce record layout component.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VisualforceLayoutComponentRepresentation extends AbstractRecordLayoutComponentRepresentation_AbstractRecordLayoutComponentRepresentation {
+    height: string;
+    showLabel: boolean;
+    showScroll: boolean;
+    visualforceUrl: string;
+    width: string;
+    componentType: 'VisualforcePage';
+}

package/dist/types/adapters/types/type-utils.d.ts

@@ -0,0 +1,32 @@
+import type { NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, ObjectAssign: {
+    <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;
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const JSONStringify: {
+    (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;
+};
+type AllowedPrimitives = boolean | string | number | Date | null;
+type Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;
+export type RecursivePartial<T> = null | {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> | null : Value<T[P]> | null;
+};
+export declare function equalsArray<U, V extends U[]>(a: V, b: V, equalsItem: (itemA: U, itemB: U) => boolean | void): boolean;
+export declare function equalsObject<U, V extends {
+    [key: string]: U;
+}>(a: V, b: V, equalsProp: (propA: U, propB: U) => boolean | void): boolean;
+export declare function createLink(ref: string | $64$luvio_engine_NormalizedKeyMetadata): {
+    __ref: string;
+};
+export declare function assignMetadataLink(entry: any, metadataKey: string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export {};

package/dist/types/adapters/uiapi/record-collection/resources/postUiApiListRecordsByListViewApiNameAndObjectApiName.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot } from '@luvio/engine';
+import type { ResourceRequestConfig as resources_postUiApiListRecordsByListViewApiNameAndObjectApiName_ResourceRequestConfig } from '../../../resources/postUiApiListRecordsByListViewApiNameAndObjectApiName';
+import type { ListRecordCollectionRepresentation as types_ListRecordCollectionRepresentation_ListRecordCollectionRepresentation } from '../../../types/ListRecordCollectionRepresentation';
+export declare function select(luvio: $64$luvio_engine_Luvio, params: resources_postUiApiListRecordsByListViewApiNameAndObjectApiName_ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: resources_postUiApiListRecordsByListViewApiNameAndObjectApiName_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ListRecordCollectionRepresentation_ListRecordCollectionRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ListRecordCollectionRepresentation_ListRecordCollectionRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_ListRecordCollectionRepresentation_ListRecordCollectionRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_ListRecordCollectionRepresentation_ListRecordCollectionRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_ListRecordCollectionRepresentation_ListRecordCollectionRepresentation, any>;

package/dist/types/adapters/uiapi/record-collection/resources/postUiApiRelatedListRecordsByParentRecordIdAndRelatedListId.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot } from '@luvio/engine';
+import type { ResourceRequestConfig as resources_postUiApiRelatedListRecordsByParentRecordIdAndRelatedListId_ResourceRequestConfig } from '../../../resources/postUiApiRelatedListRecordsByParentRecordIdAndRelatedListId';
+import type { RelatedListRecordCollectionRepresentation as types_RelatedListRecordCollectionRepresentation_RelatedListRecordCollectionRepresentation } from '../../../types/RelatedListRecordCollectionRepresentation';
+export declare function select(luvio: $64$luvio_engine_Luvio, params: resources_postUiApiRelatedListRecordsByParentRecordIdAndRelatedListId_ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: resources_postUiApiRelatedListRecordsByParentRecordIdAndRelatedListId_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_RelatedListRecordCollectionRepresentation_RelatedListRecordCollectionRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_RelatedListRecordCollectionRepresentation_RelatedListRecordCollectionRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_RelatedListRecordCollectionRepresentation_RelatedListRecordCollectionRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_RelatedListRecordCollectionRepresentation_RelatedListRecordCollectionRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_RelatedListRecordCollectionRepresentation_RelatedListRecordCollectionRepresentation, any>;

package/dist/types/adapters/util/adapter-utils.d.ts

@@ -0,0 +1,62 @@
+import type { Adapter as $64$luvio_engine_Adapter, Snapshot as $64$luvio_engine_Snapshot, UnfulfilledSnapshot as $64$luvio_engine_UnfulfilledSnapshot, AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata } from '@luvio/engine';
+export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
+declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export { ObjectCreate, ObjectKeys };
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayPrototypePush: (...items: any[]) => number;
+export interface AdapterValidationConfig {
+    displayName: string;
+    parameters: {
+        required: string[];
+        optional: string[];
+        unsupported?: string[];
+    };
+}
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+export declare function validateConfig<T>(config: Untrusted<T>, adapter: AdapterValidationConfig, oneOf?: string[]): void;
+export declare function untrustedIsObject<Base>(untrusted: unknown): untrusted is Untrusted<Base>;
+export type UncoercedConfiguration<Base, Options extends {
+    [key in keyof Base]?: any;
+}> = {
+    [Key in keyof Base]?: Base[Key] | Options[Key];
+};
+export type Untrusted<Base> = Partial<Base>;
+export declare function areRequiredParametersPresent<T>(config: any, configPropertyNames: AdapterValidationConfig): config is T;
+export declare function refreshable<C, D, R>(adapter: $64$luvio_engine_Adapter<C, D>, resolve: (config: unknown) => Promise<$64$luvio_engine_Snapshot<R>>): $64$luvio_engine_Adapter<C, D>;
+export declare const SNAPSHOT_STATE_FULFILLED = "Fulfilled";
+export declare const SNAPSHOT_STATE_UNFULFILLED = "Unfulfilled";
+export declare const snapshotRefreshOptions: {
+    overrides: {
+        headers: {
+            'Cache-Control': string;
+        };
+    };
+};
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function getFetchResponseStatusText(status: number): string;
+export declare function isUnfulfilledSnapshot<T, U>(snapshot: $64$luvio_engine_Snapshot<T, U>): snapshot is $64$luvio_engine_UnfulfilledSnapshot<T, U>;
+export declare function generateParamConfigMetadata(name: string, required: boolean, resourceType: $64$luvio_engine_AdapterConfigMetadata['resourceType'], typeCheckShape: $64$luvio_engine_AdapterConfigMetadata['typeCheckShape'], isArrayShape?: boolean, coerceFn?: (v: unknown) => unknown): $64$luvio_engine_AdapterConfigMetadata;
+export declare function buildAdapterValidationConfig(displayName: string, paramsMeta: $64$luvio_engine_AdapterConfigMetadata[]): AdapterValidationConfig;
+export declare const keyPrefix = "UiApi";

package/dist/types/adapters/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/adapters/util/field-ingest.d.ts

@@ -0,0 +1,16 @@
+import type { GraphNode, IngestPath, Luvio, Store } from '@luvio/engine';
+import type { PolymorphicFieldRepresentation, PolymorphicFieldRepresentationNormalized } from './fields';
+import { type RecordFieldTrie } from './records';
+import type { RecordConflictMap } from '../helpers/RecordRepresentation/resolveConflict';
+export declare function fieldIngest<N extends {
+    fields: {
+        [key: string]: PolymorphicFieldRepresentation;
+    };
+}, NN extends {
+    fields: {
+        [key: string]: PolymorphicFieldRepresentationNormalized;
+    };
+}>(input: N, existing: NN | undefined, path: IngestPath, luvio: Luvio, store: Store, timestamp: number, fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, recordConflictMap: RecordConflictMap): void;
+export declare function addFieldStateToValueNode(fieldsTrie: RecordFieldTrie, optionalFieldsTrie: RecordFieldTrie, fieldNode: any): void;
+export declare function readFieldStateFromValueNode(fieldNode: any): any;
+export declare function writeFieldStateNodeValue<K, V>(fieldNode: GraphNode<K, V>, propertyName: string, value: any): void;

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

@@ -0,0 +1,41 @@
+import type { PathSelection, StoreLink } from '@luvio/engine';
+import { type RecordRepresentation } from '../types/RecordRepresentation';
+import type { RecordFieldTrie } from '../util/records';
+export type ScalarFieldType = boolean | number | string | null;
+export type PolymorphicFieldRepresentationNormalized = {
+    displayValue: string | null;
+    value: StoreLink | ScalarFieldType;
+};
+export type PolymorphicFieldRepresentation = {
+    displayValue: string | null;
+    value: RecordRepresentation | ScalarFieldType | string[];
+};
+export type FieldMapRepresentationNormalized = {
+    apiName: string;
+    fields: {
+        [key: string]: PolymorphicFieldRepresentationNormalized;
+    };
+};
+export type FieldMapRepresentation = {
+    apiName: string;
+    fields: {
+        [key: string]: PolymorphicFieldRepresentation;
+    };
+};
+export declare const MAX_RECORD_DEPTH = 5;
+export declare function fieldEquals(existing: PolymorphicFieldRepresentationNormalized, incoming: PolymorphicFieldRepresentationNormalized): boolean;
+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/adapters/util/layout.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { RecordLayoutRepresentation } from '../types/RecordLayoutRepresentation';
+import type { ObjectInfoRepresentation } from '../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;