@salesforce/lds-runtime-mobile 1.314.0 → 1.316.0

package/sfdc/types/adapters/generated/types/LocationFieldRepresentation.d.ts

@@ -0,0 +1,31 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LocationFieldRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/LookupMetadataRepresentation.d.ts

@@ -0,0 +1,55 @@
+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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LookupMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/LookupMetadataTargetInfoRepresentation.d.ts

@@ -0,0 +1,36 @@
+import { AdvancedLookupInfoRepresentation as AdvancedLookupInfoRepresentation_AdvancedLookupInfoRepresentation } from './AdvancedLookupInfoRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "651983af79ef0b9931fc373f1d6c1181";
+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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LookupMetadataTargetInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Search Lookups target Metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupMetadataTargetInfoRepresentationNormalized {
+    /** Advanced Lookup Info */
+    advancedLookupInfo: AdvancedLookupInfoRepresentation_AdvancedLookupInfoRepresentation;
+    /** Object API name */
+    objectApiName: string;
+    /** Suggestions display layout and matching info */
+    suggestionsInfo: DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation;
+}
+/**
+ * Search Lookups target Metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupMetadataTargetInfoRepresentation {
+    advancedLookupInfo: AdvancedLookupInfoRepresentation_AdvancedLookupInfoRepresentation;
+    objectApiName: string;
+    suggestionsInfo: DisplayLayoutAndMatchingInfoRepresentation_DisplayLayoutAndMatchingInfoRepresentation;
+}

package/sfdc/types/adapters/generated/types/LookupPOSTRequestBodyRepresentation.d.ts

@@ -0,0 +1,29 @@
+import { RecordInputRepresentation as RecordInputRepresentation_RecordInputRepresentation } from './RecordInputRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "b691df90bb0e9447ab87187df1ff0a81";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: LookupPOSTRequestBodyRepresentation, existing: LookupPOSTRequestBodyRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LookupPOSTRequestBodyRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LookupPOSTRequestBodyRepresentationNormalized, incoming: LookupPOSTRequestBodyRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LookupPOSTRequestBodyRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * A lookup POST request body.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupPOSTRequestBodyRepresentationNormalized {
+    /** The source record */
+    sourceRecord?: RecordInputRepresentation_RecordInputRepresentation | null;
+}
+/**
+ * A lookup POST request body.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupPOSTRequestBodyRepresentation {
+    sourceRecord?: RecordInputRepresentation_RecordInputRepresentation | null;
+}

package/sfdc/types/adapters/generated/types/LookupValuesRepresentation.d.ts

@@ -0,0 +1,55 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import { RecordCollectionRepresentation as RecordCollectionRepresentation_RecordCollectionRepresentation } from './RecordCollectionRepresentation';
+export declare const VERSION = "022d5de1337ec512acb4af43b75ea5e6";
+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;
+}
+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;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LookupValuesRepresentationNormalized, incoming: LookupValuesRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: LookupValuesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+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: {
+        /** Search Lookups Metadata */
+        [key: string]: {
+            /** API name of the field used as a secondary display field. */
+            secondaryField: string | null;
+        };
+    };
+}
+/**
+ * Search results for a given lookup field, organized by type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LookupValuesRepresentation {
+    lookupResults: {
+        [key: string]: RecordCollectionRepresentation_RecordCollectionRepresentation;
+    };
+    metadata: {
+        [key: string]: {
+            secondaryField: string | null;
+        };
+    };
+}

package/sfdc/types/adapters/generated/types/MatchRepresentation.d.ts

@@ -0,0 +1,39 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MatchRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/MatchResultInfoRepresentation.d.ts

@@ -0,0 +1,31 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MatchResultInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/MatchResultRepresentation.d.ts

@@ -0,0 +1,46 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MatchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/MatchRuleRepresentation.d.ts

@@ -0,0 +1,41 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MatchRuleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/MatchingInfoRepresentation.d.ts

@@ -0,0 +1,28 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MatchingInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/sfdc/types/adapters/generated/types/ObjectInfoRepresentation.d.ts

@@ -0,0 +1,126 @@
+import { ChildRelationshipRepresentation as ChildRelationshipRepresentation_ChildRelationshipRepresentation } from './ChildRelationshipRepresentation';
+import { FieldRepresentation as FieldRepresentation_FieldRepresentation } from './FieldRepresentation';
+import { RecordTypeInfoRepresentation as RecordTypeInfoRepresentation_RecordTypeInfoRepresentation } from './RecordTypeInfoRepresentation';
+import { ThemeInfoRepresentation as ThemeInfoRepresentation_ThemeInfoRepresentation } from './ThemeInfoRepresentation';
+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 = 900000;
+export declare const VERSION = "2302a71ca718abb60353eb88dedb1c12";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    apiName: string;
+}
+export type ObjectInfoRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialObjectInfoRepresentationNormalizedKeyMetadata = 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): ObjectInfoRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ObjectInfoRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ObjectInfoRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ObjectInfoRepresentation, existing: ObjectInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ObjectInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ObjectInfoRepresentationNormalized, incoming: ObjectInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ObjectInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Object metadata.
+ *
+ * Keys:
+ *    apiName (string): apiName
+ */
+export interface ObjectInfoRepresentationNormalized {
+    /** The object API name. */
+    apiName: string;
+    /** If an associated entity type, the type of that association, otherwise null. */
+    associateEntityType: string | null;
+    /** If an associated entity type, the entity to which it is associated, otherwise null. */
+    associateParentEntity: string | null;
+    /** Child relationships for the object. */
+    childRelationships: Array<ChildRelationshipRepresentation_ChildRelationshipRepresentation>;
+    /** Indicates whether the object can have compact layouts. */
+    compactLayoutable: boolean;
+    /** Indicates whether the object can be created. */
+    createable: boolean;
+    /** Indicates whether the object is custom. */
+    custom: boolean;
+    /** The ID for the default record type for this object, if any. Null if there is none, or only a primary type. */
+    defaultRecordTypeId: string | null;
+    /** Indicates whether the object can be deleted. */
+    deletable: boolean;
+    /** This is a nested map of field and its dependents. Fields that neither have any controllers nor dependents are not a part of this map */
+    dependentFields: {
+        [key: string]: {};
+    };
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** Indicates whether the object may have feeds. */
+    feedEnabled: boolean;
+    /** A map of field API name to information about the field. This map only contains fields relevant to the requested layout and mode. */
+    fields: {
+        [key: string]: FieldRepresentation_FieldRepresentation;
+    };
+    /** The key prefix for IDs of this object. */
+    keyPrefix: string | null;
+    /** The object display label. */
+    label: string;
+    /** The plural form of the object display label. */
+    labelPlural: string;
+    /** Indicates whether the object can have a layout. */
+    layoutable: boolean;
+    /** Indicates whether the object may appear in Most Recently Used lists. */
+    mruEnabled: boolean;
+    /** 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>;
+    /** Indicates whether the object can be queried by the context user. */
+    queryable: boolean;
+    /** A map of record type IDs to information about the record type. The user need not have access to all the returned record types to see them here. */
+    recordTypeInfos: {
+        [key: string]: RecordTypeInfoRepresentation_RecordTypeInfoRepresentation;
+    };
+    /** Indicates whether the object can have search layouts. */
+    searchLayoutable: boolean;
+    /** Indicates whether the object can be searched. */
+    searchable: boolean;
+    /** Theme information for the object. */
+    themeInfo: ThemeInfoRepresentation_ThemeInfoRepresentation | null;
+    /** Indicates whether the object can be updated. */
+    updateable: boolean;
+}
+/**
+ * Object metadata.
+ *
+ * Keys:
+ *    apiName (string): apiName
+ */
+export interface ObjectInfoRepresentation {
+    apiName: string;
+    associateEntityType: string | null;
+    associateParentEntity: string | null;
+    childRelationships: Array<ChildRelationshipRepresentation_ChildRelationshipRepresentation>;
+    compactLayoutable: boolean;
+    createable: boolean;
+    custom: boolean;
+    defaultRecordTypeId: string | null;
+    deletable: boolean;
+    dependentFields: {
+        [key: string]: {};
+    };
+    eTag: string;
+    feedEnabled: boolean;
+    fields: {
+        [key: string]: FieldRepresentation_FieldRepresentation;
+    };
+    keyPrefix: string | null;
+    label: string;
+    labelPlural: string;
+    layoutable: boolean;
+    mruEnabled: boolean;
+    nameFields: Array<string>;
+    queryable: boolean;
+    recordTypeInfos: {
+        [key: string]: RecordTypeInfoRepresentation_RecordTypeInfoRepresentation;
+    };
+    searchLayoutable: boolean;
+    searchable: boolean;
+    themeInfo: ThemeInfoRepresentation_ThemeInfoRepresentation | null;
+    updateable: boolean;
+}

