@salesforce/lds-runtime-mobile 1.314.0 → 1.316.0

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

@@ -0,0 +1,31 @@
+import { DisplayLayoutRepresentation as DisplayLayoutRepresentation_DisplayLayoutRepresentation } from './DisplayLayoutRepresentation';
+import { MatchingInfoRepresentation as MatchingInfoRepresentation_MatchingInfoRepresentation } from './MatchingInfoRepresentation';
+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 = "c874d0228111fdd1f93fcc6d4011d7a4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DisplayLayoutAndMatchingInfoRepresentation, existing: DisplayLayoutAndMatchingInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DisplayLayoutAndMatchingInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DisplayLayoutAndMatchingInfoRepresentationNormalized, incoming: DisplayLayoutAndMatchingInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DisplayLayoutAndMatchingInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Search Lookups target display layout and matching info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DisplayLayoutAndMatchingInfoRepresentationNormalized {
+    displayLayout: DisplayLayoutRepresentation_DisplayLayoutRepresentation;
+    matchingInfo: MatchingInfoRepresentation_MatchingInfoRepresentation;
+}
+/**
+ * Search Lookups target display layout and matching info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DisplayLayoutAndMatchingInfoRepresentation {
+    displayLayout: DisplayLayoutRepresentation_DisplayLayoutRepresentation;
+    matchingInfo: MatchingInfoRepresentation_MatchingInfoRepresentation;
+}

package/sfdc/types/adapters/generated/types/DisplayLayoutRepresentation.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 = "a9ef377e5477d801df0f48553d914e16";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DisplayLayoutRepresentation, existing: DisplayLayoutRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DisplayLayoutRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DisplayLayoutRepresentationNormalized, incoming: DisplayLayoutRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DisplayLayoutRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Search Lookups target display layout metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DisplayLayoutRepresentationNormalized {
+    /** Fields to display in lookup results */
+    displayFields: Array<string>;
+}
+/**
+ * Search Lookups target display layout metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DisplayLayoutRepresentation {
+    displayFields: Array<string>;
+}

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

@@ -0,0 +1,29 @@
+import { MatchResultRepresentation as MatchResultRepresentation_MatchResultRepresentation } from './MatchResultRepresentation';
+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 = "24e0f70b6dfd572c484604099728b813";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicateRecordErrorRepresentation, existing: DuplicateRecordErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicateRecordErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DuplicateRecordErrorRepresentationNormalized, incoming: DuplicateRecordErrorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicateRecordErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicate record error.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRecordErrorRepresentationNormalized {
+    /** Duplicate rule match results. */
+    matchResults: Array<MatchResultRepresentation_MatchResultRepresentation>;
+}
+/**
+ * Duplicate record error.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRecordErrorRepresentation {
+    matchResults: Array<MatchResultRepresentation_MatchResultRepresentation>;
+}

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

@@ -0,0 +1,34 @@
+import { MatchResultInfoRepresentation as MatchResultInfoRepresentation_MatchResultInfoRepresentation } from './MatchResultInfoRepresentation';
+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 = "7571de0652abb50cd8f328f20ab0f9d1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicateResultInfoRepresentation, existing: DuplicateResultInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicateResultInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DuplicateResultInfoRepresentationNormalized, incoming: DuplicateResultInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicateResultInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicate Result Info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateResultInfoRepresentationNormalized {
+    /** Indicates whether duplicates are allowed to be saved. */
+    allowSave: boolean;
+    matchResultInfo: MatchResultInfoRepresentation_MatchResultInfoRepresentation;
+    /** Name of Duplicate rule. */
+    rule: string;
+}
+/**
+ * Duplicate Result Info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateResultInfoRepresentation {
+    allowSave: boolean;
+    matchResultInfo: MatchResultInfoRepresentation_MatchResultInfoRepresentation;
+    rule: string;
+}

package/sfdc/types/adapters/generated/types/DuplicateRuleFilterItemRepresentation.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 = "f43ef90ffde4d488414d6868e3aaefcb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicateRuleFilterItemRepresentation, existing: DuplicateRuleFilterItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicateRuleFilterItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DuplicateRuleFilterItemRepresentationNormalized, incoming: DuplicateRuleFilterItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicateRuleFilterItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicate Rule filter item
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRuleFilterItemRepresentationNormalized {
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** The field name on which filter is set. */
+    field: string;
+    /** Operation to be used. */
+    operation: string;
+    /** The order in which filter item was added to the filter. */
+    sortOrder: number;
+    /** The value of field to evaluate operation. */
+    value: string;
+}
+/**
+ * Duplicate Rule filter item
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRuleFilterItemRepresentation {
+    eTag: string;
+    field: string;
+    operation: string;
+    sortOrder: number;
+    value: string;
+}

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

@@ -0,0 +1,39 @@
+import { DuplicateRuleFilterItemRepresentation as DuplicateRuleFilterItemRepresentation_DuplicateRuleFilterItemRepresentation } from './DuplicateRuleFilterItemRepresentation';
+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 = "320d7f254687278f2763d4b490dab3fb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicateRuleFilterRepresentation, existing: DuplicateRuleFilterRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicateRuleFilterRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DuplicateRuleFilterRepresentationNormalized, incoming: DuplicateRuleFilterRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicateRuleFilterRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicate Rule filter
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRuleFilterRepresentationNormalized {
+    /** The custom filter logic expressed as a boolean expression. */
+    booleanFilter: string;
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** List of filter items. */
+    filterItems: Array<DuplicateRuleFilterItemRepresentation_DuplicateRuleFilterItemRepresentation>;
+    /** Rule Criteria. */
+    ruleCritera: string;
+}
+/**
+ * Duplicate Rule filter
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRuleFilterRepresentation {
+    booleanFilter: string;
+    eTag: string;
+    filterItems: Array<DuplicateRuleFilterItemRepresentation_DuplicateRuleFilterItemRepresentation>;
+    ruleCritera: string;
+}

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

@@ -0,0 +1,55 @@
+import { DuplicateRuleFilterRepresentation as DuplicateRuleFilterRepresentation_DuplicateRuleFilterRepresentation } from './DuplicateRuleFilterRepresentation';
+import { MatchRuleRepresentation as MatchRuleRepresentation_MatchRuleRepresentation } from './MatchRuleRepresentation';
+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 = "bb83d7210bb1d7861b6188bc5f552617";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicateRuleRepresentation, existing: DuplicateRuleRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicateRuleRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DuplicateRuleRepresentationNormalized, incoming: DuplicateRuleRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicateRuleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicate Rule for dedupe configuration
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRuleRepresentationNormalized {
+    /** Action on insert, Block or Allow for dedupe rule */
+    actionOnInsert: string;
+    /** Action on update, Block or Allow for dedupe rule. */
+    actionOnUpdate: string;
+    /** Determine whether dedupe rule is active. */
+    active: boolean;
+    /** Duplicate filters. */
+    duplicateRuleFilters: Array<DuplicateRuleFilterRepresentation_DuplicateRuleFilterRepresentation>;
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** MatchRules for the current DuplicateRule. */
+    matchRules: Array<MatchRuleRepresentation_MatchRuleRepresentation>;
+    /** Name of Duplicate rule. */
+    name: string;
+    /** Operations on insert, either or both of alert and report for dedupe rule. */
+    operationsOnInsert: Array<string>;
+    /** Operations on update, either or both of alert and report for dedupe rule. */
+    operationsOnUpdate: Array<string>;
+}
+/**
+ * Duplicate Rule for dedupe configuration
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicateRuleRepresentation {
+    actionOnInsert: string;
+    actionOnUpdate: string;
+    active: boolean;
+    duplicateRuleFilters: Array<DuplicateRuleFilterRepresentation_DuplicateRuleFilterRepresentation>;
+    eTag: string;
+    matchRules: Array<MatchRuleRepresentation_MatchRuleRepresentation>;
+    name: string;
+    operationsOnInsert: Array<string>;
+    operationsOnUpdate: Array<string>;
+}

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

@@ -0,0 +1,45 @@
+import { DuplicateRuleRepresentation as DuplicateRuleRepresentation_DuplicateRuleRepresentation } from './DuplicateRuleRepresentation';
+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 = "be27ee99dc0dc43a1f66b8fe98dc532c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicatesConfigurationRepresentation, existing: DuplicatesConfigurationRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicatesConfigurationRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DuplicatesConfigurationRepresentationNormalized, incoming: DuplicatesConfigurationRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicatesConfigurationRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicate Configuration for an object API.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicatesConfigurationRepresentationNormalized {
+    /** ApiName of the Entity. */
+    apiName: string;
+    /** Determine dedupe is enabled/disabled */
+    dedupeEnabled: boolean;
+    /** Dedupe fields used in config. */
+    dedupeFields: Array<string>;
+    /** Duplicate rules used in dedupe config. */
+    duplicateRules: Array<DuplicateRuleRepresentation_DuplicateRuleRepresentation>;
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** Determine predupe is enabled/disabled. */
+    predupeEnabled: boolean;
+}
+/**
+ * Duplicate Configuration for an object API.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicatesConfigurationRepresentation {
+    apiName: string;
+    dedupeEnabled: boolean;
+    dedupeFields: Array<string>;
+    duplicateRules: Array<DuplicateRuleRepresentation_DuplicateRuleRepresentation>;
+    eTag: string;
+    predupeEnabled: boolean;
+}

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

@@ -0,0 +1,39 @@
+import { MatchRepresentation as MatchRepresentation_MatchRepresentation } from './MatchRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, 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 = 30000;
+export declare const VERSION = "583c38564fa15ce0fb3dd2807be1bdc6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DuplicatesRepresentation, existing: DuplicatesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DuplicatesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: DuplicatesRepresentationNormalized, incoming: DuplicatesRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DuplicatesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Duplicates
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicatesRepresentationNormalized {
+    /** Determince whether duplicates are allowed to be saved */
+    allowSave: boolean;
+    /** Determine if there  exists duplicates. */
+    duplicateError: boolean;
+    /** Duplicate rules used for match. */
+    duplicateRules: Array<string>;
+    /** A list of potential matches. */
+    matches: Array<MatchRepresentation_MatchRepresentation>;
+}
+/**
+ * Duplicates
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DuplicatesRepresentation {
+    allowSave: boolean;
+    duplicateError: boolean;
+    duplicateRules: Array<string>;
+    matches: Array<MatchRepresentation_MatchRepresentation>;
+}

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

@@ -0,0 +1,26 @@
+import { AbstractFormSubitemRepresentation as AbstractFormSubitemRepresentation_AbstractFormSubitemRepresentation } from './AbstractFormSubitemRepresentation';
+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 = "0e1f8c145bf74188c670c8e2a2047634";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EmptySpaceFormSubitemRepresentation, existing: EmptySpaceFormSubitemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EmptySpaceFormSubitemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EmptySpaceFormSubitemRepresentationNormalized, incoming: EmptySpaceFormSubitemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EmptySpaceFormSubitemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Empty Space Subitem.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmptySpaceFormSubitemRepresentationNormalized extends AbstractFormSubitemRepresentation_AbstractFormSubitemRepresentation {
+}
+/**
+ * Empty Space Subitem.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmptySpaceFormSubitemRepresentation extends AbstractFormSubitemRepresentation_AbstractFormSubitemRepresentation {
+}

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

@@ -0,0 +1,53 @@
+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 { PlatformActionRepresentation as PlatformActionRepresentation_PlatformActionRepresentation } from './PlatformActionRepresentation';
+export declare const VERSION = "378d506f563a4bd724b322d440df33d1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    url: string;
+}
+export type EntityActionRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialEntityActionRepresentationNormalizedKeyMetadata = 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): EntityActionRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: EntityActionRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: EntityActionRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: EntityActionRepresentation, existing: EntityActionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EntityActionRepresentationNormalized;
+export interface DynamicIngestParams {
+    actions: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: EntityActionRepresentation, existing: EntityActionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => EntityActionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    actions?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EntityActionRepresentationNormalized, incoming: EntityActionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EntityActionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Entity's Actions.
+ *
+ * Keys:
+ *    url (string): url
+ */
+export interface EntityActionRepresentationNormalized {
+    /** Record data. */
+    actions: Array<$64$luvio_engine_StoreLink>;
+    /** subconext's api url of the current current entity request */
+    links: Array<string>;
+    /** the url of the current entity request */
+    url: string;
+}
+/**
+ * Entity's Actions.
+ *
+ * Keys:
+ *    url (string): url
+ */
+export interface EntityActionRepresentation {
+    actions: Array<PlatformActionRepresentation_PlatformActionRepresentation>;
+    links: Array<string>;
+    url: string;
+}

