@aws-sdk/client-rekognitionstreaming 3.305.0

package/dist-cjs/runtimeConfig.native.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = void 0;
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+const invalid_dependency_1 = require("@aws-sdk/invalid-dependency");
+const runtimeConfig_browser_1 = require("./runtimeConfig.browser");
+const getRuntimeConfig = (config) => {
+    const browserDefaults = (0, runtimeConfig_browser_1.getRuntimeConfig)(config);
+    return {
+        ...browserDefaults,
+        ...config,
+        runtime: "react-native",
+        eventStreamPayloadHandlerProvider: config?.eventStreamPayloadHandlerProvider ??
+            (() => ({ handle: (0, invalid_dependency_1.invalidFunction)("event stream request is not supported in ReactNative.") })),
+        sha256: config?.sha256 ?? sha256_js_1.Sha256,
+    };
+};
+exports.getRuntimeConfig = getRuntimeConfig;

package/dist-cjs/runtimeConfig.shared.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = void 0;
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const url_parser_1 = require("@aws-sdk/url-parser");
+const util_base64_1 = require("@aws-sdk/util-base64");
+const util_utf8_1 = require("@aws-sdk/util-utf8");
+const endpointResolver_1 = require("./endpoint/endpointResolver");
+const getRuntimeConfig = (config) => ({
+    apiVersion: "2022-05-30",
+    base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64,
+    base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64,
+    disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver,
+    logger: config?.logger ?? new smithy_client_1.NoOpLogger(),
+    serviceId: config?.serviceId ?? "RekognitionStreaming",
+    urlParser: config?.urlParser ?? url_parser_1.parseUrl,
+    utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8,
+    utf8Encoder: config?.utf8Encoder ?? util_utf8_1.toUtf8,
+});
+exports.getRuntimeConfig = getRuntimeConfig;

package/dist-es/RekognitionStreaming.js

@@ -0,0 +1,33 @@
+import { StartFaceLivenessSessionCommand, } from "./commands/StartFaceLivenessSessionCommand";
+import { StartStreamingLivenessSessionCommand, } from "./commands/StartStreamingLivenessSessionCommand";
+import { RekognitionStreamingClient } from "./RekognitionStreamingClient";
+export class RekognitionStreaming extends RekognitionStreamingClient {
+    startFaceLivenessSession(args, optionsOrCb, cb) {
+        const command = new StartFaceLivenessSessionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    startStreamingLivenessSession(args, optionsOrCb, cb) {
+        const command = new StartStreamingLivenessSessionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+}

package/dist-es/RekognitionStreamingClient.js

@@ -0,0 +1,42 @@
+import { resolveRegionConfig } from "@aws-sdk/config-resolver";
+import { resolveEventStreamSerdeConfig, } from "@aws-sdk/eventstream-serde-config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { resolveEndpointConfig } from "@aws-sdk/middleware-endpoint";
+import { resolveEventStreamConfig, } from "@aws-sdk/middleware-eventstream";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { resolveWebSocketConfig } from "@aws-sdk/middleware-websocket";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { resolveClientEndpointParameters, } from "./endpoint/EndpointParameters";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+export class RekognitionStreamingClient extends __Client {
+    constructor(configuration) {
+        const _config_0 = __getRuntimeConfig(configuration);
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = resolveRegionConfig(_config_1);
+        const _config_3 = resolveEndpointConfig(_config_2);
+        const _config_4 = resolveRetryConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveAwsAuthConfig(_config_5);
+        const _config_7 = resolveEventStreamConfig(_config_6);
+        const _config_8 = resolveWebSocketConfig(_config_7);
+        const _config_9 = resolveUserAgentConfig(_config_8);
+        const _config_10 = resolveEventStreamSerdeConfig(_config_9);
+        super(_config_10);
+        this.config = _config_10;
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}

package/dist-es/commands/StartFaceLivenessSessionCommand.js

@@ -0,0 +1,46 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getEventStreamPlugin } from "@aws-sdk/middleware-eventstream";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { getWebSocketPlugin } from "@aws-sdk/middleware-websocket";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartFaceLivenessSessionRequestFilterSensitiveLog, StartFaceLivenessSessionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartFaceLivenessSessionCommand, serializeAws_restJson1StartFaceLivenessSessionCommand, } from "../protocols/Aws_restJson1";
+export class StartFaceLivenessSessionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartFaceLivenessSessionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEventStreamPlugin(configuration));
+        this.middlewareStack.use(getWebSocketPlugin(configuration, { headerPrefix: "x-amz-rekognition-streaming-liveness-" }));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionStreamingClient";
+        const commandName = "StartFaceLivenessSessionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartFaceLivenessSessionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartFaceLivenessSessionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartFaceLivenessSessionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartFaceLivenessSessionCommand(output, context);
+    }
+}

