@aws-sdk/client-rekognitionstreaming 3.305.0

package/dist-types/ts3.4/RekognitionStreamingClient.d.ts

@@ -0,0 +1,147 @@
+import {
+  RegionInputConfig,
+  RegionResolvedConfig,
+} from "@aws-sdk/config-resolver";
+import {
+  EventStreamSerdeInputConfig,
+  EventStreamSerdeResolvedConfig,
+} from "@aws-sdk/eventstream-serde-config-resolver";
+import {
+  EndpointInputConfig,
+  EndpointResolvedConfig,
+} from "@aws-sdk/middleware-endpoint";
+import {
+  EventStreamInputConfig,
+  EventStreamResolvedConfig,
+} from "@aws-sdk/middleware-eventstream";
+import {
+  HostHeaderInputConfig,
+  HostHeaderResolvedConfig,
+} from "@aws-sdk/middleware-host-header";
+import {
+  RetryInputConfig,
+  RetryResolvedConfig,
+} from "@aws-sdk/middleware-retry";
+import {
+  AwsAuthInputConfig,
+  AwsAuthResolvedConfig,
+} from "@aws-sdk/middleware-signing";
+import {
+  UserAgentInputConfig,
+  UserAgentResolvedConfig,
+} from "@aws-sdk/middleware-user-agent";
+import {
+  WebSocketInputConfig,
+  WebSocketResolvedConfig,
+} from "@aws-sdk/middleware-websocket";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import {
+  Client as __Client,
+  DefaultsMode as __DefaultsMode,
+  SmithyConfiguration as __SmithyConfiguration,
+  SmithyResolvedConfiguration as __SmithyResolvedConfiguration,
+} from "@aws-sdk/smithy-client";
+import {
+  BodyLengthCalculator as __BodyLengthCalculator,
+  ChecksumConstructor as __ChecksumConstructor,
+  Credentials as __Credentials,
+  Decoder as __Decoder,
+  Encoder as __Encoder,
+  EventStreamPayloadHandlerProvider as __EventStreamPayloadHandlerProvider,
+  EventStreamSerdeProvider as __EventStreamSerdeProvider,
+  HashConstructor as __HashConstructor,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  Logger as __Logger,
+  Provider as __Provider,
+  Provider,
+  StreamCollector as __StreamCollector,
+  UrlParser as __UrlParser,
+  UserAgent as __UserAgent,
+} from "@aws-sdk/types";
+import {
+  StartFaceLivenessSessionCommandInput,
+  StartFaceLivenessSessionCommandOutput,
+} from "./commands/StartFaceLivenessSessionCommand";
+import {
+  StartStreamingLivenessSessionCommandInput,
+  StartStreamingLivenessSessionCommandOutput,
+} from "./commands/StartStreamingLivenessSessionCommand";
+import {
+  ClientInputEndpointParameters,
+  ClientResolvedEndpointParameters,
+  EndpointParameters,
+} from "./endpoint/EndpointParameters";
+export type ServiceInputTypes =
+  | StartFaceLivenessSessionCommandInput
+  | StartStreamingLivenessSessionCommandInput;
+export type ServiceOutputTypes =
+  | StartFaceLivenessSessionCommandOutput
+  | StartStreamingLivenessSessionCommandOutput;
+export interface ClientDefaults
+  extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+  requestHandler?: __HttpHandler;
+  sha256?: __ChecksumConstructor | __HashConstructor;
+  urlParser?: __UrlParser;
+  bodyLengthChecker?: __BodyLengthCalculator;
+  streamCollector?: __StreamCollector;
+  base64Decoder?: __Decoder;
+  base64Encoder?: __Encoder;
+  utf8Decoder?: __Decoder;
+  utf8Encoder?: __Encoder;
+  runtime?: string;
+  disableHostPrefix?: boolean;
+  serviceId?: string;
+  useDualstackEndpoint?: boolean | __Provider<boolean>;
+  useFipsEndpoint?: boolean | __Provider<boolean>;
+  region?: string | __Provider<string>;
+  credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+  eventStreamPayloadHandlerProvider?: __EventStreamPayloadHandlerProvider;
+  defaultUserAgentProvider?: Provider<__UserAgent>;
+  maxAttempts?: number | __Provider<number>;
+  retryMode?: string | __Provider<string>;
+  logger?: __Logger;
+  eventStreamSerdeProvider?: __EventStreamSerdeProvider;
+  defaultsMode?: __DefaultsMode | __Provider<__DefaultsMode>;
+}
+type RekognitionStreamingClientConfigType = Partial<
+  __SmithyConfiguration<__HttpHandlerOptions>
+> &
+  ClientDefaults &
+  RegionInputConfig &
+  EndpointInputConfig<EndpointParameters> &
+  RetryInputConfig &
+  HostHeaderInputConfig &
+  AwsAuthInputConfig &
+  EventStreamInputConfig &
+  WebSocketInputConfig &
+  UserAgentInputConfig &
+  EventStreamSerdeInputConfig &
+  ClientInputEndpointParameters;
+export interface RekognitionStreamingClientConfig
+  extends RekognitionStreamingClientConfigType {}
+type RekognitionStreamingClientResolvedConfigType =
+  __SmithyResolvedConfiguration<__HttpHandlerOptions> &
+    Required<ClientDefaults> &
+    RegionResolvedConfig &
+    EndpointResolvedConfig<EndpointParameters> &
+    RetryResolvedConfig &
+    HostHeaderResolvedConfig &
+    AwsAuthResolvedConfig &
+    EventStreamResolvedConfig &
+    WebSocketResolvedConfig &
+    UserAgentResolvedConfig &
+    EventStreamSerdeResolvedConfig &
+    ClientResolvedEndpointParameters;
+export interface RekognitionStreamingClientResolvedConfig
+  extends RekognitionStreamingClientResolvedConfigType {}
+export declare class RekognitionStreamingClient extends __Client<
+  __HttpHandlerOptions,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+  RekognitionStreamingClientResolvedConfig
+> {
+  readonly config: RekognitionStreamingClientResolvedConfig;
+  constructor(configuration: RekognitionStreamingClientConfig);
+  destroy(): void;
+}
+export {};

