@salesforce/lds-adapters-platform-cdp-machine-learning 1.311.1 → 1.312.0

package/dist/es/es2018/platform-cdp-machine-learning.js

@@ -5325,38 +5325,27 @@ function validate$3(obj, path = 'CdpMlAggregatePredictionRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
+var DiscriminatorValues$1;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Regression"] = "Regression";
+    DiscriminatorValues["BinaryClassification"] = "BinaryClassification";
+    DiscriminatorValues["Generic"] = "Generic";
+})(DiscriminatorValues$1 || (DiscriminatorValues$1 = {}));
+
+var DiscriminatorValues;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Success"] = "Success";
+    DiscriminatorValues["Error"] = "Error";
+})(DiscriminatorValues || (DiscriminatorValues = {}));
 function validate$2(obj, path = 'CdpMlPredictionBaseRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        if (obj.status !== undefined) {
-            const obj_status = obj.status;
-            const path_status = path + '.status';
-            let obj_status_union0 = null;
-            const obj_status_union0_error = (() => {
-                if (typeof obj_status !== 'string') {
-                    return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
-                }
-            })();
-            if (obj_status_union0_error != null) {
-                obj_status_union0 = obj_status_union0_error.message;
-            }
-            let obj_status_union1 = null;
-            const obj_status_union1_error = (() => {
-                if (obj_status !== null) {
-                    return new TypeError('Expected "null" but received "' + typeof obj_status + '" (at "' + path_status + '")');
-                }
-            })();
-            if (obj_status_union1_error != null) {
-                obj_status_union1 = obj_status_union1_error.message;
-            }
-            if (obj_status_union0 && obj_status_union1) {
-                let message = 'Object doesn\'t match union (at "' + path_status + '")';
-                message += '\n' + obj_status_union0.split('\n').map((line) => '\t' + line).join('\n');
-                message += '\n' + obj_status_union1.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
@@ -5428,7 +5417,7 @@ function validate$1(obj, path = 'CdpMlPredictSettingsInputRepresentation') {
 }
 
 const TTL = 1000;
-const VERSION = "53acf0a695382123e58156e703232cb5";
+const VERSION = "db91153fa53c91ab59ff4d2ae3000258";
 function validate(obj, path = 'CdpMlPredictResultRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -5481,15 +5470,13 @@ function validate(obj, path = 'CdpMlPredictResultRepresentation') {
                 }
             }
         }
-        if (obj.settings !== undefined) {
-            const obj_settings = obj.settings;
-            const path_settings = path + '.settings';
-            const referencepath_settingsValidationError = validate$1(obj_settings, path_settings);
-            if (referencepath_settingsValidationError !== null) {
-                let message = 'Object doesn\'t match CdpMlPredictSettingsInputRepresentation (at "' + path_settings + '")\n';
-                message += referencepath_settingsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
+        const obj_settings = obj.settings;
+        const path_settings = path + '.settings';
+        const referencepath_settingsValidationError = validate$1(obj_settings, path_settings);
+        if (referencepath_settingsValidationError !== null) {
+            let message = 'Object doesn\'t match CdpMlPredictSettingsInputRepresentation (at "' + path_settings + '")\n';
+            message += referencepath_settingsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
         }
     })();
     return v_error === undefined ? null : v_error;

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

