@salesforce/lds-adapters-uiapi 1.100.2

package/dist/types/src/generated/types/LocationFieldRepresentation.d.ts

@@ -0,0 +1,32 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "d4730db5d0dc984b94e37e7a1ee08f0b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LocationFieldRepresentation, existing: LocationFieldRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LocationFieldRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LocationFieldRepresentationNormalized, incoming: LocationFieldRepresentationNormalized): boolean;
+export declare function deepFreeze(input: LocationFieldRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: LocationFieldRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Represents a record field's complex location value.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LocationFieldRepresentationNormalized {
+    /** Gets the latitude of the location. This value maybe null if both latitude and longitude are null. */
+    latitude: number;
+    /** Gets the longitude of the location. This value maybe null if both latitude and longitude are null. */
+    longitude: number;
+}
+/**
+ * Represents a record field's complex location value.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LocationFieldRepresentation {
+    latitude: number;
+    longitude: number;
+}

package/dist/types/src/generated/types/LookupMetadataRepresentation.d.ts

@@ -0,0 +1,56 @@
+import { LookupMetadataTargetInfoRepresentation as LookupMetadataTargetInfoRepresentation_LookupMetadataTargetInfoRepresentation } from './LookupMetadataTargetInfoRepresentation';
+import { 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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 30000;
+export declare const VERSION = "ab99b79a5e8a78e051ec92b39d76a6bd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    objectApiName: string;
+    fieldApiName: string;
+}
+export type LookupMetadataRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialLookupMetadataRepresentationNormalizedKeyMetadata = 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): LookupMetadataRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: LookupMetadataRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: LookupMetadataRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: LookupMetadataRepresentation, existing: LookupMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LookupMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: LookupMetadataRepresentationNormalized, incoming: LookupMetadataRepresentationNormalized): boolean;
+export declare function deepFreeze(input: LookupMetadataRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: LookupMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Search Lookups Metadata
+ *
+ * Keys:
+ *    objectApiName (string): objectApiName
+ *    fieldApiName (string): fieldApiName
+ */
+export interface LookupMetadataRepresentationNormalized {
+    /** API name of the lookup field. */
+    fieldApiName: string;
+    /** API name of the lookup field source object. */
+    objectApiName: string;
+    /** API name of the field used as a secondary display field. */
+    secondaryField: string | null;
+    /** Per target entity metadata */
+    targetInfo: {
+        [key: string]: LookupMetadataTargetInfoRepresentation_LookupMetadataTargetInfoRepresentation;
+    };
+}
+/**
+ * Search Lookups Metadata
+ *
+ * Keys:
+ *    objectApiName (string): objectApiName
+ *    fieldApiName (string): fieldApiName
+ */
+export interface LookupMetadataRepresentation {
+    fieldApiName: string;
+    objectApiName: string;
+    secondaryField: string | null;
+    targetInfo: {
+        [key: string]: LookupMetadataTargetInfoRepresentation_LookupMetadataTargetInfoRepresentation;
+    };
+}

package/dist/types/src/generated/types/LookupMetadataTargetInfoRepresentation.d.ts