package/sfdc/types/adapters/generated/types/ErrorMessageRepresentation.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 = "3ec5d221261cee97fc4d020ffdd2e0af";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ErrorMessageRepresentation, existing: ErrorMessageRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ErrorMessageRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ErrorMessageRepresentationNormalized, incoming: ErrorMessageRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ErrorMessageRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Explain why we were not able to search on the object
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorMessageRepresentationNormalized {
+    /** Type of error */
+    errorCode: string;
+    /** Description of the error */
+    message: string | null;
+}
+/**
+ * Explain why we were not able to search on the object
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorMessageRepresentation {
+    errorCode: string;
+    message: string | null;
+}

package/sfdc/types/adapters/generated/types/ErrorSingleRecordAvatarRepresentation.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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "17c20b01167dba9a81452e60bb28b2f2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ErrorSingleRecordAvatarRepresentation, existing: ErrorSingleRecordAvatarRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ErrorSingleRecordAvatarRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ErrorSingleRecordAvatarRepresentationNormalized, incoming: ErrorSingleRecordAvatarRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ErrorSingleRecordAvatarRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorSingleRecordAvatarRepresentationNormalized {
+    errorCode: string;
+    message: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorSingleRecordAvatarRepresentation {
+    errorCode: string;
+    message: string;
+}

package/sfdc/types/adapters/generated/types/FavoriteBatchCollectionInputRepresentation.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 = "3e475bf6083eebf2dec29d0800b3ff16";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FavoriteBatchCollectionInputRepresentation, existing: FavoriteBatchCollectionInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FavoriteBatchCollectionInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FavoriteBatchCollectionInputRepresentationNormalized, incoming: FavoriteBatchCollectionInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FavoriteBatchCollectionInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents all favorites when updating favorites in batch.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteBatchCollectionInputRepresentationNormalized {
+    /** The list of favorites to keep and update. */
+    favorites: Array<{}>;
+}
+/**
+ * Represents all favorites when updating favorites in batch.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteBatchCollectionInputRepresentation {
+    favorites: Array<{}>;
+}

package/sfdc/types/adapters/generated/types/FavoriteBatchInputRepresentation.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 = "4756d282dea64a0c02592b15690bfb13";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FavoriteBatchInputRepresentation, existing: FavoriteBatchInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FavoriteBatchInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FavoriteBatchInputRepresentationNormalized, incoming: FavoriteBatchInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FavoriteBatchInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents a single favorite when updating favorites in batch.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteBatchInputRepresentationNormalized {
+    /** ID of the favorite. */
+    id: string;
+    /** The name of the favorite. */
+    name: string;
+}
+/**
+ * Represents a single favorite when updating favorites in batch.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteBatchInputRepresentation {
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,29 @@
+import { FavoriteRepresentation as FavoriteRepresentation_FavoriteRepresentation } from './FavoriteRepresentation';
+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 = "998b1e791f0fb7cff4833fd95ba799b9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FavoriteCollectionRepresentation, existing: FavoriteCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FavoriteCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FavoriteCollectionRepresentationNormalized, incoming: FavoriteCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FavoriteCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * A list of favorites.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteCollectionRepresentationNormalized {
+    /** The list of favorites. */
+    favorites: Array<FavoriteRepresentation_FavoriteRepresentation>;
+}
+/**
+ * A list of favorites.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteCollectionRepresentation {
+    favorites: Array<FavoriteRepresentation_FavoriteRepresentation>;
+}

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

@@ -0,0 +1,37 @@
+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 = "956fbbf5445290d7799827386343dfbc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FavoriteInputRepresentation, existing: FavoriteInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FavoriteInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FavoriteInputRepresentationNormalized, incoming: FavoriteInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FavoriteInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Create or update a favorite.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteInputRepresentationNormalized {
+    /** The name of the favorite. */
+    name: string;
+    /** The sort order of the favorite, from 1 to N. */
+    sortOrder: number;
+    /** The record, API name, or content being favorited. */
+    target: string;
+    /** The type of favorite. */
+    targetType: string;
+}
+/**
+ * Create or update a favorite.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FavoriteInputRepresentation {
+    name: string;
+    sortOrder: number;
+    target: string;
+    targetType: string;
+}