package/dist-types/ts3.4/commands/StartFaceLivenessSessionCommand.d.ts

@@ -0,0 +1,41 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  Handler,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+} from "@aws-sdk/types";
+import {
+  StartFaceLivenessSessionRequest,
+  StartFaceLivenessSessionResponse,
+} from "../models/models_0";
+import {
+  RekognitionStreamingClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../RekognitionStreamingClient";
+export interface StartFaceLivenessSessionCommandInput
+  extends StartFaceLivenessSessionRequest {}
+export interface StartFaceLivenessSessionCommandOutput
+  extends StartFaceLivenessSessionResponse,
+    __MetadataBearer {}
+export declare class StartFaceLivenessSessionCommand extends $Command<
+  StartFaceLivenessSessionCommandInput,
+  StartFaceLivenessSessionCommandOutput,
+  RekognitionStreamingClientResolvedConfig
+> {
+  readonly input: StartFaceLivenessSessionCommandInput;
+  static getEndpointParameterInstructions(): EndpointParameterInstructions;
+  constructor(input: StartFaceLivenessSessionCommandInput);
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: RekognitionStreamingClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<
+    StartFaceLivenessSessionCommandInput,
+    StartFaceLivenessSessionCommandOutput
+  >;
+  private serialize;
+  private deserialize;
+}

package/dist-types/ts3.4/commands/StartStreamingLivenessSessionCommand.d.ts

@@ -0,0 +1,41 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  Handler,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+} from "@aws-sdk/types";
+import {
+  StartStreamingLivenessSessionRequest,
+  StartStreamingLivenessSessionResponse,
+} from "../models/models_0";
+import {
+  RekognitionStreamingClientResolvedConfig,
+  ServiceInputTypes,
+  ServiceOutputTypes,
+} from "../RekognitionStreamingClient";
+export interface StartStreamingLivenessSessionCommandInput
+  extends StartStreamingLivenessSessionRequest {}
+export interface StartStreamingLivenessSessionCommandOutput
+  extends StartStreamingLivenessSessionResponse,
+    __MetadataBearer {}
+export declare class StartStreamingLivenessSessionCommand extends $Command<
+  StartStreamingLivenessSessionCommandInput,
+  StartStreamingLivenessSessionCommandOutput,
+  RekognitionStreamingClientResolvedConfig
+> {
+  readonly input: StartStreamingLivenessSessionCommandInput;
+  static getEndpointParameterInstructions(): EndpointParameterInstructions;
+  constructor(input: StartStreamingLivenessSessionCommandInput);
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: RekognitionStreamingClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<
+    StartStreamingLivenessSessionCommandInput,
+    StartStreamingLivenessSessionCommandOutput
+  >;
+  private serialize;
+  private deserialize;
+}

