@aws-amplify/predictions 5.5.6-api-v6-models.b3abc9b.0 → 6.0.0

package/lib/types/Predictions.d.ts

@@ -1,24 +1,8 @@
 /// <reference types="node" />
-/**
- * Base types
- */
-export interface PredictionsOptions {
-    [key: string]: any;
-}
-export interface ProviderOptions {
-    providerName?: string;
-}
 /**
  * Convert types
  */
-export declare enum InterpretTextCategories {
-    ALL = "ALL",
-    LANGUAGE = "LANGUAGE",
-    ENTITIES = "ENTITIES",
-    SENTIMENT = "SENTIMENT",
-    SYNTAX = "SYNTAX",
-    KEY_PHRASES = "KEY_PHRASES"
-}
+export type InterpretTextCategories = 'all' | 'language' | 'entities' | 'sentiment' | 'syntax' | 'keyPhrases';
 export interface InterpretTextInput {
     text: InterpretTextInputLanguage | InterpretTextOthers | InterpretTextAll;
 }
@@ -26,28 +10,29 @@ export interface InterpretTextInputLanguage {
     source: {
         text: string;
     };
-    type: InterpretTextCategories.LANGUAGE;
+    type: Extract<InterpretTextCategories, 'language'>;
 }
 export interface InterpretTextOthers {
     source: {
         text: string;
         language: string;
     };
-    type: InterpretTextCategories.ENTITIES | InterpretTextCategories.SENTIMENT | InterpretTextCategories.SYNTAX | InterpretTextCategories.KEY_PHRASES;
+    type: Extract<InterpretTextCategories, 'entities' | 'sentiment' | 'syntax' | 'keyPhrases'>;
 }
 export interface InterpretTextAll {
     source: {
         text: string;
     };
-    type: InterpretTextCategories.ALL;
+    type: Extract<InterpretTextCategories, 'all'>;
 }
 export interface TextEntities {
-    type: string;
-    text: string;
-}
-export interface KeyPhrases {
-    text: string;
+    type?: string;
+    text?: string;
 }
