@salesforce/lds-adapters-uiapi 0.131.0

package/dist/es/es2018/types/src/generated/types/ContentInputRepresentation.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 = "5fc56cbb7cf818566b16c1074e58cc1b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ContentInputRepresentation, existing: ContentInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ContentInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ContentInputRepresentationNormalized, incoming: ContentInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ContentInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ContentInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Describes a new content version. To upload a file, provide the binary file in a multipart/form-data body part where name="fileData".
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ContentInputRepresentationNormalized {
+    /** Description of the file to be uploaded. */
+    description?: string;
+    /** Title of the file to be uploaded. */
+    title?: string;
+}
+/**
+ * Describes a new content version. To upload a file, provide the binary file in a multipart/form-data body part where name="fileData".
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ContentInputRepresentation {
+    description?: string;
+    title?: string;
+}

package/dist/es/es2018/types/src/generated/types/CustomLinkLayoutComponentRepresentation.d.ts

@@ -0,0 +1,37 @@
+import { AbstractRecordLayoutComponentRepresentation as AbstractRecordLayoutComponentRepresentation_AbstractRecordLayoutComponentRepresentation } from './AbstractRecordLayoutComponentRepresentation';
+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 = "040a9a1bdf5deffcadfe83297e7ddbb5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CustomLinkLayoutComponentRepresentation, existing: CustomLinkLayoutComponentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CustomLinkLayoutComponentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CustomLinkLayoutComponentRepresentationNormalized, incoming: CustomLinkLayoutComponentRepresentationNormalized): boolean;
+export declare function deepFreeze(input: CustomLinkLayoutComponentRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: CustomLinkLayoutComponentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Custom link record layout component.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CustomLinkLayoutComponentRepresentationNormalized extends AbstractRecordLayoutComponentRepresentation_AbstractRecordLayoutComponentRepresentation {
+    /** Custom Link behavior */
+    behavior: string;
+    /** Custom link URL */
+    customLinkUrl: string;
+    /** Label */
+    label: string;
+}
+/**
+ * Custom link record layout component.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CustomLinkLayoutComponentRepresentation extends AbstractRecordLayoutComponentRepresentation_AbstractRecordLayoutComponentRepresentation {
+    behavior: string;
+    customLinkUrl: string;
+    label: string;
+    componentType: 'CustomLink';
+}

package/dist/es/es2018/types/src/generated/types/DisplayLayoutAndMatchingInfoRepresentation.d.ts

@@ -0,0 +1,32 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DisplayLayoutAndMatchingInfoRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DisplayLayoutAndMatchingInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DisplayLayoutRepresentation.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 = "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 function deepFreeze(input: DisplayLayoutRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DisplayLayoutRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicateRecordErrorRepresentation.d.ts

@@ -0,0 +1,30 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DuplicateRecordErrorRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicateRecordErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicateResultInfoRepresentation.d.ts

@@ -0,0 +1,35 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DuplicateResultInfoRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicateResultInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicateRuleFilterItemRepresentation.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 = "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 function deepFreeze(input: DuplicateRuleFilterItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicateRuleFilterItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicateRuleFilterRepresentation.d.ts

@@ -0,0 +1,40 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DuplicateRuleFilterRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicateRuleFilterRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicateRuleRepresentation.d.ts

@@ -0,0 +1,56 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DuplicateRuleRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicateRuleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicatesConfigurationRepresentation.d.ts

@@ -0,0 +1,46 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DuplicatesConfigurationRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicatesConfigurationRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/DuplicatesRepresentation.d.ts

@@ -0,0 +1,40 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: DuplicatesRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DuplicatesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/EmptySpaceFormSubitemRepresentation.d.ts

@@ -0,0 +1,27 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: EmptySpaceFormSubitemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EmptySpaceFormSubitemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Empty Space Subitem.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmptySpaceFormSubitemRepresentationNormalized extends AbstractFormSubitemRepresentation_AbstractFormSubitemRepresentation {
+}
+/**
+ * Empty Space Subitem.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmptySpaceFormSubitemRepresentation extends AbstractFormSubitemRepresentation_AbstractFormSubitemRepresentation {
+}

package/dist/es/es2018/types/src/generated/types/EntityActionRepresentation.d.ts

@@ -0,0 +1,54 @@
+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 function deepFreeze(input: EntityActionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EntityActionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+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/dist/es/es2018/types/src/generated/types/ErrorBadRequestRecordAvatarBatchRepresentation.d.ts

@@ -0,0 +1,32 @@
+import { AbstractRecordAvatarBatchRepresentation as AbstractRecordAvatarBatchRepresentation_AbstractRecordAvatarBatchRepresentation } from './AbstractRecordAvatarBatchRepresentation';
+import { ErrorSingleRecordAvatarRepresentation as ErrorSingleRecordAvatarRepresentation_ErrorSingleRecordAvatarRepresentation } from './ErrorSingleRecordAvatarRepresentation';
+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 = 300000;
+export declare const VERSION = "e7fac2bfb5cdacc5e0f15c350f9ab8fe";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ErrorBadRequestRecordAvatarBatchRepresentation, existing: ErrorBadRequestRecordAvatarBatchRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ErrorBadRequestRecordAvatarBatchRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ErrorBadRequestRecordAvatarBatchRepresentationNormalized, incoming: ErrorBadRequestRecordAvatarBatchRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ErrorBadRequestRecordAvatarBatchRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ErrorBadRequestRecordAvatarBatchRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorBadRequestRecordAvatarBatchRepresentationNormalized extends AbstractRecordAvatarBatchRepresentation_AbstractRecordAvatarBatchRepresentation {
+    result: Array<ErrorSingleRecordAvatarRepresentation_ErrorSingleRecordAvatarRepresentation>;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorBadRequestRecordAvatarBatchRepresentation extends AbstractRecordAvatarBatchRepresentation_AbstractRecordAvatarBatchRepresentation {
+    result: Array<ErrorSingleRecordAvatarRepresentation_ErrorSingleRecordAvatarRepresentation>;
+    statusCode: 400;
+}

package/dist/es/es2018/types/src/generated/types/ErrorMessageRepresentation.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 = "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 function deepFreeze(input: ErrorMessageRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ErrorMessageRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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/dist/es/es2018/types/src/generated/types/ErrorRecordAvatarBatchRepresentation.d.ts

@@ -0,0 +1,32 @@
+import { AbstractRecordAvatarBatchRepresentation as AbstractRecordAvatarBatchRepresentation_AbstractRecordAvatarBatchRepresentation } from './AbstractRecordAvatarBatchRepresentation';
+import { ErrorSingleRecordAvatarRepresentation as ErrorSingleRecordAvatarRepresentation_ErrorSingleRecordAvatarRepresentation } from './ErrorSingleRecordAvatarRepresentation';
+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 = 300000;
+export declare const VERSION = "cbd48fd50d0db463fdff7b1834c22bed";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ErrorRecordAvatarBatchRepresentation, existing: ErrorRecordAvatarBatchRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ErrorRecordAvatarBatchRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ErrorRecordAvatarBatchRepresentationNormalized, incoming: ErrorRecordAvatarBatchRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ErrorRecordAvatarBatchRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ErrorRecordAvatarBatchRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorRecordAvatarBatchRepresentationNormalized extends AbstractRecordAvatarBatchRepresentation_AbstractRecordAvatarBatchRepresentation {
+    result: Array<ErrorSingleRecordAvatarRepresentation_ErrorSingleRecordAvatarRepresentation>;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorRecordAvatarBatchRepresentation extends AbstractRecordAvatarBatchRepresentation_AbstractRecordAvatarBatchRepresentation {
+    result: Array<ErrorSingleRecordAvatarRepresentation_ErrorSingleRecordAvatarRepresentation>;
+    statusCode: 404;
+}