package/dist-es/commands/StartStreamingLivenessSessionCommand.js

@@ -0,0 +1,46 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getEventStreamPlugin } from "@aws-sdk/middleware-eventstream";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { getWebSocketPlugin } from "@aws-sdk/middleware-websocket";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartStreamingLivenessSessionRequestFilterSensitiveLog, StartStreamingLivenessSessionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartStreamingLivenessSessionCommand, serializeAws_restJson1StartStreamingLivenessSessionCommand, } from "../protocols/Aws_restJson1";
+export class StartStreamingLivenessSessionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartStreamingLivenessSessionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEventStreamPlugin(configuration));
+        this.middlewareStack.use(getWebSocketPlugin(configuration, { headerPrefix: "x-amz-rekognition-streaming-liveness-" }));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionStreamingClient";
+        const commandName = "StartStreamingLivenessSessionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartStreamingLivenessSessionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartStreamingLivenessSessionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartStreamingLivenessSessionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartStreamingLivenessSessionCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -0,0 +1,2 @@
+export * from "./StartFaceLivenessSessionCommand";
+export * from "./StartStreamingLivenessSessionCommand";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "rekognition",
+    };
+};

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,8 @@
+import { resolveEndpoint } from "@aws-sdk/util-endpoints";
+import { ruleSet } from "./ruleset";
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    });
+};

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,4 @@
+const p = "required", q = "fn", r = "argv", s = "ref";
+const a = "PartitionResult", b = "tree", c = "error", d = "endpoint", e = { [p]: false, "type": "String" }, f = { [p]: true, "default": false, "type": "Boolean" }, g = { [s]: "Endpoint" }, h = { [q]: "booleanEquals", [r]: [{ [s]: "UseFIPS" }, true] }, i = { [q]: "booleanEquals", [r]: [{ [s]: "UseDualStack" }, true] }, j = {}, k = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: a }, "supportsFIPS"] }] }, l = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: a }, "supportsDualStack"] }] }, m = [g], n = [h], o = [i];
+const _data = { version: "1.0", parameters: { Region: e, UseDualStack: f, UseFIPS: f, Endpoint: e }, rules: [{ conditions: [{ [q]: "aws.partition", [r]: [{ [s]: "Region" }], assign: a }], type: b, rules: [{ conditions: [{ [q]: "isSet", [r]: m }, { [q]: "parseURL", [r]: m, assign: "url" }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: g, properties: j, headers: j }, type: d }] }] }, { conditions: [h, i], type: b, rules: [{ conditions: [k, l], type: b, rules: [{ endpoint: { url: "https://rekognitionstreaming-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [k], type: b, rules: [{ endpoint: { url: "https://rekognitionstreaming-fips.{Region}.{PartitionResult#dnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [l], type: b, rules: [{ endpoint: { url: "https://rekognitionstreaming.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { endpoint: { url: "https://rekognitionstreaming.{Region}.{PartitionResult#dnsSuffix}", properties: j, headers: j }, type: d }] }] };
+export const ruleSet = _data;

package/dist-es/index.js

@@ -0,0 +1,5 @@
+export * from "./RekognitionStreaming";
+export * from "./RekognitionStreamingClient";
+export * from "./commands";
+export * from "./models";
+export { RekognitionStreamingServiceException } from "./models/RekognitionStreamingServiceException";

package/dist-es/models/RekognitionStreamingServiceException.js

@@ -0,0 +1,7 @@
+import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
+export class RekognitionStreamingServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, RekognitionStreamingServiceException.prototype);
+    }
+}

package/dist-es/models/index.js

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-es/models/models_0.js

@@ -0,0 +1,173 @@
+import { RekognitionStreamingServiceException as __BaseException } from "./RekognitionStreamingServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+        this.Code = opts.Code;
+    }
+}
+export var ClientChallenge;
+(function (ClientChallenge) {
+    ClientChallenge.visit = (value, visitor) => {
+        if (value.FaceMovementAndLightChallenge !== undefined)
+            return visitor.FaceMovementAndLightChallenge(value.FaceMovementAndLightChallenge);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ClientChallenge || (ClientChallenge = {}));
+export const LightChallengeType = {
+    SEQUENTIAL: "SEQUENTIAL",
+    SIMULTANEOUS: "SIMULTANEOUS",
+};
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.Message = opts.Message;
+        this.Code = opts.Code;
+    }
+}
+export var LivenessRequestStream;
+(function (LivenessRequestStream) {
+    LivenessRequestStream.visit = (value, visitor) => {
+        if (value.VideoEvent !== undefined)
+            return visitor.VideoEvent(value.VideoEvent);
+        if (value.ClientSessionInformationEvent !== undefined)
+            return visitor.ClientSessionInformationEvent(value.ClientSessionInformationEvent);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(LivenessRequestStream || (LivenessRequestStream = {}));
+export var ServerChallenge;
+(function (ServerChallenge) {
+    ServerChallenge.visit = (value, visitor) => {
+        if (value.FaceMovementAndLightChallenge !== undefined)
+            return visitor.FaceMovementAndLightChallenge(value.FaceMovementAndLightChallenge);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ServerChallenge || (ServerChallenge = {}));
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.Message = opts.Message;
+        this.Code = opts.Code;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+        this.Code = opts.Code;
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.Message = opts.Message;
+        this.Code = opts.Code;
+    }
+}
+export var LivenessResponseStream;
+(function (LivenessResponseStream) {
+    LivenessResponseStream.visit = (value, visitor) => {
+        if (value.ServerSessionInformationEvent !== undefined)
+            return visitor.ServerSessionInformationEvent(value.ServerSessionInformationEvent);
+        if (value.DisconnectionEvent !== undefined)
+            return visitor.DisconnectionEvent(value.DisconnectionEvent);
+        if (value.ValidationException !== undefined)
+            return visitor.ValidationException(value.ValidationException);
+        if (value.InternalServerException !== undefined)
+            return visitor.InternalServerException(value.InternalServerException);
+        if (value.ThrottlingException !== undefined)
+            return visitor.ThrottlingException(value.ThrottlingException);
+        if (value.ServiceQuotaExceededException !== undefined)
+            return visitor.ServiceQuotaExceededException(value.ServiceQuotaExceededException);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(LivenessResponseStream || (LivenessResponseStream = {}));
+export class SessionNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "SessionNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "SessionNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, SessionNotFoundException.prototype);
+        this.Message = opts.Message;
+        this.Code = opts.Code;
+    }
+}
+export const LivenessRequestStreamFilterSensitiveLog = (obj) => {
+    if (obj.VideoEvent !== undefined)
+        return { VideoEvent: obj.VideoEvent };
+    if (obj.ClientSessionInformationEvent !== undefined)
+        return { ClientSessionInformationEvent: obj.ClientSessionInformationEvent };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const LivenessResponseStreamFilterSensitiveLog = (obj) => {
+    if (obj.ServerSessionInformationEvent !== undefined)
+        return { ServerSessionInformationEvent: obj.ServerSessionInformationEvent };
+    if (obj.DisconnectionEvent !== undefined)
+        return { DisconnectionEvent: obj.DisconnectionEvent };
+    if (obj.ValidationException !== undefined)
+        return { ValidationException: obj.ValidationException };
+    if (obj.InternalServerException !== undefined)
+        return { InternalServerException: obj.InternalServerException };
+    if (obj.ThrottlingException !== undefined)
+        return { ThrottlingException: obj.ThrottlingException };
+    if (obj.ServiceQuotaExceededException !== undefined)
+        return { ServiceQuotaExceededException: obj.ServiceQuotaExceededException };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const StartFaceLivenessSessionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LivenessRequestStream && { LivenessRequestStream: "STREAMING_CONTENT" }),
+});
+export const StartFaceLivenessSessionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LivenessResponseStream && { LivenessResponseStream: "STREAMING_CONTENT" }),
+});
+export const StartStreamingLivenessSessionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LivenessRequestStream && { LivenessRequestStream: "STREAMING_CONTENT" }),
+});
+export const StartStreamingLivenessSessionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LivenessResponseStream && { LivenessResponseStream: "STREAMING_CONTENT" }),
+});