@salesforce/lds-adapters-industries-rule-builder 0.131.0

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

@@ -0,0 +1,59 @@
+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 = "0b68a1c619ee716a2a03658c6fc52613";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ResourceOutputRepresentation, existing: ResourceOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ResourceOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ResourceOutputRepresentationNormalized, incoming: ResourceOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ResourceOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ResourceOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output represenation of a Calculation Procedure Version Definition
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ResourceOutputRepresentationNormalized {
+    /** ApiName of the Resource */
+    apiName?: string;
+    /** Name of Calculation Matrix used in Resource */
+    calculationMatrixName?: string;
+    /** DataType of the Resource */
+    dataType?: string;
+    /** Default Value of the Resource */
+    defaultValue?: string;
+    /** DisplayName of the Resource */
+    displayName?: string;
+    /** Id of the Resource */
+    id?: string;
+    /** Whether Resource is editable */
+    isEditable?: boolean;
+    /** Whether Resource is User Defined */
+    isUserDefined?: boolean;
+    /** Name of the Resource */
+    name?: string;
+    /** Precision of the Resource */
+    precision?: number;
+    /** Display Order in Ui for the Resource */
+    uiDisplayOrder?: number;
+}
+/**
+ * Output represenation of a Calculation Procedure Version Definition
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ResourceOutputRepresentation {
+    apiName?: string;
+    calculationMatrixName?: string;
+    dataType?: string;
+    defaultValue?: string;
+    displayName?: string;
+    id?: string;
+    isEditable?: boolean;
+    isUserDefined?: boolean;
+    name?: string;
+    precision?: number;
+    uiDisplayOrder?: number;
+}

package/dist/es/es2018/types/src/generated/types/RootStepListInputRepresentation.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 = "5525f054ae2783e6a4093f07c7facb00";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: RootStepListInputRepresentation, existing: RootStepListInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): RootStepListInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: RootStepListInputRepresentationNormalized, incoming: RootStepListInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: RootStepListInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: RootStepListInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for Root Steps of Calculation Procedure version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RootStepListInputRepresentationNormalized {
+    /** Starting Steps for Calculation Procedure Version */
+    steps: Array<string>;
+}
+/**
+ * Input representation for Root Steps of Calculation Procedure version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RootStepListInputRepresentation {
+    steps: Array<string>;
+}

package/dist/es/es2018/types/src/generated/types/RootStepListOutputRepresentation.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 = "c372f7b3dd9312f1395b1007924ff782";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: RootStepListOutputRepresentation, existing: RootStepListOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): RootStepListOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: RootStepListOutputRepresentationNormalized, incoming: RootStepListOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: RootStepListOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: RootStepListOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation for Root Steps of Calculation Procedure version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RootStepListOutputRepresentationNormalized {
+    /** Starting steps of Calculation Procedure Version */
+    steps?: Array<string>;
+}
+/**
+ * Output representation for Root Steps of Calculation Procedure version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RootStepListOutputRepresentation {
+    steps?: Array<string>;
+}

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

@@ -0,0 +1,35 @@
+import { ErrorResultRepresentation as ErrorResultRepresentation_ErrorResultRepresentation } from './ErrorResultRepresentation';
+import { VariableMapOutputRepresentation as VariableMapOutputRepresentation_VariableMapOutputRepresentation } from './VariableMapOutputRepresentation';
+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 = "91ccaf4054127d978cd3136198480798";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: RuleResultRepresentation, existing: RuleResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): RuleResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: RuleResultRepresentationNormalized, incoming: RuleResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: RuleResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: RuleResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Rule output representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RuleResultRepresentationNormalized {
+    /** Error details */
+    error?: ErrorResultRepresentation_ErrorResultRepresentation;
+    results: VariableMapOutputRepresentation_VariableMapOutputRepresentation;
+    variables?: VariableMapOutputRepresentation_VariableMapOutputRepresentation;
+}
+/**
+ * Rule output representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface RuleResultRepresentation {
+    error?: ErrorResultRepresentation_ErrorResultRepresentation;
+    results: VariableMapOutputRepresentation_VariableMapOutputRepresentation;
+    variables?: VariableMapOutputRepresentation_VariableMapOutputRepresentation;
+}

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

@@ -0,0 +1,29 @@
+import { SimulationVersionInfoInputRepresentation as SimulationVersionInfoInputRepresentation_SimulationVersionInfoInputRepresentation } from './SimulationVersionInfoInputRepresentation';
+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 = "5aacc7c265349219633690067361f38e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationConfigInputRepresentation, existing: SimulationConfigInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationConfigInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationConfigInputRepresentationNormalized, incoming: SimulationConfigInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationConfigInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationConfigInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for config data in rule simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationConfigInputRepresentationNormalized {
+    versionInfo: SimulationVersionInfoInputRepresentation_SimulationVersionInfoInputRepresentation;
+}
+/**
+ * Input representation for config data in rule simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationConfigInputRepresentation {
+    versionInfo: SimulationVersionInfoInputRepresentation_SimulationVersionInfoInputRepresentation;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "0d9f776430ff9f88886bca838ad6d29b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationErrorOutputRepresentation, existing: SimulationErrorOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationErrorOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationErrorOutputRepresentationNormalized, incoming: SimulationErrorOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationErrorOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationErrorOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output Representation of Calculation Procedure Execution
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationErrorOutputRepresentationNormalized {
+    /** store the error code */
+    errorCode: string;
+    /** stores error msg in detail */
+    errorDetails: string;
+    /** stores error msg */
+    errorMsg: string;
+}
+/**
+ * Output Representation of Calculation Procedure Execution
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationErrorOutputRepresentation {
+    errorCode: string;
+    errorDetails: string;
+    errorMsg: string;
+}

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

@@ -0,0 +1,33 @@
+import { SimulationConfigInputRepresentation as SimulationConfigInputRepresentation_SimulationConfigInputRepresentation } from './SimulationConfigInputRepresentation';
+import { SimulationVariablesInputRepresentation as SimulationVariablesInputRepresentation_SimulationVariablesInputRepresentation } from './SimulationVariablesInputRepresentation';
+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 = "c9cc5c879cf8b7bbe411a6beeb77269f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationEvalServiceInputRepresentation, existing: SimulationEvalServiceInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationEvalServiceInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationEvalServiceInputRepresentationNormalized, incoming: SimulationEvalServiceInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationEvalServiceInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationEvalServiceInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for Rule Simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationEvalServiceInputRepresentationNormalized {
+    /** This property will contains data related to rule (metadata) */
+    config: SimulationConfigInputRepresentation_SimulationConfigInputRepresentation;
+    input: SimulationVariablesInputRepresentation_SimulationVariablesInputRepresentation;
+}
+/**
+ * Input representation for Rule Simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationEvalServiceInputRepresentation {
+    config: SimulationConfigInputRepresentation_SimulationConfigInputRepresentation;
+    input: SimulationVariablesInputRepresentation_SimulationVariablesInputRepresentation;
+}

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

@@ -0,0 +1,54 @@
+import { SimulationErrorOutputRepresentation as SimulationErrorOutputRepresentation_SimulationErrorOutputRepresentation } from './SimulationErrorOutputRepresentation';
+import { SimulationVariableOutputRepresentation as SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation } from './SimulationVariableOutputRepresentation';
+import { SimulationStepResultOutputRepresentation as SimulationStepResultOutputRepresentation_SimulationStepResultOutputRepresentation } from './SimulationStepResultOutputRepresentation';
+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, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "b6e6be6071f0e62f16a15d9d2bfcab9e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    id: string;
+}
+export type SimulationEvalServiceOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialSimulationEvalServiceOutputRepresentationNormalizedKeyMetadata = 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): SimulationEvalServiceOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: SimulationEvalServiceOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: SimulationEvalServiceOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: SimulationEvalServiceOutputRepresentation, existing: SimulationEvalServiceOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationEvalServiceOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: SimulationEvalServiceOutputRepresentationNormalized, incoming: SimulationEvalServiceOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationEvalServiceOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationEvalServiceOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output Representation for rule simulation
+ *
+ * Keys:
+ *    id (string): executionId
+ */
+export interface SimulationEvalServiceOutputRepresentationNormalized {
+    /** stores error occur in execution of rule */
+    error?: SimulationErrorOutputRepresentation_SimulationErrorOutputRepresentation;
+    /** Stores execution id of rule simulation */
+    executionId: string;
+    /** stores list of overall output from simulation */
+    simulationResults?: Array<SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation>;
+    /** stores a map with key as step id and value as it's details */
+    simulationStepResults?: {
+        [key: string]: $64$luvio_engine_StoreLink;
+    };
+}
+/**
+ * Output Representation for rule simulation
+ *
+ * Keys:
+ *    id (string): executionId
+ */
+export interface SimulationEvalServiceOutputRepresentation {
+    error?: SimulationErrorOutputRepresentation_SimulationErrorOutputRepresentation;
+    executionId: string;
+    simulationResults?: Array<SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation>;
+    simulationStepResults?: {
+        [key: string]: SimulationStepResultOutputRepresentation_SimulationStepResultOutputRepresentation;
+    };
+}

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