package/dist-types/ts3.4/commands/index.d.ts

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

package/dist-types/ts3.4/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,33 @@
+import {
+  Endpoint,
+  EndpointParameters as __EndpointParameters,
+  EndpointV2,
+  Provider,
+} from "@aws-sdk/types";
+export interface ClientInputEndpointParameters {
+  region?: string | Provider<string>;
+  useDualstackEndpoint?: boolean | Provider<boolean>;
+  useFipsEndpoint?: boolean | Provider<boolean>;
+  endpoint?:
+    | string
+    | Provider<string>
+    | Endpoint
+    | Provider<Endpoint>
+    | EndpointV2
+    | Provider<EndpointV2>;
+}
+export type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
+  defaultSigningName: string;
+};
+export declare const resolveClientEndpointParameters: <T>(
+  options: T & ClientInputEndpointParameters
+) => T &
+  ClientInputEndpointParameters & {
+    defaultSigningName: string;
+  };
+export interface EndpointParameters extends __EndpointParameters {
+  Region?: string;
+  UseDualStack?: boolean;
+  UseFIPS?: boolean;
+  Endpoint?: string;
+}

package/dist-types/ts3.4/endpoint/endpointResolver.d.ts

@@ -0,0 +1,8 @@
+import { EndpointV2, Logger } from "@aws-sdk/types";
+import { EndpointParameters } from "./EndpointParameters";
+export declare const defaultEndpointResolver: (
+  endpointParams: EndpointParameters,
+  context?: {
+    logger?: Logger;
+  }
+) => EndpointV2;

package/dist-types/ts3.4/endpoint/ruleset.d.ts

@@ -0,0 +1,2 @@
+import { RuleSetObject } from "@aws-sdk/util-endpoints";
+export declare const ruleSet: RuleSetObject;

package/dist-types/ts3.4/index.d.ts

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

package/dist-types/ts3.4/models/RekognitionStreamingServiceException.d.ts