@@ -0,0 +1,36 @@
+import { DisplayLayoutAndMatchingInfoRepresentation as DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation } from './DisplayLayoutAndMatchingInfoRepresentation';
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "814e3fb1cff0f29b4d706ba0ce195038";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LookupMetadataTargetInfoRepresentation, existing: LookupMetadataTargetInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LookupMetadataTargetInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LookupMetadataTargetInfoRepresentationNormalized, incoming: LookupMetadataTargetInfoRepresentationNormalized): boolean;
+export declare function deepFreeze(input: LookupMetadataTargetInfoRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: LookupMetadataTargetInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Search Lookups target Metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupMetadataTargetInfoRepresentationNormalized {
+    /** Full Search display layout and matching info */
+    fullSearchInfo: DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation;
+    /** Object API name */
+    objectApiName: string;
+    /** Suggestions display layout and matching info */
+    suggestionsInfo: DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation;
+}
+/**
+ * Search Lookups target Metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupMetadataTargetInfoRepresentation {
+    fullSearchInfo: DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation;
+    objectApiName: string;
+    suggestionsInfo: DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation;
+}

package/dist/types/src/generated/types/LookupValuesRepresentation.d.ts

@@ -0,0 +1,53 @@
+import { 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, PathSelection as $64$luvio_engine_PathSelection, StoreLink as $64$luvio_engine_StoreLink, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+import { RecordCollectionRepresentation as RecordCollectionRepresentation_RecordCollectionRepresentation } from './RecordCollectionRepresentation';
+import { LookupMetadataRepresentation as LookupMetadataRepresentation_LookupMetadataRepresentation } from './LookupMetadataRepresentation';
+export declare const VERSION = "7afbf1748874667ff6c5efeee85824d7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LookupValuesRepresentation, existing: LookupValuesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LookupValuesRepresentationNormalized;
+export interface DynamicIngestParams {
+    lookupResults: $64$luvio_engine_ResourceIngest;
+    metadata: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: LookupValuesRepresentation, existing: LookupValuesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => LookupValuesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    lookupResults?: $64$luvio_engine_PathSelection;
+    metadata?: $64$luvio_engine_PathSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LookupValuesRepresentationNormalized, incoming: LookupValuesRepresentationNormalized): boolean;
+export declare function deepFreeze(input: LookupValuesRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: LookupValuesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Search results for a given lookup field, organized by type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupValuesRepresentationNormalized {
+    /** Search results for a given lookup field, organized by type. */
+    lookupResults: {
+        [key: string]: $64$luvio_engine_StoreLink;
+    };
+    /** Search metadata for a given lookup field, organized by type. */
+    metadata: {
+        [key: string]: $64$luvio_engine_StoreLink;
+    };
+}
+/**
+ * Search results for a given lookup field, organized by type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupValuesRepresentation {
+    lookupResults: {
+        [key: string]: RecordCollectionRepresentation_RecordCollectionRepresentation;
+    };
+    metadata: {
+        [key: string]: LookupMetadataRepresentation_LookupMetadataRepresentation;
+    };
+}

package/dist/types/src/generated/types/MatchRepresentation.d.ts

@@ -0,0 +1,40 @@
+import { DuplicateResultInfoRepresentation as DuplicateResultInfoRepresentation_DuplicateResultInfoRepresentation } from './DuplicateResultInfoRepresentation';
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "3486e8f10e3f9c490091d2281c8c267a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MatchRepresentation, existing: MatchRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MatchRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MatchRepresentationNormalized, incoming: MatchRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MatchRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MatchRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of group of possible matches
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchRepresentationNormalized {
+    /** Map of duplicate rule name to DuplicateResultInfo. */
+    duplicateResultInfos: {
+        [key: string]: DuplicateResultInfoRepresentation_DuplicateResultInfoRepresentation;
+    };
+    /** The object's API name. */
+    objectApiName: string;
+    /** List of RecordId's with matching rule. */
+    recordIds: Array<string>;
+}
+/**
+ * Representation of group of possible matches
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchRepresentation {
+    duplicateResultInfos: {
+        [key: string]: DuplicateResultInfoRepresentation_DuplicateResultInfoRepresentation;
+    };
+    objectApiName: string;
+    recordIds: Array<string>;
+}

package/dist/types/src/generated/types/MatchResultInfoRepresentation.d.ts

@@ -0,0 +1,32 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "c8ba26e643b0a08812056e1c994951a3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MatchResultInfoRepresentation, existing: MatchResultInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MatchResultInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MatchResultInfoRepresentationNormalized, incoming: MatchResultInfoRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MatchResultInfoRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MatchResultInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Match Result Info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchResultInfoRepresentationNormalized {
+    /** List of recordIds matched. */
+    recordIds: Array<string>;
+    /** Name of Match rule. */
+    rule: string;
+}
+/**
+ * Match Result Info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchResultInfoRepresentation {
+    recordIds: Array<string>;
+    rule: string;
+}

package/dist/types/src/generated/types/MatchResultRepresentation.d.ts

@@ -0,0 +1,47 @@
+import { ThemeInfoRepresentation as ThemeInfoRepresentation_ThemeInfoRepresentation } from './ThemeInfoRepresentation';
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "0594e7ac5140d470a4fdee184890dc4f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MatchResultRepresentation, existing: MatchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MatchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MatchResultRepresentationNormalized, incoming: MatchResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MatchResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MatchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Duplicate rule match.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchResultRepresentationNormalized {
+    /** Object API name. */
+    apiName: string;
+    /** Indicates whether the duplicate rule will allow a duplicate to be saved. */
+    isAllowSave: boolean;
+    /** IDs of the matching records. */
+    matchRecordIds: Array<string>;
+    /** The developer name of the matching duplicate rule. */
+    matchRule: string;
+    /** Object label. */
+    objectLabel: string;
+    /** Object plural label. */
+    objectLabelPlural: string;
+    themeInfo: ThemeInfoRepresentation_ThemeInfoRepresentation;
+}
+/**
+ * Duplicate rule match.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchResultRepresentation {
+    apiName: string;
+    isAllowSave: boolean;
+    matchRecordIds: Array<string>;
+    matchRule: string;
+    objectLabel: string;
+    objectLabelPlural: string;
+    themeInfo: ThemeInfoRepresentation_ThemeInfoRepresentation;
+}

package/dist/types/src/generated/types/MatchRuleRepresentation.d.ts

@@ -0,0 +1,42 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 900000;
+export declare const VERSION = "b47b44e260e5ce777beaf3da9088997c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MatchRuleRepresentation, existing: MatchRuleRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MatchRuleRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MatchRuleRepresentationNormalized, incoming: MatchRuleRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MatchRuleRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MatchRuleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Match Rule for dedupe configuration
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchRuleRepresentationNormalized {
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** Name of Matching Engine. */
+    matchEngine: string;
+    /** Fields used for current MatchRule. */
+    matchFields: Array<string>;
+    /** Name of the current MatchRule. */
+    name: string;
+    /** Entity Type of Match Rule. */
+    objectApiName: string;
+}
+/**
+ * Match Rule for dedupe configuration
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchRuleRepresentation {
+    eTag: string;
+    matchEngine: string;
+    matchFields: Array<string>;
+    name: string;
+    objectApiName: string;
+}

package/dist/types/src/generated/types/MatchingInfoRepresentation.d.ts

@@ -0,0 +1,29 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "f308fd65638a43d7c2c55d8141de6a29";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MatchingInfoRepresentation, existing: MatchingInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MatchingInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MatchingInfoRepresentationNormalized, incoming: MatchingInfoRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MatchingInfoRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MatchingInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Search Lookups target matching info metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchingInfoRepresentationNormalized {
+    /** Ordered list of fields to match on */
+    matchingFields: Array<string>;
+}
+/**
+ * Search Lookups target matching info metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MatchingInfoRepresentation {
+    matchingFields: Array<string>;
+}

package/dist/types/src/generated/types/NavItemInputRepresentation.d.ts

@@ -0,0 +1,35 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "798c2505ed0c88ffb6f395a16e96cd02";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: NavItemInputRepresentation, existing: NavItemInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): NavItemInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: NavItemInputRepresentationNormalized, incoming: NavItemInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: NavItemInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: NavItemInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A navigation item.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NavItemInputRepresentationNormalized {
+    /** The nav item's id. */
+    id: string;
+    /** The nav item's label. */
+    label: string;
+    /** The nav item's page reference. */
+    pageReference: {};
+}
+/**
+ * A navigation item.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NavItemInputRepresentation {
+    id: string;
+    label: string;
+    pageReference: {};
+}

package/dist/types/src/generated/types/NavItemRepresentation.d.ts

@@ -0,0 +1,91 @@
+import { 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, 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 } from '@luvio/engine';
+import { PageReferenceRepresentation as PageReferenceRepresentation_PageReferenceRepresentation } from './PageReferenceRepresentation';
+export declare const TTL = 120000;
+export declare const VERSION = "09884ca5bf90ea4662092a4e48817081";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    developerName: string;
+}
+export type NavItemRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialNavItemRepresentationNormalizedKeyMetadata = 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): NavItemRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: NavItemRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: NavItemRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: NavItemRepresentation, existing: NavItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): NavItemRepresentationNormalized;
+export interface DynamicIngestParams {
+    pageReference: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: NavItemRepresentation, existing: NavItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => NavItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    pageReference?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: NavItemRepresentationNormalized, incoming: NavItemRepresentationNormalized): boolean;
+export declare function deepFreeze(input: NavItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: NavItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Metadata for a navitem (tab)
+ *
+ * Keys:
+ *    developerName (string): developerName
+ */
+export interface NavItemRepresentationNormalized {
+    /** Is this tab available for salesforce classic */
+    availableInClassic: boolean;
+    /** Is this tab available for lightning */
+    availableInLightning: boolean;
+    /** Tab color of the tab */
+    color: string;
+    /** Launch url for this tab */
+    content: string | null;
+    /** Boolean specifying if this tab is a custom tab */
+    custom: boolean;
+    /** Developer name of the tab */
+    developerName: string;
+    /** URL for the tab icon */
+    iconUrl: string;
+    /** ID of the nav item */
+    id: string | null;
+    /** Nav menu item type */
+    itemType: string;
+    /** Label of the tab */
+    label: string;
+    /** Api name of the object corresponding to this tab */
+    objectApiName: string;
+    /** The label of the associated object, if applicable. */
+    objectLabel: string | null;
+    /** The plural label of the associated object, if applicable. */
+    objectLabelPlural: string | null;
+    /** Corresponding page reference for the nav item */
+    pageReference: $64$luvio_engine_StoreLink | null;
+    /** Standard type */
+    standardType: string | null;
+}
+/**
+ * Metadata for a navitem (tab)
+ *
+ * Keys:
+ *    developerName (string): developerName
+ */
+export interface NavItemRepresentation {
+    availableInClassic: boolean;
+    availableInLightning: boolean;
+    color: string;
+    content: string | null;
+    custom: boolean;
+    developerName: string;
+    iconUrl: string;
+    id: string | null;
+    itemType: string;
+    label: string;
+    objectApiName: string;
+    objectLabel: string | null;
+    objectLabelPlural: string | null;
+    pageReference: PageReferenceRepresentation_PageReferenceRepresentation | null;
+    standardType: string | null;
+}

