@salesforce/lds-adapters-uiapi 1.100.2

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

@@ -0,0 +1,34 @@
+import { ObjectInfoDirectoryEntryRepresentation as ObjectInfoDirectoryEntryRepresentation_ObjectInfoDirectoryEntryRepresentation } from './ObjectInfoDirectoryEntryRepresentation';
+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 = "c040e955efdc64a496f748f728dcbe5f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ObjectInfoDirectoryRepresentation, existing: ObjectInfoDirectoryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ObjectInfoDirectoryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ObjectInfoDirectoryRepresentationNormalized, incoming: ObjectInfoDirectoryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ObjectInfoDirectoryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ObjectInfoDirectoryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Directory of objects that can be used within UI API end-points.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryRepresentationNormalized {
+    /** The object info entries corresponding to the objects that can be used within UI API. */
+    objects: {
+        [key: string]: ObjectInfoDirectoryEntryRepresentation_ObjectInfoDirectoryEntryRepresentation;
+    };
+}
+/**
+ * Directory of objects that can be used within UI API end-points.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryRepresentation {
+    objects: {
+        [key: string]: ObjectInfoDirectoryEntryRepresentation_ObjectInfoDirectoryEntryRepresentation;
+    };
+}

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

@@ -0,0 +1,121 @@
+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 = "ec9370a0cd56f4769fe9ec5cd942ff30";
+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 function deepFreeze(input: ObjectInfoRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ObjectInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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 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 master 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 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>;
+    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;
+    };
+    searchable: boolean;
+    themeInfo: ThemeInfoRepresentation_ThemeInfoRepresentation | null;
+    updateable: boolean;
+}

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

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

@@ -0,0 +1,45 @@
+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 = "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 function deepFreeze(input: OperationResponseRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: OperationResponseRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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;
+}

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

@@ -0,0 +1,40 @@
+import { AbstractPicklistValueAttributesRepresentation as AbstractPicklistValueAttributesRepresentation_AbstractPicklistValueAttributesRepresentation } from './AbstractPicklistValueAttributesRepresentation';
+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 = "950a3a962acbd2b128f937d4c055a9d6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OpportunityStagePicklistValueAttributesRepresentation, existing: OpportunityStagePicklistValueAttributesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OpportunityStagePicklistValueAttributesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OpportunityStagePicklistValueAttributesRepresentationNormalized, incoming: OpportunityStagePicklistValueAttributesRepresentationNormalized): boolean;
+export declare function deepFreeze(input: OpportunityStagePicklistValueAttributesRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: OpportunityStagePicklistValueAttributesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Additional picklist value attributes for opportunity stages.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OpportunityStagePicklistValueAttributesRepresentationNormalized extends AbstractPicklistValueAttributesRepresentation_AbstractPicklistValueAttributesRepresentation {
+    /** Indicates whether this opportunity stage value represents a closed opportunity. Multiple opportunity stage values can represent a closed opportunity. For more info, see the doc for the OpportunityStage standard object. */
+    closed: boolean;
+    /** The default percentage estimate of the confidence in closing a specific opportunity for this opportunity stage value. May be null if forecasting is not enabled for the org. For more info, see the doc for the OpportunityStage standard object. */
+    defaultProbability: number;
+    /** The default forecast category value for this opportunity stage value. May be null if forecasting is not enabled for the org. For more info, see the doc for the OpportunityStage standard object. */
+    forecastCategoryName: string;
+    /** Indicates whether this opportunity stage value represents a won opportunity. Multiple opportunity stage values can represent a won opportunity. For more info, see the doc for the OpportunityStage standard object. */
+    won: boolean;
+}
+/**
+ * Additional picklist value attributes for opportunity stages.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OpportunityStagePicklistValueAttributesRepresentation extends AbstractPicklistValueAttributesRepresentation_AbstractPicklistValueAttributesRepresentation {
+    closed: boolean;
+    defaultProbability: number;
+    forecastCategoryName: string;
+    won: boolean;
+    picklistAtrributesValueType: 'OpportunityStage';
+}

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

@@ -0,0 +1,43 @@
+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 = "a46012a5307f0a5fef78066970ed1a8a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PageReferenceInputRepresentation, existing: PageReferenceInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PageReferenceInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PageReferenceInputRepresentationNormalized, incoming: PageReferenceInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PageReferenceInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PageReferenceInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A page reference.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PageReferenceInputRepresentationNormalized {
+    /** The page reference's attributes. */
+    attributes: {
+        [key: string]: {};
+    };
+    /** The page reference's state. */
+    state: {
+        [key: string]: {};
+    };
+    /** The page reference's type. */
+    type: string;
+}
+/**
+ * A page reference.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PageReferenceInputRepresentation {
+    attributes: {
+        [key: string]: {};
+    };
+    state: {
+        [key: string]: {};
+    };
+    type: string;
+}

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

@@ -0,0 +1,43 @@
+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 VERSION = "a316b3bba367f54adc67d7552ed7d36d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PageReferenceRepresentation, existing: PageReferenceRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PageReferenceRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: PageReferenceRepresentationNormalized, incoming: PageReferenceRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PageReferenceRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PageReferenceRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A page reference.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PageReferenceRepresentationNormalized {
+    /** Values for each attribute specified by the PageDefinition. */
+    attributes: {
+        [key: string]: unknown;
+    };
+    /** Optional additional parameters that are not integral to the resolution of the reference. */
+    state: {
+        [key: string]: {};
+    };
+    /** API name of the corresponding PageDefinition. */
+    type: string;
+}
+/**
+ * A page reference.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PageReferenceRepresentation {
+    attributes: {
+        [key: string]: unknown;
+    };
+    state: {
+        [key: string]: {};
+    };
+    type: string;
+}

package/dist/types/src/generated/types/PerformActionInputRepresentation.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 VERSION = "9177642b1a4eb130c32252f383f15dcd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PerformActionInputRepresentation, existing: PerformActionInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PerformActionInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PerformActionInputRepresentationNormalized, incoming: PerformActionInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PerformActionInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PerformActionInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Description of an input for perform quick action.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PerformActionInputRepresentationNormalized {
+    /** Set allowSaveOnDuplicate param */
+    allowSaveOnDuplicate?: boolean;
+    /** Object API name. */
+    apiName: string;
+    /** The Context Id */
+    contextId?: string;
+    /** Field values. */
+    fields: {
+        [key: string]: string | number | null | boolean;
+    };
+}
+/**
+ * Description of an input for perform quick action.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PerformActionInputRepresentation {
+    allowSaveOnDuplicate?: boolean;
+    apiName: string;
+    contextId?: string;
+    fields: {
+        [key: string]: string | number | null | boolean;
+    };
+}

package/dist/types/src/generated/types/PhotoMetadataRepresentation.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 = "e84b9ffdeff97c411bd111f2a55cf6b6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PhotoMetadataRepresentation, existing: PhotoMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PhotoMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PhotoMetadataRepresentationNormalized, incoming: PhotoMetadataRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PhotoMetadataRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PhotoMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Represents an metadata of an avatar associated to a record.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PhotoMetadataRepresentationNormalized {
+    /** The ID of the response that this avatar is associated to. */
+    companyBluemasterId: string | null;
+    /** The ID of the bluemasterID that this avatar is associated to. */
+    responseId: string | null;
+}
+/**
+ * Represents an metadata of an avatar associated to a record.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PhotoMetadataRepresentation {
+    companyBluemasterId: string | null;
+    responseId: string | null;
+}

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

@@ -0,0 +1,54 @@
+import { keyBuilder as AbstractRecordAvatarRepresentation_keyBuilder, AbstractRecordAvatarRepresentation as AbstractRecordAvatarRepresentation_AbstractRecordAvatarRepresentation } from './AbstractRecordAvatarRepresentation';
+import { PhotoMetadataRepresentation as PhotoMetadataRepresentation_PhotoMetadataRepresentation } from './PhotoMetadataRepresentation';
+import { Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "34ffbf4219dfebb707bff609c2d5bf89";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: Parameters<typeof AbstractRecordAvatarRepresentation_keyBuilder>[1]): string;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: AbstractRecordAvatarRepresentation_AbstractRecordAvatarRepresentation): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: Parameters<typeof AbstractRecordAvatarRepresentation_keyBuilder>[1]): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: AbstractRecordAvatarRepresentation_AbstractRecordAvatarRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: PhotoRecordAvatarRepresentation, existing: PhotoRecordAvatarRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PhotoRecordAvatarRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PhotoRecordAvatarRepresentationNormalized, incoming: PhotoRecordAvatarRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PhotoRecordAvatarRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PhotoRecordAvatarRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Represents an avatar associated to a Record
+ *
+ * Keys:
+ *    recordId (string): recordId
+ */
+export interface PhotoRecordAvatarRepresentationNormalized extends AbstractRecordAvatarRepresentation_AbstractRecordAvatarRepresentation {
+    /** Retrieve the background color for the photo, if known, otherwise this will be null. */
+    backgroundColor: string | null;
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** Retrieve the height of the photo in pixels, if known, otherwise this will be null. */
+    height: number | null;
+    /** The photo metadata for the image */
+    photoMetadata: PhotoMetadataRepresentation_PhotoMetadataRepresentation;
+    /** Retrieve the URL location of the photo. */
+    photoUrl: string;
+    /** The provider of the image */
+    provider: string | null;
+    /** Retrieve the width of the photo in pixels, if known, otherwise this will be null. */
+    width: number | null;
+}
+/**
+ * Represents an avatar associated to a Record
+ *
+ * Keys:
+ *    recordId (string): recordId
+ */
+export interface PhotoRecordAvatarRepresentation extends AbstractRecordAvatarRepresentation_AbstractRecordAvatarRepresentation {
+    backgroundColor: string | null;
+    eTag: string;
+    height: number | null;
+    photoMetadata: PhotoMetadataRepresentation_PhotoMetadataRepresentation;
+    photoUrl: string;
+    provider: string | null;
+    width: number | null;
+    type: 'Photo';
+}

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