@@ -0,0 +1,7 @@
+import {
+  ServiceException as __ServiceException,
+  ServiceExceptionOptions as __ServiceExceptionOptions,
+} from "@aws-sdk/smithy-client";
+export declare class RekognitionStreamingServiceException extends __ServiceException {
+  constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/ts3.4/models/index.d.ts

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

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,316 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RekognitionStreamingServiceException as __BaseException } from "./RekognitionStreamingServiceException";
+export declare class AccessDeniedException extends __BaseException {
+  readonly name: "AccessDeniedException";
+  readonly $fault: "client";
+  Message?: string;
+  Code?: string;
+  constructor(
+    opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
+  );
+}
+export interface BoundingBox {
+  Width: number | undefined;
+  Height: number | undefined;
+  Left: number | undefined;
+  Top: number | undefined;
+}
+export interface FreshnessColor {
+  RGB: number[] | undefined;
+}
+export interface ColorDisplayed {
+  CurrentColor: FreshnessColor | undefined;
+  PreviousColor?: FreshnessColor;
+  SequenceNumber: number | undefined;
+  CurrentColorStartTimestamp: number | undefined;
+}
+export interface InitialFace {
+  BoundingBox: BoundingBox | undefined;
+  InitialFaceDetectedTimestamp: number | undefined;
+}
+export interface TargetFace {
+  BoundingBox: BoundingBox | undefined;
+  FaceDetectedInTargetPositionStartTimestamp: number | undefined;
+  FaceDetectedInTargetPositionEndTimestamp: number | undefined;
+}
+export interface FaceMovementAndLightClientChallenge {
+  ChallengeId: string | undefined;
+  VideoStartTimestamp?: number;
+  InitialFace?: InitialFace;
+  TargetFace?: TargetFace;
+  ColorDisplayed?: ColorDisplayed;
+}
+export type ClientChallenge =
+  | ClientChallenge.FaceMovementAndLightChallengeMember
+  | ClientChallenge.$UnknownMember;
+export declare namespace ClientChallenge {
+  interface FaceMovementAndLightChallengeMember {
+    FaceMovementAndLightChallenge: FaceMovementAndLightClientChallenge;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    FaceMovementAndLightChallenge?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    FaceMovementAndLightChallenge: (
+      value: FaceMovementAndLightClientChallenge
+    ) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ClientChallenge, visitor: Visitor<T>) => T;
+}
+export interface DeviceInformation {
+  VideoHeight: number | undefined;
+  VideoWidth: number | undefined;
+  ClientSDKVersion: string | undefined;
+}
+export interface ClientSessionInformationEvent {
+  DeviceInformation: DeviceInformation | undefined;
+  Challenge: ClientChallenge | undefined;
+}
+export interface ColorSequence {
+  FreshnessColor: FreshnessColor | undefined;
+  DownscrollDuration: number | undefined;
+  FlatDisplayDuration: number | undefined;
+}
+export interface DisconnectionEvent {
+  TimestampMillis: number | undefined;
+}
+export declare const LightChallengeType: {
+  readonly SEQUENTIAL: "SEQUENTIAL";
+  readonly SIMULTANEOUS: "SIMULTANEOUS";
+};
+export type LightChallengeType =
+  (typeof LightChallengeType)[keyof typeof LightChallengeType];
+export interface OvalScaleFactors {
+  Width: number | undefined;
+  CenterX: number | undefined;
+  CenterY: number | undefined;
+}
+export interface FaceMovementAndLightServerChallenge {
+  OvalScaleFactors: OvalScaleFactors | undefined;
+  LightChallengeType: LightChallengeType | string | undefined;
+  ColorSequences: ColorSequence[] | undefined;
+}
+export declare class InternalServerException extends __BaseException {
+  readonly name: "InternalServerException";
+  readonly $fault: "server";
+  Message?: string;
+  Code?: string;
+  constructor(
+    opts: __ExceptionOptionType<InternalServerException, __BaseException>
+  );
+}
+export interface VideoEvent {
+  VideoChunk?: Uint8Array;
+  TimestampMillis?: number;
+}
+export type LivenessRequestStream =
+  | LivenessRequestStream.ClientSessionInformationEventMember
+  | LivenessRequestStream.VideoEventMember
+  | LivenessRequestStream.$UnknownMember;
+export declare namespace LivenessRequestStream {
+  interface VideoEventMember {
+    VideoEvent: VideoEvent;
+    ClientSessionInformationEvent?: never;
+    $unknown?: never;
+  }
+  interface ClientSessionInformationEventMember {
+    VideoEvent?: never;
+    ClientSessionInformationEvent: ClientSessionInformationEvent;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    VideoEvent?: never;
+    ClientSessionInformationEvent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    VideoEvent: (value: VideoEvent) => T;
+    ClientSessionInformationEvent: (value: ClientSessionInformationEvent) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: LivenessRequestStream, visitor: Visitor<T>) => T;
+}
+export type ServerChallenge =
+  | ServerChallenge.FaceMovementAndLightChallengeMember
+  | ServerChallenge.$UnknownMember;
+export declare namespace ServerChallenge {
+  interface FaceMovementAndLightChallengeMember {
+    FaceMovementAndLightChallenge: FaceMovementAndLightServerChallenge;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    FaceMovementAndLightChallenge?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    FaceMovementAndLightChallenge: (
+      value: FaceMovementAndLightServerChallenge
+    ) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ServerChallenge, visitor: Visitor<T>) => T;
+}
+export interface SessionInformation {
+  Challenge: ServerChallenge | undefined;
+}
+export interface ServerSessionInformationEvent {
+  SessionInformation: SessionInformation | undefined;
+}
+export declare class ServiceQuotaExceededException extends __BaseException {
+  readonly name: "ServiceQuotaExceededException";
+  readonly $fault: "client";
+  Message?: string;
+  Code?: string;
+  constructor(
+    opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>
+  );
+}
+export declare class ThrottlingException extends __BaseException {
+  readonly name: "ThrottlingException";
+  readonly $fault: "client";
+  Message?: string;
+  Code?: string;
+  constructor(
+    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
+  );
+}
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  Message?: string;
+  Code?: string;
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export type LivenessResponseStream =
+  | LivenessResponseStream.DisconnectionEventMember
+  | LivenessResponseStream.InternalServerExceptionMember
+  | LivenessResponseStream.ServerSessionInformationEventMember
+  | LivenessResponseStream.ServiceQuotaExceededExceptionMember
+  | LivenessResponseStream.ThrottlingExceptionMember
+  | LivenessResponseStream.ValidationExceptionMember
+  | LivenessResponseStream.$UnknownMember;
+export declare namespace LivenessResponseStream {
+  interface ServerSessionInformationEventMember {
+    ServerSessionInformationEvent: ServerSessionInformationEvent;
+    DisconnectionEvent?: never;
+    ValidationException?: never;
+    InternalServerException?: never;
+    ThrottlingException?: never;
+    ServiceQuotaExceededException?: never;
+    $unknown?: never;
+  }
+  interface DisconnectionEventMember {
+    ServerSessionInformationEvent?: never;
+    DisconnectionEvent: DisconnectionEvent;
+    ValidationException?: never;
+    InternalServerException?: never;
+    ThrottlingException?: never;
+    ServiceQuotaExceededException?: never;
+    $unknown?: never;
+  }
+  interface ValidationExceptionMember {
+    ServerSessionInformationEvent?: never;
+    DisconnectionEvent?: never;
+    ValidationException: ValidationException;
+    InternalServerException?: never;
+    ThrottlingException?: never;
+    ServiceQuotaExceededException?: never;
+    $unknown?: never;
+  }
+  interface InternalServerExceptionMember {
+    ServerSessionInformationEvent?: never;
+    DisconnectionEvent?: never;
+    ValidationException?: never;
+    InternalServerException: InternalServerException;
+    ThrottlingException?: never;
+    ServiceQuotaExceededException?: never;
+    $unknown?: never;
+  }
+  interface ThrottlingExceptionMember {
+    ServerSessionInformationEvent?: never;
+    DisconnectionEvent?: never;
+    ValidationException?: never;
+    InternalServerException?: never;
+    ThrottlingException: ThrottlingException;
+    ServiceQuotaExceededException?: never;
+    $unknown?: never;
+  }
+  interface ServiceQuotaExceededExceptionMember {
+    ServerSessionInformationEvent?: never;
+    DisconnectionEvent?: never;
+    ValidationException?: never;
+    InternalServerException?: never;
+    ThrottlingException?: never;
+    ServiceQuotaExceededException: ServiceQuotaExceededException;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    ServerSessionInformationEvent?: never;
+    DisconnectionEvent?: never;
+    ValidationException?: never;
+    InternalServerException?: never;
+    ThrottlingException?: never;
+    ServiceQuotaExceededException?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    ServerSessionInformationEvent: (value: ServerSessionInformationEvent) => T;
+    DisconnectionEvent: (value: DisconnectionEvent) => T;
+    ValidationException: (value: ValidationException) => T;
+    InternalServerException: (value: InternalServerException) => T;
+    ThrottlingException: (value: ThrottlingException) => T;
+    ServiceQuotaExceededException: (value: ServiceQuotaExceededException) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: LivenessResponseStream, visitor: Visitor<T>) => T;
+}
+export declare class SessionNotFoundException extends __BaseException {
+  readonly name: "SessionNotFoundException";
+  readonly $fault: "client";
+  Message?: string;
+  Code?: string;
+  constructor(
+    opts: __ExceptionOptionType<SessionNotFoundException, __BaseException>
+  );
+}
+export interface StartFaceLivenessSessionRequest {
+  SessionId: string | undefined;
+  ClientSDKVersion: string | undefined;
+  LivenessRequestStream?: AsyncIterable<LivenessRequestStream>;
+}
+export interface StartFaceLivenessSessionResponse {
+  SessionId: string | undefined;
+  LivenessResponseStream?: AsyncIterable<LivenessResponseStream>;
+}
+export interface StartStreamingLivenessSessionRequest {
+  SessionId: string | undefined;
+  ClientSDKVersion: string | undefined;
+  LivenessRequestStream?: AsyncIterable<LivenessRequestStream>;
+}
+export interface StartStreamingLivenessSessionResponse {
+  SessionId: string | undefined;
+  LivenessResponseStream?: AsyncIterable<LivenessResponseStream>;
+}
+export declare const LivenessRequestStreamFilterSensitiveLog: (
+  obj: LivenessRequestStream
+) => any;
+export declare const LivenessResponseStreamFilterSensitiveLog: (
+  obj: LivenessResponseStream
+) => any;
+export declare const StartFaceLivenessSessionRequestFilterSensitiveLog: (
+  obj: StartFaceLivenessSessionRequest
+) => any;
+export declare const StartFaceLivenessSessionResponseFilterSensitiveLog: (
+  obj: StartFaceLivenessSessionResponse
+) => any;
+export declare const StartStreamingLivenessSessionRequestFilterSensitiveLog: (
+  obj: StartStreamingLivenessSessionRequest
+) => any;
+export declare const StartStreamingLivenessSessionResponseFilterSensitiveLog: (
+  obj: StartStreamingLivenessSessionResponse
+) => any;