@@ -0,0 +1,29 @@
+import { SimulationEvalServiceInputRepresentation as SimulationEvalServiceInputRepresentation_SimulationEvalServiceInputRepresentation } from './SimulationEvalServiceInputRepresentation';
+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 = "00fa8e3bcd590900d6383f97cf881ff5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationEvalServiceWrapperInputRepresentation, existing: SimulationEvalServiceWrapperInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationEvalServiceWrapperInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationEvalServiceWrapperInputRepresentationNormalized, incoming: SimulationEvalServiceWrapperInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationEvalServiceWrapperInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationEvalServiceWrapperInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * wrapper of SimulationEvalServiceInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationEvalServiceWrapperInputRepresentationNormalized {
+    simulationInput: SimulationEvalServiceInputRepresentation_SimulationEvalServiceInputRepresentation;
+}
+/**
+ * wrapper of SimulationEvalServiceInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationEvalServiceWrapperInputRepresentation {
+    simulationInput: SimulationEvalServiceInputRepresentation_SimulationEvalServiceInputRepresentation;
+}

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

@@ -0,0 +1,44 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "b9b91e109c5b8e47babfb20fc9a1308d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationInputVariableBasicRepresentation, existing: SimulationInputVariableBasicRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationInputVariableBasicRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationInputVariableBasicRepresentationNormalized, incoming: SimulationInputVariableBasicRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationInputVariableBasicRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationInputVariableBasicRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output represenation of Simulation Input Variable Basic Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationInputVariableBasicRepresentationNormalized {
+    /** SimulationInputVariablesDetails api SimulationInputVariables apiName */
+    apiName: string;
+    /** SimulationInputVariablesDetails api SimulationInputVariables dataType */
+    dataType: string;
+    /** SimulationInputVariablesDetails api SimulationInputVariables defaultValue */
+    defaultValue?: string;
+    /** SimulationInputVariablesDetails api SimulationInputVariables  lastSimulatedValue */
+    lastSimulatedValue?: string;
+    /** SimulationInputVariablesDetails api SimulationInputVariables name */
+    name: string;
+    /** SimulationInputVariablesDetails api SimulationInputVariables  precision */
+    precision?: string;
+}
+/**
+ * Output represenation of Simulation Input Variable Basic Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationInputVariableBasicRepresentation {
+    apiName: string;
+    dataType: string;
+    defaultValue?: string;
+    lastSimulatedValue?: string;
+    name: string;
+    precision?: string;
+}

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

@@ -0,0 +1,40 @@
+import { SimulationInputVariableBasicRepresentation as SimulationInputVariableBasicRepresentation_SimulationInputVariableBasicRepresentation } from './SimulationInputVariableBasicRepresentation';
+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 = 1000;
+export declare const VERSION = "77b2279d846bfa05b858a22c37197dde";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationInputVariablesResultListRepresentation, existing: SimulationInputVariablesResultListRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationInputVariablesResultListRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: SimulationInputVariablesResultListRepresentationNormalized, incoming: SimulationInputVariablesResultListRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationInputVariablesResultListRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationInputVariablesResultListRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output represenation of Simulation Input Variable Details Get
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationInputVariablesResultListRepresentationNormalized {
+    /** API response code for failure case */
+    code: string;
+    /** List of inputVariables */
+    inputVariables?: Array<SimulationInputVariableBasicRepresentation_SimulationInputVariableBasicRepresentation>;
+    /** States whether API is successful or not */
+    isSuccess: boolean;
+    /** API response message for failure case */
+    message?: string;
+}
+/**
+ * Output represenation of Simulation Input Variable Details Get
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationInputVariablesResultListRepresentation {
+    code: string;
+    inputVariables?: Array<SimulationInputVariableBasicRepresentation_SimulationInputVariableBasicRepresentation>;
+    isSuccess: boolean;
+    message?: string;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "3d141c4df15068a708dec8f104473333";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationStepAdditionalInfoOutputRepresentation, existing: SimulationStepAdditionalInfoOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationStepAdditionalInfoOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationStepAdditionalInfoOutputRepresentationNormalized, incoming: SimulationStepAdditionalInfoOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationStepAdditionalInfoOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationStepAdditionalInfoOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output Representation of step additional info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationStepAdditionalInfoOutputRepresentationNormalized {
+    /** stores stype of step (CalculationProcedure or DecisionMatrix) */
+    stepType: string;
+    /** store name of the step */
+    versionName: string;
+    /** stores version number of the step */
+    versionNumber: string;
+}
+/**
+ * Output Representation of step additional info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationStepAdditionalInfoOutputRepresentation {
+    stepType: string;
+    versionName: string;
+    versionNumber: string;
+}

package/dist/es/es2018/types/src/generated/types/SimulationStepExplainabilityMessageOutputRepresentation.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, 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 = 1000;
+export declare const VERSION = "44101e11889c792aaabc50fc90848bc2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationStepExplainabilityMessageOutputRepresentation, existing: SimulationStepExplainabilityMessageOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationStepExplainabilityMessageOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: SimulationStepExplainabilityMessageOutputRepresentationNormalized, incoming: SimulationStepExplainabilityMessageOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationStepExplainabilityMessageOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationStepExplainabilityMessageOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of explainability message for simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationStepExplainabilityMessageOutputRepresentationNormalized {
+    /** stores explainability message of the step */
+    message: string;
+    /** stores explainability condition details of the step */
+    showConditionDetails: boolean;
+    /** stores explainability executed path message of the step */
+    showOnlyExecutedPathMessage: boolean;
+    /** stores explainability template id of the step */
+    templateId: string;
+}
+/**
+ * Output representation of explainability message for simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationStepExplainabilityMessageOutputRepresentation {
+    message: string;
+    showConditionDetails: boolean;
+    showOnlyExecutedPathMessage: boolean;
+    templateId: string;
+}

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

@@ -0,0 +1,49 @@
+import { SimulationStepAdditionalInfoOutputRepresentation as SimulationStepAdditionalInfoOutputRepresentation_SimulationStepAdditionalInfoOutputRepresentation } from './SimulationStepAdditionalInfoOutputRepresentation';
+import { SimulationStepExplainabilityMessageOutputRepresentation as SimulationStepExplainabilityMessageOutputRepresentation_SimulationStepExplainabilityMessageOutputRepresentation } from './SimulationStepExplainabilityMessageOutputRepresentation';
+import { SimulationVariableOutputRepresentation as SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation } from './SimulationVariableOutputRepresentation';
+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, StoreLink as $64$luvio_engine_StoreLink, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 1000;
+export declare const VERSION = "e7784eea6ef330fca47c662e2782c2f2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationStepResultOutputRepresentation, existing: SimulationStepResultOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationStepResultOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: SimulationStepResultOutputRepresentationNormalized, incoming: SimulationStepResultOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationStepResultOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationStepResultOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of step execution in rule
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationStepResultOutputRepresentationNormalized {
+    /** stores additional info about the step */
+    additionalInfo?: SimulationStepAdditionalInfoOutputRepresentation_SimulationStepAdditionalInfoOutputRepresentation;
+    /** stores explainability message for the step */
+    explainabilityMessage?: $64$luvio_engine_StoreLink;
+    /** stores step errors occurred in the step */
+    stepErrors?: {
+        [key: string]: Array<string>;
+    };
+    /** stores input variables of step */
+    stepInputs: Array<SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation>;
+    /** stores output variables as list of step */
+    stepResults: Array<SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation>;
+}
+/**
+ * Output representation of step execution in rule
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationStepResultOutputRepresentation {
+    additionalInfo?: SimulationStepAdditionalInfoOutputRepresentation_SimulationStepAdditionalInfoOutputRepresentation;
+    explainabilityMessage?: SimulationStepExplainabilityMessageOutputRepresentation_SimulationStepExplainabilityMessageOutputRepresentation;
+    stepErrors?: {
+        [key: string]: Array<string>;
+    };
+    stepInputs: Array<SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation>;
+    stepResults: Array<SimulationVariableOutputRepresentation_SimulationVariableOutputRepresentation>;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "66469e1b2190a0f7ec55359175a6f7db";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationVariableInputRepresentation, existing: SimulationVariableInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationVariableInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationVariableInputRepresentationNormalized, incoming: SimulationVariableInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationVariableInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationVariableInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input Representating the a input variable for rule simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationVariableInputRepresentationNormalized {
+    /** datatype for this variable */
+    datatype: string;
+    /** name of variable */
+    name: string;
+    /** string value of variable */
+    value: string;
+}
+/**
+ * Input Representating the a input variable for rule simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationVariableInputRepresentation {
+    datatype: string;
+    name: string;
+    value: string;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "68024a42f48ec26d0867788c6d6d74a2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SimulationVariableOutputRepresentation, existing: SimulationVariableOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SimulationVariableOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SimulationVariableOutputRepresentationNormalized, incoming: SimulationVariableOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SimulationVariableOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SimulationVariableOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of variables for simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationVariableOutputRepresentationNormalized {
+    /** stores datatype of variable */
+    datatype: string;
+    /** stores name of variable */
+    name: string;
+    /** stores value of variable */
+    value: string;
+}
+/**
+ * Output representation of variables for simulation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SimulationVariableOutputRepresentation {
+    datatype: string;
+    name: string;
+    value: string;
+}