package/dist/types/src/generated/types/NavItemsInputRepresentation.d.ts

@@ -0,0 +1,29 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "e2ecb9499e0f20f9e4ed051e310eb520";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: NavItemsInputRepresentation, existing: NavItemsInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): NavItemsInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: NavItemsInputRepresentationNormalized, incoming: NavItemsInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: NavItemsInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: NavItemsInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * An ordered list of nav items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NavItemsInputRepresentationNormalized {
+    /** An ordered list of nav items */
+    navItems: Array<{}>;
+}
+/**
+ * An ordered list of nav items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NavItemsInputRepresentation {
+    navItems: Array<{}>;
+}

package/dist/types/src/generated/types/NavItemsRepresentation.d.ts

@@ -0,0 +1,49 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+import { NavItemRepresentation as NavItemRepresentation_NavItemRepresentation } from './NavItemRepresentation';
+export declare const TTL = 120000;
+export declare const VERSION = "756779d0d7e137dd72c743544afbad82";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: NavItemsRepresentation, existing: NavItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): NavItemsRepresentationNormalized;
+export interface DynamicIngestParams {
+    navItems: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: NavItemsRepresentation, existing: NavItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => NavItemsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    navItems?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: NavItemsRepresentationNormalized, incoming: NavItemsRepresentationNormalized): boolean;
+export declare function deepFreeze(input: NavItemsRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: NavItemsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * An ordered lists of nav items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NavItemsRepresentationNormalized {
+    /** URL to the current page of nav items. */
+    currentPageUrl: string;
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** An ordered list of nav items. */
+    navItems: Array<$64$luvio_engine_StoreLink>;
+    /** URL to the next page of of nav items. */
+    nextPageUrl: string | null;
+}
+/**
+ * An ordered lists of nav items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NavItemsRepresentation {
+    currentPageUrl: string;
+    eTag: string;
+    navItems: Array<NavItemRepresentation_NavItemRepresentation>;
+    nextPageUrl: string | null;
+}

package/dist/types/src/generated/types/ObjectInfoDirectoryEntryRepresentation.d.ts

@@ -0,0 +1,44 @@
+import { 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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "2e822aab70fdf6622a60bb733aa9b5bc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ObjectInfoDirectoryEntryRepresentation, existing: ObjectInfoDirectoryEntryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ObjectInfoDirectoryEntryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ObjectInfoDirectoryEntryRepresentationNormalized, incoming: ObjectInfoDirectoryEntryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ObjectInfoDirectoryEntryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ObjectInfoDirectoryEntryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Entry for an object info within the directory of objects.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryEntryRepresentationNormalized {
+    /** The API name of the object info corresponding to this entry. */
+    apiName: string;
+    /** The key prefix for IDs of this object. */
+    keyPrefix: string | null;
+    /** The label of the object info corresponding to this entry. */
+    label: string;
+    /** The plural label of the object info corresponding to this entry. */
+    labelPlural: string;
+    /** List of the API names of the fields used to identify the name field for standard and custom objects. Typically there is one name field per object, except where FirstName and LastName fields are used. */
+    nameFields: Array<string>;
+    /** The URL to retrieve the full object info corresponding to this entry. */
+    objectInfoUrl: string;
+}
+/**
+ * Entry for an object info within the directory of objects.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryEntryRepresentation {
+    apiName: string;
+    keyPrefix: string | null;
+    label: string;
+    labelPlural: string;
+    nameFields: Array<string>;
+    objectInfoUrl: string;
+}