@@ -0,0 +1,33 @@
+import { CdpMlPredictionSuccessBaseRepresentation as CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation } from './CdpMlPredictionSuccessBaseRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "d7942f3dfad1625fd2e3fb2d7ba81498";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlBinaryClassificationPredictionResultRepresentation, existing: CdpMlBinaryClassificationPredictionResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlBinaryClassificationPredictionResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlBinaryClassificationPredictionResultRepresentationNormalized, incoming: CdpMlBinaryClassificationPredictionResultRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlBinaryClassificationPredictionResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for a successful binary classification prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlBinaryClassificationPredictionResultRepresentationNormalized extends CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation {
+    /** Predicted value */
+    predictedValue: number;
+    /** Threshold used */
+    threshold: number;
+}
+/**
+ * Representation for a successful binary classification prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlBinaryClassificationPredictionResultRepresentation extends CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation {
+    predictedValue: number;
+    threshold: number;
+    type: 'BinaryClassification';
+}

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

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "52b36f94dc6725557282372c9912e7cd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlFieldValueRepresentation, existing: CdpMlFieldValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlFieldValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlFieldValueRepresentationNormalized, incoming: CdpMlFieldValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlFieldValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Cdp Ml Field Value
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlFieldValueRepresentationNormalized {
+    /** Count of the value */
+    count: number;
+    /** Field value */
+    value: string;
+}
+/**
+ * Cdp Ml Field Value
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlFieldValueRepresentation {
+    count: number;
+    value: string;
+}

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

@@ -0,0 +1,34 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "36c5eb04623915c81d60b731bde083fe";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlGenericPredictionOutputValueRepresentation, existing: CdpMlGenericPredictionOutputValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlGenericPredictionOutputValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlGenericPredictionOutputValueRepresentationNormalized, incoming: CdpMlGenericPredictionOutputValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlGenericPredictionOutputValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for a successful generic prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlGenericPredictionOutputValueRepresentationNormalized {
+    /** Name */
+    name: string;
+    /** Output Data type */
+    type: string;
+    /** Output Value */
+    value: {};
+}
+/**
+ * Representation for a successful generic prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlGenericPredictionOutputValueRepresentation {
+    name: string;
+    type: string;
+    value: {};
+}

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

@@ -0,0 +1,31 @@
+import { CdpMlPredictionSuccessBaseRepresentation as CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation } from './CdpMlPredictionSuccessBaseRepresentation';
+import { CdpMlGenericPredictionOutputValueRepresentation as CdpMlGenericPredictionOutputValueRepresentation_CdpMlGenericPredictionOutputValueRepresentation } from './CdpMlGenericPredictionOutputValueRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "5e7012033c0bfc12c74b010090ffd1a4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlGenericPredictionResultRepresentation, existing: CdpMlGenericPredictionResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlGenericPredictionResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlGenericPredictionResultRepresentationNormalized, incoming: CdpMlGenericPredictionResultRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlGenericPredictionResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for a successful generic prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlGenericPredictionResultRepresentationNormalized extends CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation {
+    /** Name */
+    outputs: Array<CdpMlGenericPredictionOutputValueRepresentation_CdpMlGenericPredictionOutputValueRepresentation>;
+}
+/**
+ * Representation for a successful generic prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlGenericPredictionResultRepresentation extends CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation {
+    outputs: Array<CdpMlGenericPredictionOutputValueRepresentation_CdpMlGenericPredictionOutputValueRepresentation>;
+    type: 'Generic';
+}

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

@@ -3,8 +3,10 @@ import { CdpAssetReferenceRepresentation as CdpAssetReferenceRepresentation_CdpA
 import { CdpMlPredictionBaseRepresentation as CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation } from './CdpMlPredictionBaseRepresentation';
 import { CdpMlPredictSettingsInputRepresentation as CdpMlPredictSettingsInputRepresentation_CdpMlPredictSettingsInputRepresentation } from './CdpMlPredictSettingsInputRepresentation';
 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';
+import { CdpMlPredictionSuccessBaseRepresentation as CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation } from './CdpMlPredictionSuccessBaseRepresentation';
+import { CdpMlPredictionErrorRepresentation as CdpMlPredictionErrorRepresentation_CdpMlPredictionErrorRepresentation } from './CdpMlPredictionErrorRepresentation';
 export declare const TTL = 1000;
-export declare const VERSION = "53acf0a695382123e58156e703232cb5";
+export declare const VERSION = "db91153fa53c91ab59ff4d2ae3000258";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export interface KeyParams extends $64$luvio_engine_KeyMetadata {
@@ -35,9 +37,9 @@ export interface CdpMlPredictResultRepresentationNormalized {
     /** Prediction Type */
     predictionType: string;
     /** A list of prediction results */
-    predictions?: Array<$64$luvio_engine_StoreLink>;
+    predictions?: Array<CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation>;
     /** Settings used for the prediction */