package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,32 @@
+import {
+  HttpRequest as __HttpRequest,
+  HttpResponse as __HttpResponse,
+} from "@aws-sdk/protocol-http";
+import {
+  EventStreamSerdeContext as __EventStreamSerdeContext,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+import {
+  StartFaceLivenessSessionCommandInput,
+  StartFaceLivenessSessionCommandOutput,
+} from "../commands/StartFaceLivenessSessionCommand";
+import {
+  StartStreamingLivenessSessionCommandInput,
+  StartStreamingLivenessSessionCommandOutput,
+} from "../commands/StartStreamingLivenessSessionCommand";
+export declare const serializeAws_restJson1StartFaceLivenessSessionCommand: (
+  input: StartFaceLivenessSessionCommandInput,
+  context: __SerdeContext & __EventStreamSerdeContext
+) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1StartStreamingLivenessSessionCommand: (
+  input: StartStreamingLivenessSessionCommandInput,
+  context: __SerdeContext & __EventStreamSerdeContext
+) => Promise<__HttpRequest>;
+export declare const deserializeAws_restJson1StartFaceLivenessSessionCommand: (
+  output: __HttpResponse,
+  context: __SerdeContext & __EventStreamSerdeContext
+) => Promise<StartFaceLivenessSessionCommandOutput>;
+export declare const deserializeAws_restJson1StartStreamingLivenessSessionCommand: (
+  output: __HttpResponse,
+  context: __SerdeContext & __EventStreamSerdeContext
+) => Promise<StartStreamingLivenessSessionCommandOutput>;