package/sfdc/types/adapters/generated/types/OperationInputRepresentation.d.ts

@@ -0,0 +1,38 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "11837b63202b2d0c9c67993438d2ed1e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OperationInputRepresentation, existing: OperationInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OperationInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OperationInputRepresentationNormalized, incoming: OperationInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OperationInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * An operation that can to be executed within aggregate
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OperationInputRepresentationNormalized {
+    /** The HTTP headers of the operation to be executed */
+    httpHeaders: {
+        [key: string]: string;
+    };
+    /** The ID of the operation that can be used in references */
+    referenceId: string;
+    /** The URL of the operation to executed */
+    url: string;
+}
+/**
+ * An operation that can to be executed within aggregate
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OperationInputRepresentation {
+    httpHeaders: {
+        [key: string]: string;
+    };
+    referenceId: string;
+    url: string;
+}

package/sfdc/types/adapters/generated/types/OperationResponseRepresentation.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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "d37896e71ed42a780936d197e23d7cf2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OperationResponseRepresentation, existing: OperationResponseRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OperationResponseRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OperationResponseRepresentationNormalized, incoming: OperationResponseRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OperationResponseRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The output of an operation execution within aggregate.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OperationResponseRepresentationNormalized {
+    /** The body of the operation */
+    body: {};
+    /** The HTTP headers of the operation */
+    httpHeaders: {
+        [key: string]: string;
+    };
+    /** The HTTP status code of the operation */
+    httpStatusCode: number;
+    /** The ID that was given for the operation */
+    referenceId: string;
+    /** The url for the operation */
+    url: string;
+}
+/**
+ * The output of an operation execution within aggregate.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OperationResponseRepresentation {
+    body: {};
+    httpHeaders: {
+        [key: string]: string;
+    };
+    httpStatusCode: number;
+    referenceId: string;
+    url: string;
+}