-    settings?: $64$luvio_engine_StoreLink;
+    settings: $64$luvio_engine_StoreLink;
 }
 /**
  * Cdp Ml Prediction result representation
@@ -49,6 +51,6 @@ export interface CdpMlPredictResultRepresentation {
     aggregatePredictions?: Array<CdpMlAggregatePredictionRepresentation_CdpMlAggregatePredictionRepresentation>;
     model: CdpAssetReferenceRepresentation_CdpAssetReferenceRepresentation;
     predictionType: string;
-    predictions?: Array<CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation>;
-    settings?: CdpMlPredictSettingsInputRepresentation_CdpMlPredictSettingsInputRepresentation;
+    predictions?: Array<CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation | CdpMlPredictionErrorRepresentation_CdpMlPredictionErrorRepresentation>;
+    settings: CdpMlPredictSettingsInputRepresentation_CdpMlPredictSettingsInputRepresentation;
 }

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

@@ -1,12 +1,17 @@
-import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
-export declare const TTL = 1000;
-export declare const VERSION = "c99d4c0679fe8e8779d08458cac72034";
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentUnionSelection as $64$luvio_engine_FragmentUnionSelection, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare enum DiscriminatorValues {
+    Success = "Success",
+    Error = "Error"
+}
+export declare const VERSION = "150f60aeac8cde473d8e16cd52f1f0b7";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
 export declare function normalize(input: CdpMlPredictionBaseRepresentation, existing: CdpMlPredictionBaseRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionBaseRepresentationNormalized;
-export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare const selectChildren: () => $64$luvio_engine_FragmentUnionSelection;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
 export declare function equals(existing: CdpMlPredictionBaseRepresentationNormalized, incoming: CdpMlPredictionBaseRepresentationNormalized): boolean;
 export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare const discriminatorIngest: $64$luvio_engine_ResourceIngest;
 export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionBaseRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
 /**
  * Base representation for a prediction result
@@ -16,7 +21,7 @@ export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableSto
  */
 export interface CdpMlPredictionBaseRepresentationNormalized {
     /** prediction status */
-    status?: string | null;
+    status: string;
 }
 /**
  * Base representation for a prediction result
@@ -25,5 +30,5 @@ export interface CdpMlPredictionBaseRepresentationNormalized {
  *    (none)
  */
 export interface CdpMlPredictionBaseRepresentation {
-    status?: string | null;
+    status: string;
 }

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

