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

package/lib/providers/AmazonAIConvertPredictionsProvider.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmazonAIConvertPredictionsProvider = 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 utils_1 = require("@aws-amplify/core/internals/utils");
+const client_polly_1 = require("@aws-sdk/client-polly");
+const client_translate_1 = require("@aws-sdk/client-translate");
+const eventstream_codec_1 = require("@smithy/eventstream-codec");
+const util_utf8_1 = require("@smithy/util-utf8");
+const buffer_1 = require("buffer");
+const validation_1 = require("../errors/types/validation");
+const assertValidationError_1 = require("../errors/utils/assertValidationError");
+const types_1 = require("../types");
+const logger = new core_1.ConsoleLogger('AmazonAIConvertPredictionsProvider');
+const eventBuilder = new eventstream_codec_1.EventStreamCodec(util_utf8_1.toUtf8, util_utf8_1.fromUtf8);
+const LANGUAGES_CODE_IN_8KHZ = ['fr-FR', 'en-AU', 'en-GB', 'fr-CA'];
+class AmazonAIConvertPredictionsProvider {
+    constructor() {
+        this.inputSampleRate = 44100;
+    }
+    getProviderName() {
+        return 'AmazonAIConvertPredictionsProvider';
+    }
+    convert(input) {
+        (0, assertValidationError_1.assertValidationError)((0, types_1.isValidConvertInput)(input), validation_1.PredictionsValidationErrorCode.InvalidInput);
+        if ((0, types_1.isTranslateTextInput)(input)) {
+            logger.debug('translateText');
+            return this.translateText(input);
+        }
+        else if ((0, types_1.isTextToSpeechInput)(input)) {
+            logger.debug('textToSpeech');
+            return this.convertTextToSpeech(input);
+        }
+        else {
+            logger.debug('textToSpeech');
+            return this.convertSpeechToText(input);
+        }
+    }
+    async translateText(input) {
+        logger.debug('Starting translation');
+        const { translateText = {} } = core_1.Amplify.getConfig().Predictions?.convert ?? {};
+        (0, assertValidationError_1.assertValidationError)(!!translateText.region, validation_1.PredictionsValidationErrorCode.NoRegion);
+        const { defaults = {}, region } = translateText;
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        const { sourceLanguage, targetLanguage } = defaults;
+        const sourceLanguageCode = input.translateText?.source?.language ?? sourceLanguage;
+        const targetLanguageCode = input.translateText?.targetLanguage ?? targetLanguage;
+        (0, assertValidationError_1.assertValidationError)(!!sourceLanguageCode, validation_1.PredictionsValidationErrorCode.NoSourceLanguage);
+        (0, assertValidationError_1.assertValidationError)(!!targetLanguageCode, validation_1.PredictionsValidationErrorCode.NoTargetLanguage);
+        this.translateClient = new client_translate_1.TranslateClient({
+            region,
+            credentials,
+            customUserAgent: (0, utils_1.getAmplifyUserAgentObject)({
+                category: utils_1.Category.Predictions,
+                action: utils_1.PredictionsAction.Convert,
+            }),
+        });
+        const translateTextCommand = new client_translate_1.TranslateTextCommand({
+            SourceLanguageCode: sourceLanguageCode,
+            TargetLanguageCode: targetLanguageCode,
+            Text: input.translateText?.source?.text,
+        });
+        const data = await this.translateClient.send(translateTextCommand);
+        return {
+            text: data.TranslatedText,
+            language: data.TargetLanguageCode,
+        };
+    }
+    async convertTextToSpeech(input) {
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        (0, assertValidationError_1.assertValidationError)(!!input.textToSpeech?.source, validation_1.PredictionsValidationErrorCode.NoSource);
+        const { speechGenerator } = core_1.Amplify.getConfig().Predictions?.convert ?? {};
+        (0, assertValidationError_1.assertValidationError)(!!speechGenerator?.region, validation_1.PredictionsValidationErrorCode.NoRegion);
+        const { defaults = {}, region } = speechGenerator;
+        const { voiceId: defaultVoiceId } = defaults;
+        const voiceId = input.textToSpeech?.voiceId ?? defaultVoiceId;
+        (0, assertValidationError_1.assertValidationError)(!!voiceId, validation_1.PredictionsValidationErrorCode.NoVoiceId);
+        this.pollyClient = new client_polly_1.PollyClient({
+            region,
+            credentials,
+            customUserAgent: (0, utils_1.getAmplifyUserAgentObject)({
+                category: utils_1.Category.Predictions,
+                action: utils_1.PredictionsAction.Convert,
+            }),
+        });
+        const synthesizeSpeechCommand = new client_polly_1.SynthesizeSpeechCommand({
+            OutputFormat: 'mp3',
+            Text: input.textToSpeech?.source?.text,
+            VoiceId: voiceId,
+            TextType: 'text',
+            SampleRate: '24000',
+            // tslint:disable-next-line: align
+        });
+        const data = await this.pollyClient.send(synthesizeSpeechCommand);
+        const response = new Response(data.AudioStream);
+        const arrayBuffer = await response.arrayBuffer();
+        const blob = new Blob([arrayBuffer], {
+            type: data.ContentType,
+        });
+        const url = URL.createObjectURL(blob);
+        return {
+            speech: { url },
+            audioStream: arrayBuffer,
+            text: input.textToSpeech?.source?.text,
+        };
+    }
+    async convertSpeechToText(input) {
+        logger.debug('starting transcription..');
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        const { transcription } = core_1.Amplify.getConfig().Predictions?.convert ?? {};
+        (0, assertValidationError_1.assertValidationError)(!!transcription?.region, validation_1.PredictionsValidationErrorCode.NoRegion);
+        const { defaults, region } = transcription;
+        const language = input.transcription?.language ?? defaults?.language;
+        (0, assertValidationError_1.assertValidationError)(!!language, validation_1.PredictionsValidationErrorCode.NoLanguage);
+        const source = input.transcription?.source;
+        (0, assertValidationError_1.assertValidationError)((0, types_1.isConvertBytesSource)(source), validation_1.PredictionsValidationErrorCode.InvalidSource);
+        const connection = await this.openConnectionWithTranscribe({
+            credentials,
+            region,
+            languageCode: language,
+        });
+        const fullText = await this.sendDataToTranscribe({
+            connection,
+            raw: source.bytes,
+            languageCode: language,
+        });
+        return {
+            transcription: {
+                fullText,
+            },
+        };
+    }
+    static serializeDataFromTranscribe(message) {
+        let decodedMessage = '';
+        const transcribeMessage = eventBuilder.decode(buffer_1.Buffer.from(message.data));
+        const transcribeMessageJson = JSON.parse((0, util_utf8_1.toUtf8)(transcribeMessage.body));
+        if (transcribeMessage.headers[':message-type'].value === 'exception') {
+            logger.debug('exception', JSON.stringify(transcribeMessageJson.Message, null, 2));
+            throw new Error(transcribeMessageJson.Message);
+        }
+        else if (transcribeMessage.headers[':message-type'].value === 'event') {
+            if (transcribeMessageJson.Transcript.Results.length > 0) {
+                if (transcribeMessageJson.Transcript.Results[0].Alternatives.length > 0) {
+                    if (transcribeMessageJson.Transcript.Results[0].Alternatives[0]
+                        .Transcript.length > 0) {
+                        if (transcribeMessageJson.Transcript.Results[0].IsPartial === false) {
+                            decodedMessage =
+                                transcribeMessageJson.Transcript.Results[0].Alternatives[0]
+                                    .Transcript + '\n';
+                            logger.debug({ decodedMessage });
+                        }
+                        else {
+                            logger.debug({
+                                transcript: transcribeMessageJson.Transcript.Results[0].Alternatives[0],
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return decodedMessage;
+    }
+    sendDataToTranscribe({ connection, raw, languageCode, }) {
+        return new Promise((res, rej) => {
+            let fullText = '';
+            connection.onmessage = message => {
+                try {
+                    const decodedMessage = AmazonAIConvertPredictionsProvider.serializeDataFromTranscribe(message);
+                    if (decodedMessage) {
+                        fullText += decodedMessage + ' ';
+                    }
+                }
+                catch (err) {
+                    logger.debug(err);
+                    rej(err);
+                }
+            };
+            connection.onerror = errorEvent => {
+                logger.debug({ errorEvent });
+                rej('failed to transcribe, network error');
+            };
+            connection.onclose = closeEvent => {
+                logger.debug({ closeEvent });
+                return res(fullText.trim());
+            };
+            logger.debug({ raw });
+            if (Array.isArray(raw)) {
+                for (let i = 0; i < raw.length - 1023; i += 1024) {
+                    const data = raw.slice(i, i + 1024);
+                    this.sendEncodedDataToTranscribe(connection, data, languageCode);
+                }
+            }
+            else {
+                // If Buffer
+                this.sendEncodedDataToTranscribe(connection, raw, languageCode);
+            }
+            // sending end frame
+            const endFrameEventMessage = this.getAudioEventMessage(buffer_1.Buffer.from([]));
+            const endFrameBinary = eventBuilder.encode(endFrameEventMessage);
+            connection.send(endFrameBinary);
+        });
+    }
+    sendEncodedDataToTranscribe(connection, data, languageCode) {
+        const downsampledBuffer = this.downsampleBuffer({
+            buffer: data,
+            outputSampleRate: LANGUAGES_CODE_IN_8KHZ.includes(languageCode)
+                ? 8000
+                : 16000,
+        });
+        const pcmEncodedBuffer = this.pcmEncode(downsampledBuffer);
+        const audioEventMessage = this.getAudioEventMessage(buffer_1.Buffer.from(pcmEncodedBuffer));
+        const binary = eventBuilder.encode(audioEventMessage);
+        connection.send(binary);
+    }
+    getAudioEventMessage(buffer) {
+        const audioEventMessage = {
+            body: buffer,
+            headers: {
+                ':message-type': {
+                    type: 'string',
+                    value: 'event',
+                },
+                ':event-type': {
+                    type: 'string',
+                    value: 'AudioEvent',
+                },
+            },
+        };
+        return audioEventMessage;
+    }
+    pcmEncode(input) {
+        let offset = 0;
+        // ArrayBuffer cannot be processed using length property
+        if (input instanceof ArrayBuffer) {
+            return input;
+        }
+        const buffer = new ArrayBuffer(input.length * 2);
+        const view = new DataView(buffer);
+        for (let i = 0; i < input.length; i++, offset += 2) {
+            const s = Math.max(-1, Math.min(1, input[i]));
+            view.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+        }
+        return buffer;
+    }
+    downsampleBuffer({ buffer, outputSampleRate = 16000, }) {
+        // Cannot process ArrayBuffer using length property
+        if (outputSampleRate === this.inputSampleRate ||
+            buffer instanceof ArrayBuffer) {
+            return buffer;
+        }
+        const sampleRateRatio = this.inputSampleRate / outputSampleRate;
+        const newLength = Math.round(buffer.length / sampleRateRatio);
+        const result = new Float32Array(newLength);
+        let offsetResult = 0;
+        let offsetBuffer = 0;
+        while (offsetResult < result.length) {
+            const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
+            let accum = 0, count = 0;
+            for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i++) {
+                accum += buffer[i];
+                count++;
+            }
+            result[offsetResult] = accum / count;
+            offsetResult++;
+            offsetBuffer = nextOffsetBuffer;
+        }
+        return result;
+    }
+    openConnectionWithTranscribe({ credentials, region, languageCode, }) {
+        return new Promise(async (res, rej) => {
+            const signedUrl = this.generateTranscribeUrl({
+                credentials,
+                region,
+                languageCode,
+            });
+            logger.debug('connecting...');
+            const connection = new WebSocket(signedUrl);
+            connection.binaryType = 'arraybuffer';
+            connection.onopen = () => {
+                logger.debug('connected');
+                res(connection);
+            };
+        });
+    }
+    generateTranscribeUrl({ credentials: { accessKeyId, secretAccessKey, sessionToken }, region, languageCode, }) {
+        const credentials = {
+            access_key: accessKeyId,
+            secret_key: secretAccessKey,
+            session_token: sessionToken,
+        };
+        const url = [
+            `wss://transcribestreaming.${region}.amazonaws.com:8443`,
+            '/stream-transcription-websocket?',
+            `media-encoding=pcm&`,
+            `sample-rate=${LANGUAGES_CODE_IN_8KHZ.includes(languageCode) ? '8000' : '16000'}&`,
+            `language-code=${languageCode}`,
+        ].join('');
+        const signedUrl = utils_1.Signer.signUrl(url, credentials, { region, service: 'transcribe' }, 300);
+        return signedUrl;
+    }
+}
+exports.AmazonAIConvertPredictionsProvider = AmazonAIConvertPredictionsProvider;

package/lib/{Providers → providers}/AmazonAIIdentifyPredictionsProvider.d.ts

@@ -1,10 +1,9 @@
-import { AbstractIdentifyPredictionsProvider } from '../types/Providers';
-import { IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyTextInput, IdentifyTextOutput } from '../types';
-export declare class AmazonAIIdentifyPredictionsProvider extends AbstractIdentifyPredictionsProvider {
-    private rekognitionClient;
-    private textractClient;
-    constructor();
+import { IdentifyEntitiesInput, IdentifyEntitiesOutput, IdentifyLabelsInput, IdentifyLabelsOutput, IdentifyTextInput, IdentifyTextOutput } from '../types';
+export declare class AmazonAIIdentifyPredictionsProvider {
+    private rekognitionClient?;
+    private textractClient?;
     getProviderName(): string;
+    identify(input: IdentifyTextInput | IdentifyLabelsInput | IdentifyEntitiesInput): Promise<IdentifyTextOutput | IdentifyLabelsOutput | IdentifyEntitiesOutput>;
     /**
      * Verify user input source and converts it into source object readable by Rekognition and Textract.
      * Note that Rekognition and Textract use the same source interface, so we need not worry about types.

package/lib/providers/AmazonAIIdentifyPredictionsProvider.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmazonAIIdentifyPredictionsProvider = 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 utils_1 = require("@aws-amplify/core/internals/utils");
+const storage_1 = require("@aws-amplify/storage");
+const client_rekognition_1 = require("@aws-sdk/client-rekognition");
+const client_textract_1 = require("@aws-sdk/client-textract");
+const validation_1 = require("../errors/types/validation");
+const assertValidationError_1 = require("../errors/utils/assertValidationError");
+const types_1 = require("../types");
+const IdentifyTextUtils_1 = require("./IdentifyTextUtils");
+const Utils_1 = require("./Utils");
+const logger = new core_1.ConsoleLogger('AmazonAIIdentifyPredictionsProvider');
+class AmazonAIIdentifyPredictionsProvider {
+    getProviderName() {
+        return 'AmazonAIIdentifyPredictionsProvider';
+    }
+    identify(input) {
+        (0, assertValidationError_1.assertValidationError)((0, types_1.isValidIdentifyInput)(input), validation_1.PredictionsValidationErrorCode.InvalidInput);
+        if ((0, types_1.isIdentifyTextInput)(input)) {
+            logger.debug('identifyText');
+            return this.identifyText(input);
+        }
+        else if ((0, types_1.isIdentifyLabelsInput)(input)) {
+            logger.debug('identifyLabels');
+            return this.identifyLabels(input);
+        }
+        else {
+            logger.debug('identifyEntities');
+            return this.identifyEntities(input);
+        }
+    }
+    /**
+     * Verify user input source and converts it into source object readable by Rekognition and Textract.
+     * Note that Rekognition and Textract use the same source interface, so we need not worry about types.
+     * @param {IdentifySource} source - User input source that directs to the object user wants
+     * to identify (storage, file, or bytes).
+     * @return {Promise<Image>} - Promise resolving to the converted source object.
+     */
+    configureSource(source) {
+        return new Promise((res, rej) => {
+            if ((0, types_1.isStorageSource)(source)) {
+                const storageConfig = {
+                    accessLevel: source.level,
+                    targetIdentityId: source.identityId,
+                };
+                (0, storage_1.getUrl)({ key: source.key, options: storageConfig })
+                    .then(value => {
+                    const parser = /https:\/\/([a-zA-Z0-9%\-_.]+)\.s3\.[A-Za-z0-9%\-._~]+\/([a-zA-Z0-9%\-._~/]+)\?/;
+                    const parsedURL = value.url.toString().match(parser) ?? '';
+                    if (parsedURL.length < 3)
+                        rej('Invalid S3 key was given.');
+                    res({
+                        S3Object: {
+                            Bucket: parsedURL[1],
+                            Name: decodeURIComponent(parsedURL[2]),
+                        },
+                    });
+                })
+                    .catch(err => rej(err));
+            }
+            else if ((0, types_1.isFileSource)(source)) {
+                (0, Utils_1.blobToArrayBuffer)(source.file)
+                    .then(buffer => {
+                    res({ Bytes: new Uint8Array(buffer) });
+                })
+                    .catch(err => rej(err));
+            }
+            else if ((0, types_1.isIdentifyBytesSource)(source)) {
+                const bytes = source.bytes;
+                if (bytes instanceof Blob) {
+                    (0, Utils_1.blobToArrayBuffer)(bytes)
+                        .then(buffer => {
+                        res({ Bytes: new Uint8Array(buffer) });
+                    })
+                        .catch(err => rej(err));
+                }
+                if (bytes instanceof ArrayBuffer || bytes instanceof Buffer) {
+                    res({ Bytes: new Uint8Array(bytes) });
+                }
+                // everything else can be directly passed to Rekognition / Textract.
+                res({ Bytes: bytes });
+            }
+            else {
+                rej('Input source is not configured correctly.');
+            }
+        });
+    }
+    /**
+     * Recognize text from real-world images and documents (plain text, forms and tables). Detects text in the input
+     * image and converts it into machine-readable text.
+     * @param {IdentifySource} source - Object containing the source image and feature types to analyze.
+     * @return {Promise<IdentifyTextOutput>} - Promise resolving to object containing identified texts.
+     */
+    async identifyText(input) {
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        const { identifyText = {} } = core_1.Amplify.getConfig().Predictions?.identify ?? {};
+        const { region = '', defaults = {} } = identifyText;
+        const { format: configFormat = 'PLAIN' } = defaults;
+        this.rekognitionClient = new client_rekognition_1.RekognitionClient({
+            region,
+            credentials,
+            customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
+        });
+        this.textractClient = new client_textract_1.TextractClient({
+            region,
+            credentials,
+            customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
+        });
+        let inputDocument;
+        inputDocument = await this.configureSource(input.text?.source);
+        // get default value if format isn't specified in the input.
+        const format = input.text?.format ?? configFormat;
+        const featureTypes = []; // structures we want to analyze (e.g. [TABLES, FORMS]).
+        if (format === 'FORM' || format === 'ALL')
+            featureTypes.push('FORMS');
+        if (format === 'TABLE' || format === 'ALL')
+            featureTypes.push('TABLES');
+        if (featureTypes.length === 0) {
+            /**
+             * Empty featureTypes indicates that we will identify plain text. We will use rekognition (suitable
+             * for everyday images but has 50 word limit) first and see if reaches its word limit. If it does, then
+             * we call textract and use the data that identify more words.
+             */
+            const textractParam = {
+                Document: inputDocument,
+            };
+            const rekognitionParam = {
+                Image: inputDocument,
+            };
+            const detectTextCommand = new client_rekognition_1.DetectTextCommand(rekognitionParam);
+            const rekognitionData = await this.rekognitionClient.send(detectTextCommand);
+            const rekognitionResponse = (0, IdentifyTextUtils_1.categorizeRekognitionBlocks)(rekognitionData.TextDetections);
+            if (rekognitionResponse.text.words.length < 50) {
+                // did not hit the word limit, return the data
+                return rekognitionResponse;
+            }
+            const detectDocumentTextCommand = new client_textract_1.DetectDocumentTextCommand(textractParam);
+            const { Blocks } = await this.textractClient.send(detectDocumentTextCommand);
+            if ((rekognitionData.TextDetections?.length ?? 0) > (Blocks?.length ?? 0)) {
+                return rekognitionResponse;
+            }
+            return (0, IdentifyTextUtils_1.categorizeTextractBlocks)(Blocks);
+        }
+        else {
+            const param = {
+                Document: inputDocument,
+                FeatureTypes: featureTypes,
+            };
+            const analyzeDocumentCommand = new client_textract_1.AnalyzeDocumentCommand(param);
+            const { Blocks } = await this.textractClient.send(analyzeDocumentCommand);
+            return (0, IdentifyTextUtils_1.categorizeTextractBlocks)(Blocks);
+        }
+    }
+    /**
+     * Identify instances of real world entities from an image and if it contains unsafe content.
+     * @param {IdentifyLabelsInput} input - Object containing the source image and entity type to identify.
+     * @return {Promise<IdentifyLabelsOutput>} - Promise resolving to an array of identified entities.
+     */
+    async identifyLabels(input) {
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        const { identifyLabels = {} } = core_1.Amplify.getConfig().Predictions?.identify ?? {};
+        const { region = '', defaults = {} } = identifyLabels;
+        const { type = 'LABELS' } = defaults;
+        this.rekognitionClient = new client_rekognition_1.RekognitionClient({
+            region,
+            credentials,
+            customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
+        });
+        const inputImage = await this.configureSource(input.labels?.source);
+        const param = { Image: inputImage };
+        const servicePromises = [];
+        // get default argument
+        const entityType = input.labels?.type ?? type;
+        if (entityType === 'LABELS' || entityType === 'ALL') {
+            servicePromises.push(this.detectLabels(param));
+        }
+        if (entityType === 'UNSAFE' || entityType === 'ALL') {
+            servicePromises.push(this.detectModerationLabels(param));
+        }
+        return Promise.all(servicePromises).then(data => {
+            let identifyResult = {};
+            // concatenate resolved promises to a single object
+            data.forEach(val => {
+                identifyResult = { ...identifyResult, ...val };
+            });
+            return identifyResult;
+        });
+    }
+    /**
+     * Calls Rekognition.detectLabels and organizes the returned data.
+     * @param {DetectLabelsInput} param - parameter to be passed onto Rekognition
+     * @return {Promise<IdentifyLabelsOutput>} - Promise resolving to organized detectLabels response.
+     */
+    async detectLabels(param) {
+        const detectLabelsCommand = new client_rekognition_1.DetectLabelsCommand(param);
+        const data = await this.rekognitionClient.send(detectLabelsCommand);
+        if (!data.Labels)
+            return {}; // no image was detected
+        const detectLabelData = data.Labels.map(label => {
+            const boxes = label.Instances?.map(instance => (0, Utils_1.makeCamelCase)(instance.BoundingBox)) || [];
+            return {
+                name: label.Name,
+                boundingBoxes: boxes,
+                metadata: {
+                    confidence: label.Confidence,
+                    parents: (0, Utils_1.makeCamelCaseArray)(label.Parents),
+                },
+            };
+        });
+        return { labels: detectLabelData };
+    }
+    /**
+     * Calls Rekognition.detectModerationLabels and organizes the returned data.
+     * @param {Rekognition.DetectLabelsRequest} param - Parameter to be passed onto Rekognition
+     * @return {Promise<IdentifyLabelsOutput>} - Promise resolving to organized detectModerationLabels response.
+     */
+    async detectModerationLabels(param) {
+        const detectModerationLabelsCommand = new client_rekognition_1.DetectModerationLabelsCommand(param);
+        const data = await this.rekognitionClient.send(detectModerationLabelsCommand);
+        if (data.ModerationLabels?.length !== 0) {
+            return { unsafe: 'YES' };
+        }
+        else {
+            return { unsafe: 'NO' };
+        }
+    }
+    /**
+     * Identify faces within an image that is provided as input, and match faces from a collection
+     * or identify celebrities.
+     * @param {IdentifyEntityInput} input - object containing the source image and face match options.
+     * @return {Promise<IdentifyEntityOutput>} Promise resolving to identify results.
+     */
+    async identifyEntities(input) {
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        const { identifyEntities = {} } = core_1.Amplify.getConfig().Predictions?.identify ?? {};
+        const { region = '', celebrityDetectionEnabled = false, defaults = {}, } = identifyEntities;
+        const { collectionId: collectionIdConfig = '', maxEntities: maxFacesConfig = 50, } = defaults;
+        // default arguments
+        this.rekognitionClient = new client_rekognition_1.RekognitionClient({
+            region,
+            credentials,
+            customUserAgent: _getPredictionsIdentifyAmplifyUserAgent(),
+        });
+        const inputImage = await this.configureSource(input.entities?.source);
+        const param = { Attributes: ['ALL'], Image: inputImage };
+        if ((0, types_1.isIdentifyCelebrities)(input.entities) &&
+            input.entities.celebrityDetection) {
+            (0, assertValidationError_1.assertValidationError)(celebrityDetectionEnabled, validation_1.PredictionsValidationErrorCode.CelebrityDetectionNotEnabled);
+            const recognizeCelebritiesCommand = new client_rekognition_1.RecognizeCelebritiesCommand(param);
+            const data = await this.rekognitionClient.send(recognizeCelebritiesCommand);
+            const faces = data.CelebrityFaces?.map(celebrity => ({
+                boundingBox: (0, Utils_1.makeCamelCase)(celebrity.Face?.BoundingBox),
+                landmarks: (0, Utils_1.makeCamelCaseArray)(celebrity.Face?.Landmarks),
+                metadata: {
+                    ...(0, Utils_1.makeCamelCase)(celebrity, ['Id', 'Name', 'Urls']),
+                    pose: (0, Utils_1.makeCamelCase)(celebrity.Face?.Pose),
+                },
+            })) ?? [];
+            return { entities: faces };
+        }
+        else if ((0, types_1.isIdentifyFromCollection)(input.entities) &&
+            input.entities.collection) {
+            const { collectionId = collectionIdConfig, maxEntities: maxFaces = maxFacesConfig, } = input.entities;
+            // Concatenate additional parameters
+            const updatedParam = {
+                ...param,
+                CollectionId: collectionId,
+                MaxFaces: maxFaces,
+            };
+            const searchFacesByImageCommand = new client_rekognition_1.SearchFacesByImageCommand(updatedParam);
+            const data = await this.rekognitionClient.send(searchFacesByImageCommand);
+            const faces = data.FaceMatches?.map(match => {
+                const externalImageId = match.Face?.ExternalImageId
+                    ? this.decodeExternalImageId(match.Face.ExternalImageId)
+                    : undefined;
+                return {
+                    boundingBox: (0, Utils_1.makeCamelCase)(match.Face?.BoundingBox),
+                    metadata: {
+                        externalImageId,
+                        similarity: match.Similarity,
+                    },
+                };
+            }) ?? [];
+            return { entities: faces };
+        }
+        else {
+            const detectFacesCommand = new client_rekognition_1.DetectFacesCommand(param);
+            const data = await this.rekognitionClient.send(detectFacesCommand);
+            const faces = data.FaceDetails?.map(detail => {
+                // face attributes keys we want to extract from Rekognition's response
+                const attributeKeys = [
+                    'Smile',
+                    'Eyeglasses',
+                    'Sunglasses',
+                    'Gender',
+                    'Beard',
+                    'Mustache',
+                    'EyesOpen',
+                    'MouthOpen',
+                ];
+                const faceAttributes = (0, Utils_1.makeCamelCase)(detail, attributeKeys);
+                faceAttributes.emotions = detail.Emotions?.map(emotion => emotion.Type);
+                return {
+                    boundingBox: (0, Utils_1.makeCamelCase)(detail.BoundingBox),
+                    landmarks: (0, Utils_1.makeCamelCaseArray)(detail.Landmarks),
+                    ageRange: (0, Utils_1.makeCamelCase)(detail.AgeRange),
+                    attributes: faceAttributes,
+                    metadata: {
+                        confidence: detail.Confidence,
+                        pose: (0, Utils_1.makeCamelCase)(detail.Pose),
+                    },
+                };
+            }) ?? [];
+            return { entities: faces };
+        }
+    }
+    decodeExternalImageId(externalImageId) {
+        return ('' + externalImageId).replace(/::/g, '/');
+    }
+}
+exports.AmazonAIIdentifyPredictionsProvider = AmazonAIIdentifyPredictionsProvider;
+function _getPredictionsIdentifyAmplifyUserAgent() {
+    return (0, utils_1.getAmplifyUserAgentObject)({
+        category: utils_1.Category.Predictions,
+        action: utils_1.PredictionsAction.Identify,
+    });
+}

package/lib/{Providers → providers}/AmazonAIInterpretPredictionsProvider.d.ts

@@ -1,9 +1,8 @@
-import { AbstractInterpretPredictionsProvider } from '../types/Providers';
 import { InterpretTextInput, InterpretTextOutput } from '../types';
-export declare class AmazonAIInterpretPredictionsProvider extends AbstractInterpretPredictionsProvider {
-    private comprehendClient;
-    constructor();
+export declare class AmazonAIInterpretPredictionsProvider {
+    private comprehendClient?;
     getProviderName(): string;
+    interpret(input: InterpretTextInput): Promise<InterpretTextOutput>;
     interpretText(input: InterpretTextInput): Promise<InterpretTextOutput>;
     private detectKeyPhrases;
     private detectSyntax;