@@ -0,0 +1,42 @@
+import { AbstractPicklistValueAttributesRepresentation as AbstractPicklistValueAttributesRepresentation_AbstractPicklistValueAttributesRepresentation } from './AbstractPicklistValueAttributesRepresentation';
+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';
+import { LeadStatusPicklistValueAttributesRepresentation as LeadStatusPicklistValueAttributesRepresentation_LeadStatusPicklistValueAttributesRepresentation } from './LeadStatusPicklistValueAttributesRepresentation';
+import { CaseStatusPicklistValueAttributesRepresentation as CaseStatusPicklistValueAttributesRepresentation_CaseStatusPicklistValueAttributesRepresentation } from './CaseStatusPicklistValueAttributesRepresentation';
+import { OpportunityStagePicklistValueAttributesRepresentation as OpportunityStagePicklistValueAttributesRepresentation_OpportunityStagePicklistValueAttributesRepresentation } from './OpportunityStagePicklistValueAttributesRepresentation';
+export declare const VERSION = "9e2a16a80378487f557124c771201cf9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PicklistValueRepresentation, existing: PicklistValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PicklistValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PicklistValueRepresentationNormalized, incoming: PicklistValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PicklistValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PicklistValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A single picklist value.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PicklistValueRepresentationNormalized {
+    /** For picklist values representing the status of a lead or an opportunity's stage, this value will contain additional attributes to help consumers understand the meaning of the value. Depending on the PicklistValueType this could be populated with information about a LeadStatus or an OpportunityStage. For any other PicklistValueType this property will be null. */
+    attributes: AbstractPicklistValueAttributesRepresentation_AbstractPicklistValueAttributesRepresentation | null;
+    /** The displayable value of the picklist to use in a UI. */
+    label: string;
+    /** If this picklist is a dependent picklist, this will be the controlling value indexes for which this value is valid. If this is an independent picklist, this list will be empty. */
+    validFor: Array<number>;
+    /** The value of the picklist to use in the API. */
+    value: string;
+}
+/**
+ * A single picklist value.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PicklistValueRepresentation {
+    attributes: LeadStatusPicklistValueAttributesRepresentation_LeadStatusPicklistValueAttributesRepresentation | CaseStatusPicklistValueAttributesRepresentation_CaseStatusPicklistValueAttributesRepresentation | OpportunityStagePicklistValueAttributesRepresentation_OpportunityStagePicklistValueAttributesRepresentation | null;
+    label: string;
+    validFor: Array<number>;
+    value: string;
+}

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

@@ -0,0 +1,47 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, PathSelection as $64$luvio_engine_PathSelection, StoreLink as $64$luvio_engine_StoreLink, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+import { PicklistValuesRepresentation as PicklistValuesRepresentation_PicklistValuesRepresentation } from './PicklistValuesRepresentation';
+export declare const TTL = 300000;
+export declare const VERSION = "ec03b0f6da287c949d1ccaa904ddbfd3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PicklistValuesCollectionRepresentation, existing: PicklistValuesCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PicklistValuesCollectionRepresentationNormalized;
+export interface DynamicIngestParams {
+    picklistFieldValues: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: PicklistValuesCollectionRepresentation, existing: PicklistValuesCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => PicklistValuesCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    picklistFieldValues?: $64$luvio_engine_PathSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PicklistValuesCollectionRepresentationNormalized, incoming: PicklistValuesCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: PicklistValuesCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: PicklistValuesCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Picklist values for multiple picklist fields and scoped to a record type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PicklistValuesCollectionRepresentationNormalized {
+    /** ETag like field, readOnly, handy while caching. */
+    eTag: string;
+    /** This contains a map of fieldName to PicklistValuesRepresentation for all picklist fields. There would be no entry for non picklistFields in this map */
+    picklistFieldValues: {
+        [key: string]: $64$luvio_engine_StoreLink;
+    };
+}
+/**
+ * Picklist values for multiple picklist fields and scoped to a record type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PicklistValuesCollectionRepresentation {
+    eTag: string;
+    picklistFieldValues: {
+        [key: string]: PicklistValuesRepresentation_PicklistValuesRepresentation;
+    };
+}