@@ -0,0 +1,32 @@
+import { CdpMlPredictionContributionFieldRepresentation as CdpMlPredictionContributionFieldRepresentation_CdpMlPredictionContributionFieldRepresentation } from './CdpMlPredictionContributionFieldRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ae3c9ebdbac9d1ad93d3dfd0d3f73b83";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlPredictionContributionBaseRepresentation, existing: CdpMlPredictionContributionBaseRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionContributionBaseRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlPredictionContributionBaseRepresentationNormalized, incoming: CdpMlPredictionContributionBaseRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionContributionBaseRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Base representation for a Prediction Contribution
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionContributionBaseRepresentationNormalized {
+    /** List of field and values that have the same contribution value */
+    fields: Array<CdpMlPredictionContributionFieldRepresentation_CdpMlPredictionContributionFieldRepresentation>;
+    /** Contribution value */
+    value: number;
+}
+/**
+ * Base representation for a Prediction Contribution
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionContributionBaseRepresentation {
+    fields: Array<CdpMlPredictionContributionFieldRepresentation_CdpMlPredictionContributionFieldRepresentation>;
+    value: number;
+}

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

@@ -0,0 +1,34 @@
+import { CdpMlPredictionFieldCustomTextRepresentation as CdpMlPredictionFieldCustomTextRepresentation_CdpMlPredictionFieldCustomTextRepresentation } from './CdpMlPredictionFieldCustomTextRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "06fa1155071dedd86272aef35857bf3a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlPredictionContributionFieldRepresentation, existing: CdpMlPredictionContributionFieldRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionContributionFieldRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlPredictionContributionFieldRepresentationNormalized, incoming: CdpMlPredictionContributionFieldRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionContributionFieldRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Cdp Ml Prediction Contribution Field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionContributionFieldRepresentationNormalized {
+    customText: CdpMlPredictionFieldCustomTextRepresentation_CdpMlPredictionFieldCustomTextRepresentation;
+    /** Input value used for this field */
+    inputValue: string;
+    /** Model output value for the field (i.e. recommended value to improve prediction) */
+    prescribedValue: string;
+}
+/**
+ * Cdp Ml Prediction Contribution Field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionContributionFieldRepresentation {
+    customText: CdpMlPredictionFieldCustomTextRepresentation_CdpMlPredictionFieldCustomTextRepresentation;
+    inputValue: string;
+    prescribedValue: string;
+}

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

@@ -0,0 +1,33 @@
+import { CdpMlPredictionBaseRepresentation as CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation } from './CdpMlPredictionBaseRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ed179e110e66d8254956a4b1c6fb0e56";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlPredictionErrorRepresentation, existing: CdpMlPredictionErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlPredictionErrorRepresentationNormalized, incoming: CdpMlPredictionErrorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Failed prediction
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionErrorRepresentationNormalized extends CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation {
+    /** Error Code for the Error Message */
+    errorCode: string;
+    /** Error Message for Predict Error */
+    message: string;
+}
+/**
+ * Failed prediction
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionErrorRepresentation extends CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation {
+    errorCode: string;
+    message: string;
+    status: 'Error';
+}

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

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "7f612f2ff2c7896ac46cf1e8d7571b87";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlPredictionFieldCustomTextRepresentation, existing: CdpMlPredictionFieldCustomTextRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionFieldCustomTextRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlPredictionFieldCustomTextRepresentationNormalized, incoming: CdpMlPredictionFieldCustomTextRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionFieldCustomTextRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Cdp Ml Prediction Field Custom Text
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionFieldCustomTextRepresentationNormalized {
+    isHidden: boolean;
+    /** Provides placeholder to resolved value defined in the template text. Null if there are no placeholders. */
+    mergeFieldValues: unknown;
+    /** Template text if custom override is defined for the column. */
+    templateText: string;
+}
+/**
+ * Cdp Ml Prediction Field Custom Text
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionFieldCustomTextRepresentation {
+    isHidden: boolean;
+    mergeFieldValues: unknown;
+    templateText: string;
+}

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

@@ -0,0 +1,51 @@
+import { CdpMlPredictionBaseRepresentation as CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation } from './CdpMlPredictionBaseRepresentation';
+import { CdpMlPredictionContributionBaseRepresentation as CdpMlPredictionContributionBaseRepresentation_CdpMlPredictionContributionBaseRepresentation } from './CdpMlPredictionContributionBaseRepresentation';
+import { CdpAssetReferenceRepresentation as CdpAssetReferenceRepresentation_CdpAssetReferenceRepresentation } from './CdpAssetReferenceRepresentation';
+import { CdpMlPredictionWarningsRepresentation as CdpMlPredictionWarningsRepresentation_CdpMlPredictionWarningsRepresentation } from './CdpMlPredictionWarningsRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentUnionSelection as $64$luvio_engine_FragmentUnionSelection, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare enum DiscriminatorValues {
+    Regression = "Regression",
+    BinaryClassification = "BinaryClassification",
+    Generic = "Generic"
+}
+export declare const VERSION = "4bf69752af5d0c61c2fdac87e45db8a2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlPredictionSuccessBaseRepresentation, existing: CdpMlPredictionSuccessBaseRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionSuccessBaseRepresentationNormalized;
+export declare const selectChildren: () => $64$luvio_engine_FragmentUnionSelection;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlPredictionSuccessBaseRepresentationNormalized, incoming: CdpMlPredictionSuccessBaseRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare const discriminatorIngest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionSuccessBaseRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Base representation for a successful prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionSuccessBaseRepresentationNormalized extends CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation {
+    /** A list of top factors associated with prediction */
+    factors: Array<CdpMlPredictionContributionBaseRepresentation_CdpMlPredictionContributionBaseRepresentation>;
+    /** Model partition that's used for this prediction */
+    partition: CdpAssetReferenceRepresentation_CdpAssetReferenceRepresentation;
+    /** A list of recommendations associated with this prediction */
+    prescriptions: Array<CdpMlPredictionContributionBaseRepresentation_CdpMlPredictionContributionBaseRepresentation>;
+    /** Prediction type */
+    type: string;
+    warnings: CdpMlPredictionWarningsRepresentation_CdpMlPredictionWarningsRepresentation;
+}
+/**
+ * Base representation for a successful prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionSuccessBaseRepresentation extends CdpMlPredictionBaseRepresentation_CdpMlPredictionBaseRepresentation {
+    factors: Array<CdpMlPredictionContributionBaseRepresentation_CdpMlPredictionContributionBaseRepresentation>;
+    partition: CdpAssetReferenceRepresentation_CdpAssetReferenceRepresentation;
+    prescriptions: Array<CdpMlPredictionContributionBaseRepresentation_CdpMlPredictionContributionBaseRepresentation>;
+    type: string;
+    warnings: CdpMlPredictionWarningsRepresentation_CdpMlPredictionWarningsRepresentation;
+    status: 'Success';
+}

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

@@ -0,0 +1,32 @@
+import { CdpMlFieldValueRepresentation as CdpMlFieldValueRepresentation_CdpMlFieldValueRepresentation } from './CdpMlFieldValueRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "510be89ce5315c3840efaaaad36fabb8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlPredictionWarningsRepresentation, existing: CdpMlPredictionWarningsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlPredictionWarningsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlPredictionWarningsRepresentationNormalized, incoming: CdpMlPredictionWarningsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlPredictionWarningsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for prediction warnings
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionWarningsRepresentationNormalized {
+    /** A list of missing field names */
+    missingFielsNames: Array<string>;
+    /** A list of fields that contain values that are not seen in the model */
+    outOfBoundsFields: Array<CdpMlFieldValueRepresentation_CdpMlFieldValueRepresentation>;
+}
+/**
+ * Representation for prediction warnings
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlPredictionWarningsRepresentation {
+    missingFielsNames: Array<string>;
+    outOfBoundsFields: Array<CdpMlFieldValueRepresentation_CdpMlFieldValueRepresentation>;
+}

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

@@ -0,0 +1,30 @@
+import { CdpMlPredictionSuccessBaseRepresentation as CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation } from './CdpMlPredictionSuccessBaseRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "167c8a12564b59d3c74be73a5be6145d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CdpMlRegressionPredictionResultRepresentation, existing: CdpMlRegressionPredictionResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CdpMlRegressionPredictionResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CdpMlRegressionPredictionResultRepresentationNormalized, incoming: CdpMlRegressionPredictionResultRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: CdpMlRegressionPredictionResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for a successful regression prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlRegressionPredictionResultRepresentationNormalized extends CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation {
+    /** Representation for a successful regression prediction result */
+    predictedValue: number;
+}
+/**
+ * Representation for a successful regression prediction result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CdpMlRegressionPredictionResultRepresentation extends CdpMlPredictionSuccessBaseRepresentation_CdpMlPredictionSuccessBaseRepresentation {
+    predictedValue: number;
+    type: 'Regression';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-platform-cdp-machine-learning",
-    "version": "1.311.1",
+    "version": "1.312.0",
     "description": "machine learning for data cloud",
     "license": "SEE LICENSE IN LICENSE.txt",
     "main": "dist/es/es2018/platform-cdp-machine-learning.js",
@@ -41,10 +41,10 @@
         "test:unit:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand"
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.311.1"
+        "@salesforce/lds-bindings": "^1.312.0"
     },
     "devDependencies": {
-        "@salesforce/lds-compiler-plugins": "^1.311.1"
+        "@salesforce/lds-compiler-plugins": "^1.312.0"
     },
     "nx": {
         "targets": {

package/sfdc/index.js

@@ -1383,38 +1383,27 @@ function validate$l(obj, path = 'CdpMlAggregatePredictionRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
+var DiscriminatorValues$1;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Regression"] = "Regression";
+    DiscriminatorValues["BinaryClassification"] = "BinaryClassification";
+    DiscriminatorValues["Generic"] = "Generic";
+})(DiscriminatorValues$1 || (DiscriminatorValues$1 = {}));
+
+var DiscriminatorValues;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Success"] = "Success";
+    DiscriminatorValues["Error"] = "Error";
+})(DiscriminatorValues || (DiscriminatorValues = {}));
 function validate$k(obj, path = 'CdpMlPredictionBaseRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        if (obj.status !== undefined) {
-            const obj_status = obj.status;
-            const path_status = path + '.status';
-            let obj_status_union0 = null;
-            const obj_status_union0_error = (() => {
-                if (typeof obj_status !== 'string') {
-                    return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
-                }
-            })();
-            if (obj_status_union0_error != null) {
-                obj_status_union0 = obj_status_union0_error.message;
-            }
-            let obj_status_union1 = null;
-            const obj_status_union1_error = (() => {
-                if (obj_status !== null) {
-                    return new TypeError('Expected "null" but received "' + typeof obj_status + '" (at "' + path_status + '")');
-                }
-            })();
-            if (obj_status_union1_error != null) {
-                obj_status_union1 = obj_status_union1_error.message;
-            }
-            if (obj_status_union0 && obj_status_union1) {
-                let message = 'Object doesn\'t match union (at "' + path_status + '")';
-                message += '\n' + obj_status_union0.split('\n').map((line) => '\t' + line).join('\n');
-                message += '\n' + obj_status_union1.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
+        const obj_status = obj.status;
+        const path_status = path + '.status';
+        if (typeof obj_status !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_status + '" (at "' + path_status + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
@@ -1486,7 +1475,7 @@ function validate$j(obj, path = 'CdpMlPredictSettingsInputRepresentation') {
 }
 
 const TTL$7 = 1000;
-const VERSION$7 = "53acf0a695382123e58156e703232cb5";
+const VERSION$7 = "db91153fa53c91ab59ff4d2ae3000258";
 function validate$i(obj, path = 'CdpMlPredictResultRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1539,15 +1528,13 @@ function validate$i(obj, path = 'CdpMlPredictResultRepresentation') {
                 }
             }
         }
-        if (obj.settings !== undefined) {
-            const obj_settings = obj.settings;
-            const path_settings = path + '.settings';
-            const referencepath_settingsValidationError = validate$j(obj_settings, path_settings);
-            if (referencepath_settingsValidationError !== null) {
-                let message = 'Object doesn\'t match CdpMlPredictSettingsInputRepresentation (at "' + path_settings + '")\n';
-                message += referencepath_settingsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
+        const obj_settings = obj.settings;
+        const path_settings = path + '.settings';
+        const referencepath_settingsValidationError = validate$j(obj_settings, path_settings);
+        if (referencepath_settingsValidationError !== null) {
+            let message = 'Object doesn\'t match CdpMlPredictSettingsInputRepresentation (at "' + path_settings + '")\n';
+            message += referencepath_settingsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
         }
     })();
     return v_error === undefined ? null : v_error;
@@ -5894,4 +5881,4 @@ withDefaultLuvio((luvio) => {
 });
 
 export { createCdpMlConfiguredModel, createCdpMlPredictResult, createMlConfiguredModel, getCdpMlConfiguredModel, getCdpMlConfiguredModelCollection, getCdpMlConfiguredModelCollection_imperative, getCdpMlConfiguredModel_imperative, getCdpMlModelArtifact, getCdpMlModelArtifactCollection, getCdpMlModelArtifactCollection_imperative, getCdpMlModelArtifact_imperative, getCdpMlWorkspace, getCdpMlWorkspaceCollection, getCdpMlWorkspaceCollection_imperative, getCdpMlWorkspaceNotifyChange, getCdpMlWorkspace_imperative, getMlConfiguredModel, getMlConfiguredModelCollection, getMlConfiguredModelCollection_imperative, getMlConfiguredModelNotifyChange, getMlConfiguredModel_imperative, updateCdpMlConfiguredModel, updateMlConfiguredModel };
-// version: 1.311.1-f99d2bc85e
+// version: 1.312.0-0d267bac6a

package/src/raml/api.raml

@@ -1214,14 +1214,172 @@ types:
         type: integer
   CdpMlPredictionBaseRepresentation:
     description: Base representation for a prediction result
+    discriminator: status
     type: object
     properties:
-      status?:
+      status:
         description: prediction status
-        type: string | nil
+        type: string
         enum:
           - Success
           - Error
+  CdpMlPredictionErrorRepresentation:
+    description: Failed prediction
+    type: CdpMlPredictionBaseRepresentation
+    discriminatorValue: Error
+    properties:
+      errorCode:
+        description: Error Code for the Error Message
+        type: string
+        enum:
+          - TimedOut
+          - NoMatch
+          - Error
+      message:
+        description: Error Message for Predict Error
+        type: string
+  CdpMlPredictionSuccessBaseRepresentation:
+    description: Base representation for a successful prediction result
+    type: CdpMlPredictionBaseRepresentation
+    discriminator: type
+    discriminatorValue: Success
+    properties:
+      type:
+        description: Prediction type
+        type: string
+        enum:
+          - Regression
+          - BinaryClassification
+          - Generic
+      partition:
+        description: Model partition that's used for this prediction
+        type: CdpAssetReferenceRepresentation
+      warnings:
+        description: Warnings that are generated by the prediction
+        type: CdpMlPredictionWarningsRepresentation
+      factors:
+        description: A list of top factors associated with prediction
+        type: array
+        items:
+          type: CdpMlPredictionContributionBaseRepresentation
+      prescriptions:
+        description: A list of recommendations associated with this prediction
+        type: array
+        items:
+          type: CdpMlPredictionContributionBaseRepresentation
+  CdpMlRegressionPredictionResultRepresentation:
+    description: Representation for a successful regression prediction result
+    type: CdpMlPredictionSuccessBaseRepresentation
+    discriminatorValue: Regression
+    properties:
+      predictedValue:
+        description: Representation for a successful regression prediction result
+        format: double
+        type: number
+  CdpMlBinaryClassificationPredictionResultRepresentation:
+    description: Representation for a successful binary classification prediction result
+    type: CdpMlPredictionSuccessBaseRepresentation
+    discriminatorValue: BinaryClassification
+    properties:
+      predictedValue:
+        description: Predicted value
+        format: double
+        type: number
+      threshold:
+        description: Threshold used
+        format: double
+        type: number
+  CdpMlGenericPredictionResultRepresentation:
+    description: Representation for a successful generic prediction result
+    type: CdpMlPredictionSuccessBaseRepresentation
+    discriminatorValue: Generic
+    properties:
+      outputs:
+        description: Name
+        type: array
+        items:
+          type: CdpMlGenericPredictionOutputValueRepresentation
+  CdpMlGenericPredictionOutputValueRepresentation:
+    description: Representation for a successful generic prediction result
+    type: object
+    properties:
+      name:
+        description: Name
+        type: string
+      value:
+        description: Output Value
+        type: object
+      type:
+        description: Output Data type
+        type: string
+        enum:
+          - Text
+          - Number
+          - Date
+          - Boolean
+  CdpMlPredictionContributionBaseRepresentation:
+    description: Base representation for a Prediction Contribution
+    type: object
+    properties:
+      value:
+        description: Contribution value
+        format: double
+        type: number
+      fields:
+        description: List of field and values that have the same contribution value
+        type: array
+        items:
+          type: CdpMlPredictionContributionFieldRepresentation
+  CdpMlPredictionContributionFieldRepresentation:
+    description: Cdp Ml Prediction Contribution Field
+    type: object
+    properties:
+      prescribedValue:
+        description: Model output value for the field (i.e. recommended value to improve prediction)
+        type: string
+      inputValue:
+        description: Input value used for this field
+        type: string
+      customText:
+        description:
+        type: CdpMlPredictionFieldCustomTextRepresentation
+  CdpMlPredictionFieldCustomTextRepresentation:
+    description: Cdp Ml Prediction Field Custom Text
+    type: object
+    properties:
+      templateText:
+        description: Template text if custom override is defined for the column.
+        type: string
+      mergeFieldValues:
+        description: Provides placeholder to resolved value defined in the template text. Null if there are no placeholders.
+        type: any
+      isHidden:
+        description:
+        type: boolean
+  CdpMlPredictionWarningsRepresentation:
+    description: Representation for prediction warnings
+    type: object
+    properties:
+      outOfBoundsFields:
+        description: A list of fields that contain values that are not seen in the model
+        type: array
+        items:
+          type: CdpMlFieldValueRepresentation
+      missingFielsNames:
+        description: A list of missing field names
+        type: array
+        items:
+          type: string
+  CdpMlFieldValueRepresentation:
+    description: Cdp Ml Field Value
+    type: object
+    properties:
+      value:
+        description: Field value
+        type: string
+      count:
+        description: Count of the value
+        type: integer
   CdpMlAggregatePredictionRepresentation:
     description: Cdp Ml Prediction result representation
     type: object
@@ -1296,7 +1454,7 @@ types:
         type: array
         items:
           type: CdpMlAggregatePredictionRepresentation
-      settings?:
+      settings:
         description: Settings used for the prediction
         type: CdpMlPredictSettingsInputRepresentation
   MlConfiguredModelInputRepresentation:

package/src/raml/luvio.raml

@@ -43,9 +43,6 @@ types:
   CdpMlAggregatePredictConditionRepresentation:
     (luvio.ttl): 1000
     (luvio.opaque): true
-  CdpMlPredictionBaseRepresentation:
-    (luvio.ttl): 1000
-    (luvio.opaque): true
   CdpMlAggregatePredictionRepresentation:
     (luvio.ttl): 1000
     (luvio.opaque): true