+export type KeyPhrases = KeyPhrase[];
+export type KeyPhrase = {
+    text?: string;
+};
 export interface TextSyntax {
     text: string;
     syntax: string;
@@ -59,11 +44,15 @@ export interface TextSentiment {
     neutral: number;
     mixed: number;
 }
+export type DetectParams = {
+    Text: string;
+    LanguageCode: string;
+};
 export interface InterpretTextOutput {
     textInterpretation: {
         language?: string;
         textEntities?: Array<TextEntities>;
-        keyPhrases?: Array<KeyPhrases>;
+        keyPhrases?: KeyPhrases;
         sentiment?: TextSentiment;
         syntax?: Array<TextSyntax>;
     };
@@ -99,27 +88,34 @@ export interface TextToSpeechOutput {
 }
 export interface StorageSource {
     key: string;
-    level?: 'public' | 'private' | 'protected';
+    level?: 'guest' | 'private' | 'protected';
     identityId?: string;
 }
 export interface FileSource {
     file: File;
 }
-export interface BytesSource {
-    bytes: Buffer | ArrayBuffer | Blob | string;
+export type ConvertBytes = Buffer | ArrayBuffer | string;
+export type IdentifyBytes = ConvertBytes | Blob;
+export interface BytesSource<T> {
+    bytes: T;
 }
 export interface SpeechToTextInput {
     transcription: {
-        source: BytesSource;
+        source: BytesSource<ConvertBytes>;
         language?: string;
     };
 }
+export type TranscribeData = {
+    connection: WebSocket;
+    raw: ConvertBytes;
+    languageCode: string;
+};
 export interface SpeechToTextOutput {
     transcription: {
         fullText: string;
     };
 }
-export declare type IdentifySource = StorageSource | FileSource | BytesSource;
+export type IdentifySource = StorageSource | FileSource | BytesSource<IdentifyBytes>;
 export interface IdentifyTextInput {
     text: {
         source: IdentifySource;
@@ -153,14 +149,14 @@ export interface Table {
         columns: number;
     };
     table: TableCell[][];
-    polygon: Polygon;
-    boundingBox: BoundingBox;
+    polygon?: Polygon;
+    boundingBox?: BoundingBox;
 }
 export interface KeyValue {
     key: string;
     value: Content;
-    polygon: Polygon;
-    boundingBox: BoundingBox;
+    polygon?: Polygon;
+    boundingBox?: BoundingBox;
 }
 export interface IdentifyTextOutput {
     text: {
@@ -172,8 +168,8 @@ export interface IdentifyTextOutput {
         tables?: Table[];
         selections?: {
             selected: boolean;
-            polygon: Polygon;
-            boundingBox: BoundingBox;
+            polygon?: Polygon;
+            boundingBox?: BoundingBox;
         }[];
     };
 }
@@ -187,7 +183,7 @@ export interface Point {
     x?: Number;
     y?: Number;
 }
-export declare type Polygon = Array<Point> | Iterable<Point>;
+export type Polygon = Array<Point> | Iterable<Point>;
 export interface BoundingBox {
     width?: Number;
     height?: Number;
@@ -196,8 +192,8 @@ export interface BoundingBox {
 }
 export interface IdentifyLabelsOutput {
     labels?: {
-        name: string;
-        boundingBoxes: BoundingBox[];
+        name?: string;
+        boundingBoxes?: (BoundingBox | undefined)[];
         metadata?: Object;
     }[];
     unsafe?: 'YES' | 'NO' | 'UNKNOWN';
@@ -227,24 +223,30 @@ export interface FaceAttributes {
     mustache?: boolean;
     eyesOpen?: boolean;
     mouthOpen?: boolean;
-    emotions?: string[];
-}
+    emotions?: (string | undefined)[];
+}
+export type EntityAgeRange = {
+    low?: Number;
+    high?: Number;
+};
+export type EntityLandmark = {
+    type?: string;
+    x?: number;
+    y?: number;
+};
+export type IdentifyEntity = {
+    boundingBox?: BoundingBox;
+    ageRange?: EntityAgeRange;
+    landmarks?: (EntityLandmark | undefined)[];
+    attributes?: FaceAttributes;
+    metadata?: object;
+};
 export interface IdentifyEntitiesOutput {
-    entities: {
-        boundingBox?: BoundingBox;
-        ageRange?: {
-            low?: Number;
-            high?: Number;
-        };
-        landmarks?: {
-            type?: string;
-            x?: number;
-            y?: number;
-        }[];
-        attributes?: FaceAttributes;
-        metadata?: object;
-    }[];
+    entities: IdentifyEntity[];
 }
+export declare function isValidConvertInput(obj: any): boolean;
+export declare function isValidIdentifyInput(obj: any): boolean;
+export declare function isValidInterpretInput(obj: any): boolean;
 export declare function isIdentifyFromCollection(obj: any): obj is IdentifyFromCollection;
 export declare function isIdentifyCelebrities(obj: any): obj is IdentifyCelebrities;
 export declare function isTranslateTextInput(obj: any): obj is TranslateTextInput;
@@ -252,11 +254,13 @@ export declare function isTextToSpeechInput(obj: any): obj is TextToSpeechInput;
 export declare function isSpeechToTextInput(obj: any): obj is SpeechToTextInput;
 export declare function isStorageSource(obj: any): obj is StorageSource;
 export declare function isFileSource(obj: any): obj is FileSource;
-export declare function isBytesSource(obj: any): obj is BytesSource;
+export declare function isConvertBytesSource(obj: any): obj is BytesSource<ConvertBytes>;
+export declare function isIdentifyBytesSource(obj: any): obj is BytesSource<IdentifyBytes>;
 export declare function isIdentifyTextInput(obj: any): obj is IdentifyTextInput;
 export declare function isIdentifyLabelsInput(obj: any): obj is IdentifyLabelsInput;
 export declare function isIdentifyEntitiesInput(obj: any): obj is IdentifyEntitiesInput;
 export declare function isInterpretTextInput(obj: any): obj is InterpretTextInput;
+export declare function isInterpretTextOthers(text: InterpretTextInput['text']): text is InterpretTextOthers;
 export interface Geometry {
     /**
      * <p>An axis-aligned coarse representation of the detected text's location on the image.</p>
@@ -277,5 +281,5 @@ export interface Relationship {
      */
     Ids?: Array<string> | Iterable<string>;
 }
-export declare type FeatureType = 'TABLES' | 'FORMS' | string;
-export declare type FeatureTypes = FeatureType[];
+export type FeatureType = 'TABLES' | 'FORMS' | string;
+export type FeatureTypes = FeatureType[];

package/lib/types/Predictions.js

@@ -3,77 +3,90 @@
 // SPDX-License-Identifier: Apache-2.0
 /* tslint:disable:max-line-length */
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Convert types
- */
-var InterpretTextCategories;
-(function (InterpretTextCategories) {
-    InterpretTextCategories["ALL"] = "ALL";
-    InterpretTextCategories["LANGUAGE"] = "LANGUAGE";
-    InterpretTextCategories["ENTITIES"] = "ENTITIES";
-    InterpretTextCategories["SENTIMENT"] = "SENTIMENT";
-    InterpretTextCategories["SYNTAX"] = "SYNTAX";
-    InterpretTextCategories["KEY_PHRASES"] = "KEY_PHRASES";
-})(InterpretTextCategories = exports.InterpretTextCategories || (exports.InterpretTextCategories = {}));
+exports.isInterpretTextOthers = exports.isInterpretTextInput = exports.isIdentifyEntitiesInput = exports.isIdentifyLabelsInput = exports.isIdentifyTextInput = exports.isIdentifyBytesSource = exports.isConvertBytesSource = exports.isFileSource = exports.isStorageSource = exports.isSpeechToTextInput = exports.isTextToSpeechInput = exports.isTranslateTextInput = exports.isIdentifyCelebrities = exports.isIdentifyFromCollection = exports.isValidInterpretInput = exports.isValidIdentifyInput = exports.isValidConvertInput = void 0;
+function isValidConvertInput(obj) {
+    return (isTranslateTextInput(obj) ||
+        isTextToSpeechInput(obj) ||
+        isSpeechToTextInput(obj));
+}
+exports.isValidConvertInput = isValidConvertInput;
+function isValidIdentifyInput(obj) {
+    return (isIdentifyTextInput(obj) ||
+        isIdentifyLabelsInput(obj) ||
+        isIdentifyEntitiesInput(obj));
+}
+exports.isValidIdentifyInput = isValidIdentifyInput;
+function isValidInterpretInput(obj) {
+    return isInterpretTextInput(obj);
+}
+exports.isValidInterpretInput = isValidInterpretInput;
 function isIdentifyFromCollection(obj) {
-    var key = 'collection';
-    var keyId = 'collectionId';
+    const key = 'collection';
+    const keyId = 'collectionId';
     return obj && (obj.hasOwnProperty(key) || obj.hasOwnProperty(keyId));
 }
 exports.isIdentifyFromCollection = isIdentifyFromCollection;
 function isIdentifyCelebrities(obj) {
-    var key = 'celebrityDetection';
+    const key = 'celebrityDetection';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isIdentifyCelebrities = isIdentifyCelebrities;
 function isTranslateTextInput(obj) {
-    var key = 'translateText';
+    const key = 'translateText';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isTranslateTextInput = isTranslateTextInput;
 function isTextToSpeechInput(obj) {
-    var key = 'textToSpeech';
+    const key = 'textToSpeech';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isTextToSpeechInput = isTextToSpeechInput;
 function isSpeechToTextInput(obj) {
-    var key = 'transcription';
+    const key = 'transcription';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isSpeechToTextInput = isSpeechToTextInput;
 function isStorageSource(obj) {
-    var key = 'key';
+    const key = 'key';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isStorageSource = isStorageSource;
 function isFileSource(obj) {
-    var key = 'file';
+    const key = 'file';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isFileSource = isFileSource;
-function isBytesSource(obj) {
-    var key = 'bytes';
+function isConvertBytesSource(obj) {
+    const key = 'bytes';
     return obj && obj.hasOwnProperty(key);
 }
-exports.isBytesSource = isBytesSource;
+exports.isConvertBytesSource = isConvertBytesSource;
+function isIdentifyBytesSource(obj) {
+    const key = 'bytes';
+    return obj && obj.hasOwnProperty(key);
+}
+exports.isIdentifyBytesSource = isIdentifyBytesSource;
 function isIdentifyTextInput(obj) {
-    var key = 'text';
+    const key = 'text';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isIdentifyTextInput = isIdentifyTextInput;
 function isIdentifyLabelsInput(obj) {
-    var key = 'labels';
+    const key = 'labels';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isIdentifyLabelsInput = isIdentifyLabelsInput;
 function isIdentifyEntitiesInput(obj) {
-    var key = 'entities';
+    const key = 'entities';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isIdentifyEntitiesInput = isIdentifyEntitiesInput;
 function isInterpretTextInput(obj) {
-    var key = 'text';
+    const key = 'text';
     return obj && obj.hasOwnProperty(key);
 }
 exports.isInterpretTextInput = isInterpretTextInput;
-//# sourceMappingURL=Predictions.js.map
+function isInterpretTextOthers(text) {
+    return text.source.language !== undefined;
+}
+exports.isInterpretTextOthers = isInterpretTextOthers;

package/lib/types/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 tslib_1.__exportStar(require("./Predictions"), exports);
-//# sourceMappingURL=index.js.map

package/lib-esm/Predictions.d.ts

@@ -1,49 +1,15 @@
-import { PredictionsOptions, TranslateTextInput, TranslateTextOutput, TextToSpeechInput, ProviderOptions, TextToSpeechOutput, SpeechToTextInput, SpeechToTextOutput, IdentifyTextInput, IdentifyTextOutput, IdentifyLabelsOutput, IdentifyLabelsInput, IdentifyEntitiesInput, IdentifyEntitiesOutput, InterpretTextOutput, InterpretTextInput } from './types';
-import { AbstractPredictionsProvider } from './types/Providers';
+import { IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyTextInput, IdentifyTextOutput, InterpretTextInput, InterpretTextOutput, SpeechToTextInput, SpeechToTextOutput, TextToSpeechInput, TextToSpeechOutput, TranslateTextInput, TranslateTextOutput } from './types';
 export declare class PredictionsClass {
-    private _options;
-    private _convertPluggables;
-    private _identifyPluggables;
-    private _interpretPluggables;
-    /**
-     * Initialize Predictions with AWS configurations
-     * @param {PredictionsOptions} options - Configuration object for Predictions
-     */
-    constructor(options: PredictionsOptions);
+    private convertProvider;
+    private identifyProvider;
+    private interpretProvider;
     getModuleName(): string;
-    /**
-     * add plugin/pluggable into Predictions category
-     * @param {Object} pluggable - an instance of the plugin/pluggable
-     **/
-    addPluggable(pluggable: AbstractPredictionsProvider): void;
-    /**
-     * Get the plugin object
-     * @param providerName - the name of the plugin
-     */
-    getPluggable(providerName: string): AbstractPredictionsProvider;
-    /**
-     * Remove the plugin object
-     * @param providerName - the name of the plugin
-     */
-    removePluggable(providerName: string): void;
-    /**
-     * To make both top level providers and category level providers work with same interface and configuration
-     * this method duplicates Predictions config into parent level config (for top level provider) and
-     * category level config (such as convert, identify etc) and pass both to each provider.
-     */
-    configure(options: PredictionsOptions): void;
-    interpret(input: InterpretTextInput, options?: ProviderOptions): Promise<InterpretTextOutput>;
-    convert(input: TranslateTextInput, options?: ProviderOptions): Promise<TranslateTextOutput>;
-    convert(input: TextToSpeechInput, options?: ProviderOptions): Promise<TextToSpeechOutput>;
-    convert(input: SpeechToTextInput, options?: ProviderOptions): Promise<SpeechToTextOutput>;
-    identify(input: IdentifyTextInput, options?: ProviderOptions): Promise<IdentifyTextOutput>;
-    identify(input: IdentifyLabelsInput, options?: ProviderOptions): Promise<IdentifyLabelsOutput>;
-    identify(input: IdentifyEntitiesInput, options?: ProviderOptions): Promise<IdentifyEntitiesOutput>;
-    private getPluggableToExecute;
-    private getAllProviders;
-    private configurePluggable;
-    private implementsConvertPluggable;
-    private implementsIdentifyPluggable;
-    private implementsInterpretPluggable;
+    interpret(input: InterpretTextInput): Promise<InterpretTextOutput>;
+    convert(input: TranslateTextInput): Promise<TranslateTextOutput>;
+    convert(input: TextToSpeechInput): Promise<TextToSpeechOutput>;
+    convert(input: SpeechToTextInput): Promise<SpeechToTextOutput>;
+    identify(input: IdentifyTextInput): Promise<IdentifyTextOutput>;
+    identify(input: IdentifyLabelsInput): Promise<IdentifyLabelsOutput>;
+    identify(input: IdentifyEntitiesInput): Promise<IdentifyEntitiesOutput>;
 }
 export declare const Predictions: PredictionsClass;

package/lib-esm/Predictions.js

@@ -1,135 +1,25 @@
-import { __assign, __read, __spread } from "tslib";
-import { Amplify, ConsoleLogger as Logger } from '@aws-amplify/core';
-var logger = new Logger('Predictions');
-var PredictionsClass = /** @class */ (function () {
-    /**
-     * Initialize Predictions with AWS configurations
-     * @param {PredictionsOptions} options - Configuration object for Predictions
-     */
-    function PredictionsClass(options) {
-        this._options = options;
-        this._convertPluggables = [];
-        this._identifyPluggables = [];
-        this._interpretPluggables = [];
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { AmazonAIConvertPredictionsProvider, AmazonAIIdentifyPredictionsProvider, AmazonAIInterpretPredictionsProvider, } from './providers';
+const logger = new Logger('Predictions');
+export class PredictionsClass {
+    constructor() {
+        this.convertProvider = new AmazonAIConvertPredictionsProvider();
+        this.identifyProvider = new AmazonAIIdentifyPredictionsProvider();
+        this.interpretProvider = new AmazonAIInterpretPredictionsProvider();
     }
-    PredictionsClass.prototype.getModuleName = function () {
+    getModuleName() {
         return 'Predictions';
-    };
-    /**
-     * add plugin/pluggable into Predictions category
-     * @param {Object} pluggable - an instance of the plugin/pluggable
-     **/
-    PredictionsClass.prototype.addPluggable = function (pluggable) {
-        if (this.getPluggable(pluggable.getProviderName())) {
-            throw new Error("Pluggable with name " + pluggable.getProviderName() + " has already been added.");
-        }
-        var pluggableAdded = false;
-        if (this.implementsConvertPluggable(pluggable)) {
-            this._convertPluggables.push(pluggable);
-            pluggableAdded = true;
-        }
-        if (this.implementsIdentifyPluggable(pluggable)) {
-            this._identifyPluggables.push(pluggable);
-            pluggableAdded = true;
-        }
-        if (this.implementsInterpretPluggable(pluggable)) {
-            this._interpretPluggables.push(pluggable);
-            pluggableAdded = true;
-        }
-        if (pluggableAdded) {
-            this.configurePluggable(pluggable);
-        }
-    };
-    /**
-     * Get the plugin object
-     * @param providerName - the name of the plugin
-     */
-    PredictionsClass.prototype.getPluggable = function (providerName) {
-        var pluggable = this.getAllProviders().find(function (pluggable) { return pluggable.getProviderName() === providerName; });
-        if (pluggable === undefined) {
-            logger.debug('No plugin found with providerName=>', providerName);
-            return null;
-        }
-        else
-            return pluggable;
-    };
-    /**
-     * Remove the plugin object
-     * @param providerName - the name of the plugin
-     */
-    PredictionsClass.prototype.removePluggable = function (providerName) {
-        this._convertPluggables = this._convertPluggables.filter(function (pluggable) { return pluggable.getProviderName() !== providerName; });
-        this._identifyPluggables = this._identifyPluggables.filter(function (pluggable) { return pluggable.getProviderName() !== providerName; });
-        this._interpretPluggables = this._interpretPluggables.filter(function (pluggable) { return pluggable.getProviderName() !== providerName; });
-        return;
-    };
-    /**
-     * To make both top level providers and category level providers work with same interface and configuration
-     * this method duplicates Predictions config into parent level config (for top level provider) and
-     * category level config (such as convert, identify etc) and pass both to each provider.
-     */
-    PredictionsClass.prototype.configure = function (options) {
-        var _this = this;
-        var predictionsConfig = options ? options.predictions || options : {};
-        predictionsConfig = __assign(__assign({}, predictionsConfig), options);
-        this._options = Object.assign({}, this._options, predictionsConfig);
-        logger.debug('configure Predictions', this._options);
-        this.getAllProviders().forEach(function (pluggable) {
-            return _this.configurePluggable(pluggable);
-        });
-    };
-    PredictionsClass.prototype.interpret = function (input, options) {
-        var pluggableToExecute = this.getPluggableToExecute(this._interpretPluggables, options);
-        return pluggableToExecute.interpret(input);
-    };
-    PredictionsClass.prototype.convert = function (input, options) {
-        var pluggableToExecute = this.getPluggableToExecute(this._convertPluggables, options);
-        return pluggableToExecute.convert(input);
-    };
-    PredictionsClass.prototype.identify = function (input, options) {
-        var pluggableToExecute = this.getPluggableToExecute(this._identifyPluggables, options);
-        return pluggableToExecute.identify(input);
-    };
-    // tslint:disable-next-line: max-line-length
-    PredictionsClass.prototype.getPluggableToExecute = function (pluggables, providerOptions) {
-        // Give preference to provider name first since it is more specific to this call, even if
-        // there is only one provider configured to error out if the name provided is not the one matched.
-        if (providerOptions && providerOptions.providerName) {
-            return __spread(pluggables).find(function (pluggable) {
-                return pluggable.getProviderName() === providerOptions.providerName;
-            });
-        }
-        else {
-            if (pluggables.length === 1) {
-                return pluggables[0];
-            }
-            else {
-                throw new Error('More than one or no providers are configured, ' +
-                    'Either specify a provider name or configure exactly one provider');
-            }
-        }
-    };
-    PredictionsClass.prototype.getAllProviders = function () {
-        return __spread(this._convertPluggables, this._identifyPluggables, this._interpretPluggables);
-    };
-    PredictionsClass.prototype.configurePluggable = function (pluggable) {
-        var categoryConfig = Object.assign({}, this._options['predictions'], // Parent predictions config for the top level provider
-        this._options[pluggable.getCategory().toLowerCase()] // Actual category level config
-        );
-        pluggable.configure(categoryConfig);
-    };
-    PredictionsClass.prototype.implementsConvertPluggable = function (obj) {
-        return obj && typeof obj.convert === 'function';
-    };
-    PredictionsClass.prototype.implementsIdentifyPluggable = function (obj) {
-        return obj && typeof obj.identify === 'function';
-    };
-    PredictionsClass.prototype.implementsInterpretPluggable = function (obj) {
-        return obj && typeof obj.interpret === 'function';
-    };
-    return PredictionsClass;
-}());
-export { PredictionsClass };
-export var Predictions = new PredictionsClass({});
-Amplify.register(Predictions);
-//# sourceMappingURL=Predictions.js.map
+    }
+    interpret(input) {
+        return this.interpretProvider.interpret(input);
+    }
+    convert(input) {
+        return this.convertProvider.convert(input);
+    }
+    identify(input) {
+        return this.identifyProvider.identify(input);
+    }
+}
+export const Predictions = new PredictionsClass();

package/lib-esm/errors/PredictionsError.d.ts

@@ -0,0 +1,4 @@
+import { AmplifyError, AmplifyErrorParams } from '@aws-amplify/core/internals/utils';
+export declare class PredictionsError extends AmplifyError {
+    constructor(params: AmplifyErrorParams);
+}

package/lib-esm/errors/PredictionsError.js

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyError, } from '@aws-amplify/core/internals/utils';
+export class PredictionsError extends AmplifyError {
+    constructor(params) {
+        super(params);
+        // TODO: Delete the following 2 lines after we change the build target to >= es2015
+        this.constructor = PredictionsError;
+        Object.setPrototypeOf(this, PredictionsError.prototype);
+    }
+}

package/lib-esm/errors/types/validation.d.ts

@@ -0,0 +1,14 @@
+import { AmplifyErrorMap } from '@aws-amplify/core/internals/utils';
+export declare enum PredictionsValidationErrorCode {
+    CelebrityDetectionNotEnabled = "CelebrityDetectionNotEnabled",
+    InvalidInput = "InvalidInput",
+    InvalidSource = "InvalidSource",
+    NoCredentials = "NoCredentials",
+    NoLanguage = "NoLanguage",
+    NoRegion = "NoRegion",
+    NoSource = "NoSource",
+    NoSourceLanguage = "NoSourceLanguage",
+    NoTargetLanguage = "NoTargetLanguage",
+    NoVoiceId = "NoVoiceId"
+}
+export declare const validationErrorMap: AmplifyErrorMap<PredictionsValidationErrorCode>;

package/lib-esm/errors/types/validation.js

@@ -0,0 +1,47 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export var PredictionsValidationErrorCode;
+(function (PredictionsValidationErrorCode) {
+    PredictionsValidationErrorCode["CelebrityDetectionNotEnabled"] = "CelebrityDetectionNotEnabled";
+    PredictionsValidationErrorCode["InvalidInput"] = "InvalidInput";
+    PredictionsValidationErrorCode["InvalidSource"] = "InvalidSource";
+    PredictionsValidationErrorCode["NoCredentials"] = "NoCredentials";
+    PredictionsValidationErrorCode["NoLanguage"] = "NoLanguage";
+    PredictionsValidationErrorCode["NoRegion"] = "NoRegion";
+    PredictionsValidationErrorCode["NoSource"] = "NoSource";
+    PredictionsValidationErrorCode["NoSourceLanguage"] = "NoSourceLanguage";
+    PredictionsValidationErrorCode["NoTargetLanguage"] = "NoTargetLanguage";
+    PredictionsValidationErrorCode["NoVoiceId"] = "NoVoiceId";
+})(PredictionsValidationErrorCode || (PredictionsValidationErrorCode = {}));
+export const validationErrorMap = {
+    [PredictionsValidationErrorCode.CelebrityDetectionNotEnabled]: {
+        message: 'Celebrity Detection must be enabled.',
+    },
+    [PredictionsValidationErrorCode.InvalidInput]: {
+        message: 'Input does not conform to expected type.',
+    },
+    [PredictionsValidationErrorCode.InvalidSource]: {
+        message: 'Source type not supported.',
+    },
+    [PredictionsValidationErrorCode.NoCredentials]: {
+        message: 'Credentials should not be empty.',
+    },
+    [PredictionsValidationErrorCode.NoLanguage]: {
+        message: 'Missing language.',
+    },
+    [PredictionsValidationErrorCode.NoRegion]: {
+        message: 'Missing region.',
+    },
+    [PredictionsValidationErrorCode.NoSource]: {
+        message: 'Missing source.',
+    },
+    [PredictionsValidationErrorCode.NoSourceLanguage]: {
+        message: 'Missing source language for translation.',
+    },
+    [PredictionsValidationErrorCode.NoTargetLanguage]: {
+        message: 'Missing target language for translation.',
+    },
+    [PredictionsValidationErrorCode.NoVoiceId]: {
+        message: 'Missing voice id.',
+    },
+};