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

package/README.md

@@ -0,0 +1,3 @@
+> INTERNAL USE ONLY
+
+This package contains the AWS Amplify Predictions category and is intended for internal use only. To integrate Amplify into your app, please use [aws-amplify](https://www.npmjs.com/package/aws-amplify).

package/lib/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/Predictions.js

@@ -1,137 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var core_1 = require("@aws-amplify/core");
-var logger = new core_1.ConsoleLogger('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 = [];
+exports.Predictions = exports.PredictionsClass = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const core_1 = require("@aws-amplify/core");
+const providers_1 = require("./providers");
+const logger = new core_1.ConsoleLogger('Predictions');
+class PredictionsClass {
+    constructor() {
+        this.convertProvider = new providers_1.AmazonAIConvertPredictionsProvider();
+        this.identifyProvider = new providers_1.AmazonAIIdentifyPredictionsProvider();
+        this.interpretProvider = new providers_1.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 = tslib_1.__assign(tslib_1.__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 tslib_1.__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 tslib_1.__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;
-}());
+    }
+    interpret(input) {
+        return this.interpretProvider.interpret(input);
+    }
+    convert(input) {
+        return this.convertProvider.convert(input);
+    }
+    identify(input) {
+        return this.identifyProvider.identify(input);
+    }
+}
 exports.PredictionsClass = PredictionsClass;
-exports.Predictions = new PredictionsClass({});
-core_1.Amplify.register(exports.Predictions);
-//# sourceMappingURL=Predictions.js.map
+exports.Predictions = new PredictionsClass();

package/lib/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/errors/PredictionsError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictionsError = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const utils_1 = require("@aws-amplify/core/internals/utils");
+class PredictionsError extends utils_1.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);
+    }
+}
+exports.PredictionsError = PredictionsError;

package/lib/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/errors/types/validation.js

@@ -0,0 +1,50 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationErrorMap = exports.PredictionsValidationErrorCode = void 0;
+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 = exports.PredictionsValidationErrorCode || (exports.PredictionsValidationErrorCode = {}));
+exports.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.',
+    },
+};

package/lib/errors/utils/assertValidationError.d.ts

@@ -0,0 +1,2 @@
+import { PredictionsValidationErrorCode } from '../types/validation';
+export declare function assertValidationError(assertion: boolean, name: PredictionsValidationErrorCode): asserts assertion;

package/lib/errors/utils/assertValidationError.js

@@ -0,0 +1,14 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidationError = void 0;
+const PredictionsError_1 = require("../PredictionsError");
+const validation_1 = require("../types/validation");
+function assertValidationError(assertion, name) {
+    if (!assertion) {
+        const { message, recoverySuggestion } = validation_1.validationErrorMap[name];
+        throw new PredictionsError_1.PredictionsError({ name, message, recoverySuggestion });
+    }
+}
+exports.assertValidationError = assertValidationError;

package/lib/index.d.ts

@@ -1,4 +1,2 @@
-import { Predictions } from './Predictions';
-import { AmazonAIConvertPredictionsProvider, AmazonAIIdentifyPredictionsProvider, AmazonAIPredictionsProvider, AmazonAIInterpretPredictionsProvider } from './Providers';
-export * from './types';
-export { Predictions, AmazonAIIdentifyPredictionsProvider, AmazonAIConvertPredictionsProvider, AmazonAIPredictionsProvider, AmazonAIInterpretPredictionsProvider, };
+export { Predictions } from './Predictions';
+export { IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyTextInput, IdentifyTextOutput, InterpretTextInput, InterpretTextOutput, SpeechToTextInput, SpeechToTextOutput, TextToSpeechInput, TextToSpeechOutput, TranslateTextInput, TranslateTextOutput, } from './types';

package/lib/index.js

@@ -1,14 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
+exports.Predictions = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 var Predictions_1 = require("./Predictions");
-exports.Predictions = Predictions_1.Predictions;
-var Providers_1 = require("./Providers");
-exports.AmazonAIConvertPredictionsProvider = Providers_1.AmazonAIConvertPredictionsProvider;
-exports.AmazonAIIdentifyPredictionsProvider = Providers_1.AmazonAIIdentifyPredictionsProvider;
-exports.AmazonAIPredictionsProvider = Providers_1.AmazonAIPredictionsProvider;
-exports.AmazonAIInterpretPredictionsProvider = Providers_1.AmazonAIInterpretPredictionsProvider;
-tslib_1.__exportStar(require("./types"), exports);
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "Predictions", { enumerable: true, get: function () { return Predictions_1.Predictions; } });

package/{lib-esm/Providers → lib/providers}/AmazonAIConvertPredictionsProvider.d.ts

@@ -1,14 +1,13 @@
-import { AbstractConvertPredictionsProvider } from '../types/Providers/AbstractConvertPredictionsProvider';
-import { TranslateTextInput, TextToSpeechInput, SpeechToTextInput, TranslateTextOutput, TextToSpeechOutput, SpeechToTextOutput } from '../types';
-export declare class AmazonAIConvertPredictionsProvider extends AbstractConvertPredictionsProvider {
-    private translateClient;
-    private pollyClient;
-    constructor();
+import { SpeechToTextInput, SpeechToTextOutput, TextToSpeechInput, TextToSpeechOutput, TranslateTextInput, TranslateTextOutput } from '../types';
+export declare class AmazonAIConvertPredictionsProvider {
+    private translateClient?;
+    private pollyClient?;
     getProviderName(): string;
+    convert(input: TranslateTextInput | TextToSpeechInput | SpeechToTextInput): Promise<TextToSpeechOutput | TranslateTextOutput | SpeechToTextOutput>;
     protected translateText(input: TranslateTextInput): Promise<TranslateTextOutput>;
     protected convertTextToSpeech(input: TextToSpeechInput): Promise<TextToSpeechOutput>;
     protected convertSpeechToText(input: SpeechToTextInput): Promise<SpeechToTextOutput>;
-    static serializeDataFromTranscribe(message: any): string;
+    static serializeDataFromTranscribe(message: MessageEvent): string;
     private sendDataToTranscribe;
     private sendEncodedDataToTranscribe;
     private getAudioEventMessage;