@aws-sdk/client-comprehend 3.34.0 → 3.37.0

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

@@ -0,0 +1,2704 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare enum AugmentedManifestsDocumentTypeFormat {
+    PLAIN_TEXT_DOCUMENT = "PLAIN_TEXT_DOCUMENT",
+    SEMI_STRUCTURED_DOCUMENT = "SEMI_STRUCTURED_DOCUMENT"
+}
+export declare enum Split {
+    TEST = "TEST",
+    TRAIN = "TRAIN"
+}
+
+export interface AugmentedManifestsListItem {
+    
+    S3Uri: string | undefined;
+    
+    Split?: Split | string;
+    
+    AttributeNames: string[] | undefined;
+    
+    AnnotationDataS3Uri?: string;
+    
+    SourceDocumentsS3Uri?: string;
+    
+    DocumentType?: AugmentedManifestsDocumentTypeFormat | string;
+}
+export declare namespace AugmentedManifestsListItem {
+    
+    const filterSensitiveLog: (obj: AugmentedManifestsListItem) => any;
+}
+export interface BatchDetectDominantLanguageRequest {
+    
+    TextList: string[] | undefined;
+}
+export declare namespace BatchDetectDominantLanguageRequest {
+    
+    const filterSensitiveLog: (obj: BatchDetectDominantLanguageRequest) => any;
+}
+
+export interface BatchItemError {
+    
+    Index?: number;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace BatchItemError {
+    
+    const filterSensitiveLog: (obj: BatchItemError) => any;
+}
+
+export interface DominantLanguage {
+    
+    LanguageCode?: string;
+    
+    Score?: number;
+}
+export declare namespace DominantLanguage {
+    
+    const filterSensitiveLog: (obj: DominantLanguage) => any;
+}
+
+export interface BatchDetectDominantLanguageItemResult {
+    
+    Index?: number;
+    
+    Languages?: DominantLanguage[];
+}
+export declare namespace BatchDetectDominantLanguageItemResult {
+    
+    const filterSensitiveLog: (obj: BatchDetectDominantLanguageItemResult) => any;
+}
+export interface BatchDetectDominantLanguageResponse {
+    
+    ResultList: BatchDetectDominantLanguageItemResult[] | undefined;
+    
+    ErrorList: BatchItemError[] | undefined;
+}
+export declare namespace BatchDetectDominantLanguageResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetectDominantLanguageResponse) => any;
+}
+
+export interface BatchSizeLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "BatchSizeLimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace BatchSizeLimitExceededException {
+    
+    const filterSensitiveLog: (obj: BatchSizeLimitExceededException) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    Message?: string;
+}
+export declare namespace InternalServerException {
+    
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidRequestException) => any;
+}
+
+export interface TextSizeLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "TextSizeLimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TextSizeLimitExceededException {
+    
+    const filterSensitiveLog: (obj: TextSizeLimitExceededException) => any;
+}
+export declare enum LanguageCode {
+    AR = "ar",
+    DE = "de",
+    EN = "en",
+    ES = "es",
+    FR = "fr",
+    HI = "hi",
+    IT = "it",
+    JA = "ja",
+    KO = "ko",
+    PT = "pt",
+    ZH = "zh",
+    ZH_TW = "zh-TW"
+}
+export interface BatchDetectEntitiesRequest {
+    
+    TextList: string[] | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace BatchDetectEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: BatchDetectEntitiesRequest) => any;
+}
+export declare enum EntityType {
+    COMMERCIAL_ITEM = "COMMERCIAL_ITEM",
+    DATE = "DATE",
+    EVENT = "EVENT",
+    LOCATION = "LOCATION",
+    ORGANIZATION = "ORGANIZATION",
+    OTHER = "OTHER",
+    PERSON = "PERSON",
+    QUANTITY = "QUANTITY",
+    TITLE = "TITLE"
+}
+
+export interface Entity {
+    
+    Score?: number;
+    
+    Type?: EntityType | string;
+    
+    Text?: string;
+    
+    BeginOffset?: number;
+    
+    EndOffset?: number;
+}
+export declare namespace Entity {
+    
+    const filterSensitiveLog: (obj: Entity) => any;
+}
+
+export interface BatchDetectEntitiesItemResult {
+    
+    Index?: number;
+    
+    Entities?: Entity[];
+}
+export declare namespace BatchDetectEntitiesItemResult {
+    
+    const filterSensitiveLog: (obj: BatchDetectEntitiesItemResult) => any;
+}
+export interface BatchDetectEntitiesResponse {
+    
+    ResultList: BatchDetectEntitiesItemResult[] | undefined;
+    
+    ErrorList: BatchItemError[] | undefined;
+}
+export declare namespace BatchDetectEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetectEntitiesResponse) => any;
+}
+
+export interface UnsupportedLanguageException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedLanguageException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace UnsupportedLanguageException {
+    
+    const filterSensitiveLog: (obj: UnsupportedLanguageException) => any;
+}
+export interface BatchDetectKeyPhrasesRequest {
+    
+    TextList: string[] | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace BatchDetectKeyPhrasesRequest {
+    
+    const filterSensitiveLog: (obj: BatchDetectKeyPhrasesRequest) => any;
+}
+
+export interface KeyPhrase {
+    
+    Score?: number;
+    
+    Text?: string;
+    
+    BeginOffset?: number;
+    
+    EndOffset?: number;
+}
+export declare namespace KeyPhrase {
+    
+    const filterSensitiveLog: (obj: KeyPhrase) => any;
+}
+
+export interface BatchDetectKeyPhrasesItemResult {
+    
+    Index?: number;
+    
+    KeyPhrases?: KeyPhrase[];
+}
+export declare namespace BatchDetectKeyPhrasesItemResult {
+    
+    const filterSensitiveLog: (obj: BatchDetectKeyPhrasesItemResult) => any;
+}
+export interface BatchDetectKeyPhrasesResponse {
+    
+    ResultList: BatchDetectKeyPhrasesItemResult[] | undefined;
+    
+    ErrorList: BatchItemError[] | undefined;
+}
+export declare namespace BatchDetectKeyPhrasesResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetectKeyPhrasesResponse) => any;
+}
+export interface BatchDetectSentimentRequest {
+    
+    TextList: string[] | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace BatchDetectSentimentRequest {
+    
+    const filterSensitiveLog: (obj: BatchDetectSentimentRequest) => any;
+}
+export declare enum SentimentType {
+    MIXED = "MIXED",
+    NEGATIVE = "NEGATIVE",
+    NEUTRAL = "NEUTRAL",
+    POSITIVE = "POSITIVE"
+}
+
+export interface SentimentScore {
+    
+    Positive?: number;
+    
+    Negative?: number;
+    
+    Neutral?: number;
+    
+    Mixed?: number;
+}
+export declare namespace SentimentScore {
+    
+    const filterSensitiveLog: (obj: SentimentScore) => any;
+}
+
+export interface BatchDetectSentimentItemResult {
+    
+    Index?: number;
+    
+    Sentiment?: SentimentType | string;
+    
+    SentimentScore?: SentimentScore;
+}
+export declare namespace BatchDetectSentimentItemResult {
+    
+    const filterSensitiveLog: (obj: BatchDetectSentimentItemResult) => any;
+}
+export interface BatchDetectSentimentResponse {
+    
+    ResultList: BatchDetectSentimentItemResult[] | undefined;
+    
+    ErrorList: BatchItemError[] | undefined;
+}
+export declare namespace BatchDetectSentimentResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetectSentimentResponse) => any;
+}
+export declare enum SyntaxLanguageCode {
+    DE = "de",
+    EN = "en",
+    ES = "es",
+    FR = "fr",
+    IT = "it",
+    PT = "pt"
+}
+export interface BatchDetectSyntaxRequest {
+    
+    TextList: string[] | undefined;
+    
+    LanguageCode: SyntaxLanguageCode | string | undefined;
+}
+export declare namespace BatchDetectSyntaxRequest {
+    
+    const filterSensitiveLog: (obj: BatchDetectSyntaxRequest) => any;
+}
+export declare enum PartOfSpeechTagType {
+    ADJ = "ADJ",
+    ADP = "ADP",
+    ADV = "ADV",
+    AUX = "AUX",
+    CCONJ = "CCONJ",
+    CONJ = "CONJ",
+    DET = "DET",
+    INTJ = "INTJ",
+    NOUN = "NOUN",
+    NUM = "NUM",
+    O = "O",
+    PART = "PART",
+    PRON = "PRON",
+    PROPN = "PROPN",
+    PUNCT = "PUNCT",
+    SCONJ = "SCONJ",
+    SYM = "SYM",
+    VERB = "VERB"
+}
+
+export interface PartOfSpeechTag {
+    
+    Tag?: PartOfSpeechTagType | string;
+    
+    Score?: number;
+}
+export declare namespace PartOfSpeechTag {
+    
+    const filterSensitiveLog: (obj: PartOfSpeechTag) => any;
+}
+
+export interface SyntaxToken {
+    
+    TokenId?: number;
+    
+    Text?: string;
+    
+    BeginOffset?: number;
+    
+    EndOffset?: number;
+    
+    PartOfSpeech?: PartOfSpeechTag;
+}
+export declare namespace SyntaxToken {
+    
+    const filterSensitiveLog: (obj: SyntaxToken) => any;
+}
+
+export interface BatchDetectSyntaxItemResult {
+    
+    Index?: number;
+    
+    SyntaxTokens?: SyntaxToken[];
+}
+export declare namespace BatchDetectSyntaxItemResult {
+    
+    const filterSensitiveLog: (obj: BatchDetectSyntaxItemResult) => any;
+}
+export interface BatchDetectSyntaxResponse {
+    
+    ResultList: BatchDetectSyntaxItemResult[] | undefined;
+    
+    ErrorList: BatchItemError[] | undefined;
+}
+export declare namespace BatchDetectSyntaxResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetectSyntaxResponse) => any;
+}
+
+export interface ClassifierEvaluationMetrics {
+    
+    Accuracy?: number;
+    
+    Precision?: number;
+    
+    Recall?: number;
+    
+    F1Score?: number;
+    
+    MicroPrecision?: number;
+    
+    MicroRecall?: number;
+    
+    MicroF1Score?: number;
+    
+    HammingLoss?: number;
+}
+export declare namespace ClassifierEvaluationMetrics {
+    
+    const filterSensitiveLog: (obj: ClassifierEvaluationMetrics) => any;
+}
+
+export interface ClassifierMetadata {
+    
+    NumberOfLabels?: number;
+    
+    NumberOfTrainedDocuments?: number;
+    
+    NumberOfTestDocuments?: number;
+    
+    EvaluationMetrics?: ClassifierEvaluationMetrics;
+}
+export declare namespace ClassifierMetadata {
+    
+    const filterSensitiveLog: (obj: ClassifierMetadata) => any;
+}
+export interface ClassifyDocumentRequest {
+    
+    Text: string | undefined;
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace ClassifyDocumentRequest {
+    
+    const filterSensitiveLog: (obj: ClassifyDocumentRequest) => any;
+}
+
+export interface DocumentClass {
+    
+    Name?: string;
+    
+    Score?: number;
+}
+export declare namespace DocumentClass {
+    
+    const filterSensitiveLog: (obj: DocumentClass) => any;
+}
+
+export interface DocumentLabel {
+    
+    Name?: string;
+    
+    Score?: number;
+}
+export declare namespace DocumentLabel {
+    
+    const filterSensitiveLog: (obj: DocumentLabel) => any;
+}
+export interface ClassifyDocumentResponse {
+    
+    Classes?: DocumentClass[];
+    
+    Labels?: DocumentLabel[];
+}
+export declare namespace ClassifyDocumentResponse {
+    
+    const filterSensitiveLog: (obj: ClassifyDocumentResponse) => any;
+}
+
+export interface ResourceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ResourceUnavailableException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceUnavailableException {
+    
+    const filterSensitiveLog: (obj: ResourceUnavailableException) => any;
+}
+export interface ContainsPiiEntitiesRequest {
+    
+    Text: string | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace ContainsPiiEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: ContainsPiiEntitiesRequest) => any;
+}
+export declare enum PiiEntityType {
+    ADDRESS = "ADDRESS",
+    AGE = "AGE",
+    ALL = "ALL",
+    AWS_ACCESS_KEY = "AWS_ACCESS_KEY",
+    AWS_SECRET_KEY = "AWS_SECRET_KEY",
+    BANK_ACCOUNT_NUMBER = "BANK_ACCOUNT_NUMBER",
+    BANK_ROUTING = "BANK_ROUTING",
+    CREDIT_DEBIT_CVV = "CREDIT_DEBIT_CVV",
+    CREDIT_DEBIT_EXPIRY = "CREDIT_DEBIT_EXPIRY",
+    CREDIT_DEBIT_NUMBER = "CREDIT_DEBIT_NUMBER",
+    DATE_TIME = "DATE_TIME",
+    DRIVER_ID = "DRIVER_ID",
+    EMAIL = "EMAIL",
+    IP_ADDRESS = "IP_ADDRESS",
+    MAC_ADDRESS = "MAC_ADDRESS",
+    NAME = "NAME",
+    PASSPORT_NUMBER = "PASSPORT_NUMBER",
+    PASSWORD = "PASSWORD",
+    PHONE = "PHONE",
+    PIN = "PIN",
+    SSN = "SSN",
+    URL = "URL",
+    USERNAME = "USERNAME"
+}
+
+export interface EntityLabel {
+    
+    Name?: PiiEntityType | string;
+    
+    Score?: number;
+}
+export declare namespace EntityLabel {
+    
+    const filterSensitiveLog: (obj: EntityLabel) => any;
+}
+export interface ContainsPiiEntitiesResponse {
+    
+    Labels?: EntityLabel[];
+}
+export declare namespace ContainsPiiEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: ContainsPiiEntitiesResponse) => any;
+}
+export declare enum DocumentClassifierDataFormat {
+    AUGMENTED_MANIFEST = "AUGMENTED_MANIFEST",
+    COMPREHEND_CSV = "COMPREHEND_CSV"
+}
+
+export interface DocumentClassifierInputDataConfig {
+    
+    DataFormat?: DocumentClassifierDataFormat | string;
+    
+    S3Uri?: string;
+    
+    TestS3Uri?: string;
+    
+    LabelDelimiter?: string;
+    
+    AugmentedManifests?: AugmentedManifestsListItem[];
+}
+export declare namespace DocumentClassifierInputDataConfig {
+    
+    const filterSensitiveLog: (obj: DocumentClassifierInputDataConfig) => any;
+}
+export declare enum DocumentClassifierMode {
+    MULTI_CLASS = "MULTI_CLASS",
+    MULTI_LABEL = "MULTI_LABEL"
+}
+
+export interface DocumentClassifierOutputDataConfig {
+    
+    S3Uri?: string;
+    
+    KmsKeyId?: string;
+}
+export declare namespace DocumentClassifierOutputDataConfig {
+    
+    const filterSensitiveLog: (obj: DocumentClassifierOutputDataConfig) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface VpcConfig {
+    
+    SecurityGroupIds: string[] | undefined;
+    
+    Subnets: string[] | undefined;
+}
+export declare namespace VpcConfig {
+    
+    const filterSensitiveLog: (obj: VpcConfig) => any;
+}
+export interface CreateDocumentClassifierRequest {
+    
+    DocumentClassifierName: string | undefined;
+    
+    VersionName?: string;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    InputDataConfig: DocumentClassifierInputDataConfig | undefined;
+    
+    OutputDataConfig?: DocumentClassifierOutputDataConfig;
+    
+    ClientRequestToken?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Mode?: DocumentClassifierMode | string;
+    
+    ModelKmsKeyId?: string;
+}
+export declare namespace CreateDocumentClassifierRequest {
+    
+    const filterSensitiveLog: (obj: CreateDocumentClassifierRequest) => any;
+}
+export interface CreateDocumentClassifierResponse {
+    
+    DocumentClassifierArn?: string;
+}
+export declare namespace CreateDocumentClassifierResponse {
+    
+    const filterSensitiveLog: (obj: CreateDocumentClassifierResponse) => any;
+}
+
+export interface KmsKeyValidationException extends __SmithyException, $MetadataBearer {
+    name: "KmsKeyValidationException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace KmsKeyValidationException {
+    
+    const filterSensitiveLog: (obj: KmsKeyValidationException) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+
+export interface ResourceLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceLimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceLimitExceededException {
+    
+    const filterSensitiveLog: (obj: ResourceLimitExceededException) => any;
+}
+
+export interface TooManyRequestsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyRequestsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyRequestsException {
+    
+    const filterSensitiveLog: (obj: TooManyRequestsException) => any;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyTagsException {
+    
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+export interface CreateEndpointRequest {
+    
+    EndpointName: string | undefined;
+    
+    ModelArn: string | undefined;
+    
+    DesiredInferenceUnits: number | undefined;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+    
+    DataAccessRoleArn?: string;
+}
+export declare namespace CreateEndpointRequest {
+    
+    const filterSensitiveLog: (obj: CreateEndpointRequest) => any;
+}
+export interface CreateEndpointResponse {
+    
+    EndpointArn?: string;
+}
+export declare namespace CreateEndpointResponse {
+    
+    const filterSensitiveLog: (obj: CreateEndpointResponse) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface EntityRecognizerAnnotations {
+    
+    S3Uri: string | undefined;
+    
+    TestS3Uri?: string;
+}
+export declare namespace EntityRecognizerAnnotations {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerAnnotations) => any;
+}
+export declare enum EntityRecognizerDataFormat {
+    AUGMENTED_MANIFEST = "AUGMENTED_MANIFEST",
+    COMPREHEND_CSV = "COMPREHEND_CSV"
+}
+export declare enum InputFormat {
+    ONE_DOC_PER_FILE = "ONE_DOC_PER_FILE",
+    ONE_DOC_PER_LINE = "ONE_DOC_PER_LINE"
+}
+
+export interface EntityRecognizerDocuments {
+    
+    S3Uri: string | undefined;
+    
+    TestS3Uri?: string;
+    
+    InputFormat?: InputFormat | string;
+}
+export declare namespace EntityRecognizerDocuments {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerDocuments) => any;
+}
+
+export interface EntityRecognizerEntityList {
+    
+    S3Uri: string | undefined;
+}
+export declare namespace EntityRecognizerEntityList {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerEntityList) => any;
+}
+
+export interface EntityTypesListItem {
+    
+    Type: string | undefined;
+}
+export declare namespace EntityTypesListItem {
+    
+    const filterSensitiveLog: (obj: EntityTypesListItem) => any;
+}
+
+export interface EntityRecognizerInputDataConfig {
+    
+    DataFormat?: EntityRecognizerDataFormat | string;
+    
+    EntityTypes: EntityTypesListItem[] | undefined;
+    
+    Documents?: EntityRecognizerDocuments;
+    
+    Annotations?: EntityRecognizerAnnotations;
+    
+    EntityList?: EntityRecognizerEntityList;
+    
+    AugmentedManifests?: AugmentedManifestsListItem[];
+}
+export declare namespace EntityRecognizerInputDataConfig {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerInputDataConfig) => any;
+}
+export interface CreateEntityRecognizerRequest {
+    
+    RecognizerName: string | undefined;
+    
+    VersionName?: string;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    InputDataConfig: EntityRecognizerInputDataConfig | undefined;
+    
+    ClientRequestToken?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    ModelKmsKeyId?: string;
+}
+export declare namespace CreateEntityRecognizerRequest {
+    
+    const filterSensitiveLog: (obj: CreateEntityRecognizerRequest) => any;
+}
+export interface CreateEntityRecognizerResponse {
+    
+    EntityRecognizerArn?: string;
+}
+export declare namespace CreateEntityRecognizerResponse {
+    
+    const filterSensitiveLog: (obj: CreateEntityRecognizerResponse) => any;
+}
+export interface DeleteDocumentClassifierRequest {
+    
+    DocumentClassifierArn: string | undefined;
+}
+export declare namespace DeleteDocumentClassifierRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentClassifierRequest) => any;
+}
+export interface DeleteDocumentClassifierResponse {
+}
+export declare namespace DeleteDocumentClassifierResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentClassifierResponse) => any;
+}
+export interface DeleteEndpointRequest {
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace DeleteEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointRequest) => any;
+}
+export interface DeleteEndpointResponse {
+}
+export declare namespace DeleteEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointResponse) => any;
+}
+export interface DeleteEntityRecognizerRequest {
+    
+    EntityRecognizerArn: string | undefined;
+}
+export declare namespace DeleteEntityRecognizerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEntityRecognizerRequest) => any;
+}
+export interface DeleteEntityRecognizerResponse {
+}
+export declare namespace DeleteEntityRecognizerResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEntityRecognizerResponse) => any;
+}
+export interface DescribeDocumentClassificationJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeDocumentClassificationJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentClassificationJobRequest) => any;
+}
+export declare enum DocumentReadAction {
+    TEXTRACT_ANALYZE_DOCUMENT = "TEXTRACT_ANALYZE_DOCUMENT",
+    TEXTRACT_DETECT_DOCUMENT_TEXT = "TEXTRACT_DETECT_DOCUMENT_TEXT"
+}
+export declare enum DocumentReadMode {
+    FORCE_DOCUMENT_READ_ACTION = "FORCE_DOCUMENT_READ_ACTION",
+    SERVICE_DEFAULT = "SERVICE_DEFAULT"
+}
+export declare enum DocumentReadFeatureTypes {
+    FORMS = "FORMS",
+    TABLES = "TABLES"
+}
+
+export interface DocumentReaderConfig {
+    
+    DocumentReadAction: DocumentReadAction | string | undefined;
+    
+    DocumentReadMode?: DocumentReadMode | string;
+    
+    FeatureTypes?: (DocumentReadFeatureTypes | string)[];
+}
+export declare namespace DocumentReaderConfig {
+    
+    const filterSensitiveLog: (obj: DocumentReaderConfig) => any;
+}
+
+export interface InputDataConfig {
+    
+    S3Uri: string | undefined;
+    
+    InputFormat?: InputFormat | string;
+    
+    DocumentReaderConfig?: DocumentReaderConfig;
+}
+export declare namespace InputDataConfig {
+    
+    const filterSensitiveLog: (obj: InputDataConfig) => any;
+}
+export declare enum JobStatus {
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    STOPPED = "STOPPED",
+    STOP_REQUESTED = "STOP_REQUESTED",
+    SUBMITTED = "SUBMITTED"
+}
+
+export interface OutputDataConfig {
+    
+    S3Uri: string | undefined;
+    
+    KmsKeyId?: string;
+}
+export declare namespace OutputDataConfig {
+    
+    const filterSensitiveLog: (obj: OutputDataConfig) => any;
+}
+
+export interface DocumentClassificationJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    DocumentClassifierArn?: string;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace DocumentClassificationJobProperties {
+    
+    const filterSensitiveLog: (obj: DocumentClassificationJobProperties) => any;
+}
+export interface DescribeDocumentClassificationJobResponse {
+    
+    DocumentClassificationJobProperties?: DocumentClassificationJobProperties;
+}
+export declare namespace DescribeDocumentClassificationJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentClassificationJobResponse) => any;
+}
+
+export interface JobNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "JobNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace JobNotFoundException {
+    
+    const filterSensitiveLog: (obj: JobNotFoundException) => any;
+}
+export interface DescribeDocumentClassifierRequest {
+    
+    DocumentClassifierArn: string | undefined;
+}
+export declare namespace DescribeDocumentClassifierRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentClassifierRequest) => any;
+}
+export declare enum ModelStatus {
+    DELETING = "DELETING",
+    IN_ERROR = "IN_ERROR",
+    STOPPED = "STOPPED",
+    STOP_REQUESTED = "STOP_REQUESTED",
+    SUBMITTED = "SUBMITTED",
+    TRAINED = "TRAINED",
+    TRAINING = "TRAINING"
+}
+
+export interface DocumentClassifierProperties {
+    
+    DocumentClassifierArn?: string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    Status?: ModelStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    TrainingStartTime?: Date;
+    
+    TrainingEndTime?: Date;
+    
+    InputDataConfig?: DocumentClassifierInputDataConfig;
+    
+    OutputDataConfig?: DocumentClassifierOutputDataConfig;
+    
+    ClassifierMetadata?: ClassifierMetadata;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Mode?: DocumentClassifierMode | string;
+    
+    ModelKmsKeyId?: string;
+    
+    VersionName?: string;
+}
+export declare namespace DocumentClassifierProperties {
+    
+    const filterSensitiveLog: (obj: DocumentClassifierProperties) => any;
+}
+export interface DescribeDocumentClassifierResponse {
+    
+    DocumentClassifierProperties?: DocumentClassifierProperties;
+}
+export declare namespace DescribeDocumentClassifierResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentClassifierResponse) => any;
+}
+export interface DescribeDominantLanguageDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeDominantLanguageDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDominantLanguageDetectionJobRequest) => any;
+}
+
+export interface DominantLanguageDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace DominantLanguageDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: DominantLanguageDetectionJobProperties) => any;
+}
+export interface DescribeDominantLanguageDetectionJobResponse {
+    
+    DominantLanguageDetectionJobProperties?: DominantLanguageDetectionJobProperties;
+}
+export declare namespace DescribeDominantLanguageDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDominantLanguageDetectionJobResponse) => any;
+}
+export interface DescribeEndpointRequest {
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace DescribeEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointRequest) => any;
+}
+export declare enum EndpointStatus {
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    IN_SERVICE = "IN_SERVICE",
+    UPDATING = "UPDATING"
+}
+
+export interface EndpointProperties {
+    
+    EndpointArn?: string;
+    
+    Status?: EndpointStatus | string;
+    
+    Message?: string;
+    
+    ModelArn?: string;
+    
+    DesiredModelArn?: string;
+    
+    DesiredInferenceUnits?: number;
+    
+    CurrentInferenceUnits?: number;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    DataAccessRoleArn?: string;
+    
+    DesiredDataAccessRoleArn?: string;
+}
+export declare namespace EndpointProperties {
+    
+    const filterSensitiveLog: (obj: EndpointProperties) => any;
+}
+export interface DescribeEndpointResponse {
+    
+    EndpointProperties?: EndpointProperties;
+}
+export declare namespace DescribeEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointResponse) => any;
+}
+export interface DescribeEntitiesDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeEntitiesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEntitiesDetectionJobRequest) => any;
+}
+
+export interface EntitiesDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    EntityRecognizerArn?: string;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace EntitiesDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: EntitiesDetectionJobProperties) => any;
+}
+export interface DescribeEntitiesDetectionJobResponse {
+    
+    EntitiesDetectionJobProperties?: EntitiesDetectionJobProperties;
+}
+export declare namespace DescribeEntitiesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEntitiesDetectionJobResponse) => any;
+}
+export interface DescribeEntityRecognizerRequest {
+    
+    EntityRecognizerArn: string | undefined;
+}
+export declare namespace DescribeEntityRecognizerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEntityRecognizerRequest) => any;
+}
+
+export interface EntityTypesEvaluationMetrics {
+    
+    Precision?: number;
+    
+    Recall?: number;
+    
+    F1Score?: number;
+}
+export declare namespace EntityTypesEvaluationMetrics {
+    
+    const filterSensitiveLog: (obj: EntityTypesEvaluationMetrics) => any;
+}
+
+export interface EntityRecognizerMetadataEntityTypesListItem {
+    
+    Type?: string;
+    
+    EvaluationMetrics?: EntityTypesEvaluationMetrics;
+    
+    NumberOfTrainMentions?: number;
+}
+export declare namespace EntityRecognizerMetadataEntityTypesListItem {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerMetadataEntityTypesListItem) => any;
+}
+
+export interface EntityRecognizerEvaluationMetrics {
+    
+    Precision?: number;
+    
+    Recall?: number;
+    
+    F1Score?: number;
+}
+export declare namespace EntityRecognizerEvaluationMetrics {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerEvaluationMetrics) => any;
+}
+
+export interface EntityRecognizerMetadata {
+    
+    NumberOfTrainedDocuments?: number;
+    
+    NumberOfTestDocuments?: number;
+    
+    EvaluationMetrics?: EntityRecognizerEvaluationMetrics;
+    
+    EntityTypes?: EntityRecognizerMetadataEntityTypesListItem[];
+}
+export declare namespace EntityRecognizerMetadata {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerMetadata) => any;
+}
+
+export interface EntityRecognizerProperties {
+    
+    EntityRecognizerArn?: string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    Status?: ModelStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    TrainingStartTime?: Date;
+    
+    TrainingEndTime?: Date;
+    
+    InputDataConfig?: EntityRecognizerInputDataConfig;
+    
+    RecognizerMetadata?: EntityRecognizerMetadata;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    ModelKmsKeyId?: string;
+    
+    VersionName?: string;
+}
+export declare namespace EntityRecognizerProperties {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerProperties) => any;
+}
+export interface DescribeEntityRecognizerResponse {
+    
+    EntityRecognizerProperties?: EntityRecognizerProperties;
+}
+export declare namespace DescribeEntityRecognizerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEntityRecognizerResponse) => any;
+}
+export interface DescribeEventsDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeEventsDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventsDetectionJobRequest) => any;
+}
+
+export interface EventsDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    DataAccessRoleArn?: string;
+    
+    TargetEventTypes?: string[];
+}
+export declare namespace EventsDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: EventsDetectionJobProperties) => any;
+}
+export interface DescribeEventsDetectionJobResponse {
+    
+    EventsDetectionJobProperties?: EventsDetectionJobProperties;
+}
+export declare namespace DescribeEventsDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventsDetectionJobResponse) => any;
+}
+export interface DescribeKeyPhrasesDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeKeyPhrasesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeKeyPhrasesDetectionJobRequest) => any;
+}
+
+export interface KeyPhrasesDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace KeyPhrasesDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: KeyPhrasesDetectionJobProperties) => any;
+}
+export interface DescribeKeyPhrasesDetectionJobResponse {
+    
+    KeyPhrasesDetectionJobProperties?: KeyPhrasesDetectionJobProperties;
+}
+export declare namespace DescribeKeyPhrasesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeKeyPhrasesDetectionJobResponse) => any;
+}
+export interface DescribePiiEntitiesDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribePiiEntitiesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribePiiEntitiesDetectionJobRequest) => any;
+}
+export declare enum PiiEntitiesDetectionMode {
+    ONLY_OFFSETS = "ONLY_OFFSETS",
+    ONLY_REDACTION = "ONLY_REDACTION"
+}
+
+export interface PiiOutputDataConfig {
+    
+    S3Uri: string | undefined;
+    
+    KmsKeyId?: string;
+}
+export declare namespace PiiOutputDataConfig {
+    
+    const filterSensitiveLog: (obj: PiiOutputDataConfig) => any;
+}
+export declare enum PiiEntitiesDetectionMaskMode {
+    MASK = "MASK",
+    REPLACE_WITH_PII_ENTITY_TYPE = "REPLACE_WITH_PII_ENTITY_TYPE"
+}
+
+export interface RedactionConfig {
+    
+    PiiEntityTypes?: (PiiEntityType | string)[];
+    
+    MaskMode?: PiiEntitiesDetectionMaskMode | string;
+    
+    MaskCharacter?: string;
+}
+export declare namespace RedactionConfig {
+    
+    const filterSensitiveLog: (obj: RedactionConfig) => any;
+}
+
+export interface PiiEntitiesDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: PiiOutputDataConfig;
+    
+    RedactionConfig?: RedactionConfig;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    DataAccessRoleArn?: string;
+    
+    Mode?: PiiEntitiesDetectionMode | string;
+}
+export declare namespace PiiEntitiesDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: PiiEntitiesDetectionJobProperties) => any;
+}
+export interface DescribePiiEntitiesDetectionJobResponse {
+    
+    PiiEntitiesDetectionJobProperties?: PiiEntitiesDetectionJobProperties;
+}
+export declare namespace DescribePiiEntitiesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribePiiEntitiesDetectionJobResponse) => any;
+}
+export interface DescribeSentimentDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeSentimentDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSentimentDetectionJobRequest) => any;
+}
+
+export interface SentimentDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace SentimentDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: SentimentDetectionJobProperties) => any;
+}
+export interface DescribeSentimentDetectionJobResponse {
+    
+    SentimentDetectionJobProperties?: SentimentDetectionJobProperties;
+}
+export declare namespace DescribeSentimentDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSentimentDetectionJobResponse) => any;
+}
+export interface DescribeTopicsDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeTopicsDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTopicsDetectionJobRequest) => any;
+}
+
+export interface TopicsDetectionJobProperties {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    Message?: string;
+    
+    SubmitTime?: Date;
+    
+    EndTime?: Date;
+    
+    InputDataConfig?: InputDataConfig;
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    NumberOfTopics?: number;
+    
+    DataAccessRoleArn?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace TopicsDetectionJobProperties {
+    
+    const filterSensitiveLog: (obj: TopicsDetectionJobProperties) => any;
+}
+export interface DescribeTopicsDetectionJobResponse {
+    
+    TopicsDetectionJobProperties?: TopicsDetectionJobProperties;
+}
+export declare namespace DescribeTopicsDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTopicsDetectionJobResponse) => any;
+}
+export interface DetectDominantLanguageRequest {
+    
+    Text: string | undefined;
+}
+export declare namespace DetectDominantLanguageRequest {
+    
+    const filterSensitiveLog: (obj: DetectDominantLanguageRequest) => any;
+}
+export interface DetectDominantLanguageResponse {
+    
+    Languages?: DominantLanguage[];
+}
+export declare namespace DetectDominantLanguageResponse {
+    
+    const filterSensitiveLog: (obj: DetectDominantLanguageResponse) => any;
+}
+export interface DetectEntitiesRequest {
+    
+    Text: string | undefined;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    EndpointArn?: string;
+}
+export declare namespace DetectEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: DetectEntitiesRequest) => any;
+}
+export interface DetectEntitiesResponse {
+    
+    Entities?: Entity[];
+}
+export declare namespace DetectEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: DetectEntitiesResponse) => any;
+}
+export interface DetectKeyPhrasesRequest {
+    
+    Text: string | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace DetectKeyPhrasesRequest {
+    
+    const filterSensitiveLog: (obj: DetectKeyPhrasesRequest) => any;
+}
+export interface DetectKeyPhrasesResponse {
+    
+    KeyPhrases?: KeyPhrase[];
+}
+export declare namespace DetectKeyPhrasesResponse {
+    
+    const filterSensitiveLog: (obj: DetectKeyPhrasesResponse) => any;
+}
+export interface DetectPiiEntitiesRequest {
+    
+    Text: string | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace DetectPiiEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: DetectPiiEntitiesRequest) => any;
+}
+
+export interface PiiEntity {
+    
+    Score?: number;
+    
+    Type?: PiiEntityType | string;
+    
+    BeginOffset?: number;
+    
+    EndOffset?: number;
+}
+export declare namespace PiiEntity {
+    
+    const filterSensitiveLog: (obj: PiiEntity) => any;
+}
+export interface DetectPiiEntitiesResponse {
+    
+    Entities?: PiiEntity[];
+}
+export declare namespace DetectPiiEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: DetectPiiEntitiesResponse) => any;
+}
+export interface DetectSentimentRequest {
+    
+    Text: string | undefined;
+    
+    LanguageCode: LanguageCode | string | undefined;
+}
+export declare namespace DetectSentimentRequest {
+    
+    const filterSensitiveLog: (obj: DetectSentimentRequest) => any;
+}
+export interface DetectSentimentResponse {
+    
+    Sentiment?: SentimentType | string;
+    
+    SentimentScore?: SentimentScore;
+}
+export declare namespace DetectSentimentResponse {
+    
+    const filterSensitiveLog: (obj: DetectSentimentResponse) => any;
+}
+export interface DetectSyntaxRequest {
+    
+    Text: string | undefined;
+    
+    LanguageCode: SyntaxLanguageCode | string | undefined;
+}
+export declare namespace DetectSyntaxRequest {
+    
+    const filterSensitiveLog: (obj: DetectSyntaxRequest) => any;
+}
+export interface DetectSyntaxResponse {
+    
+    SyntaxTokens?: SyntaxToken[];
+}
+export declare namespace DetectSyntaxResponse {
+    
+    const filterSensitiveLog: (obj: DetectSyntaxResponse) => any;
+}
+
+export interface InvalidFilterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidFilterException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidFilterException {
+    
+    const filterSensitiveLog: (obj: InvalidFilterException) => any;
+}
+
+export interface DocumentClassificationJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace DocumentClassificationJobFilter {
+    
+    const filterSensitiveLog: (obj: DocumentClassificationJobFilter) => any;
+}
+export interface ListDocumentClassificationJobsRequest {
+    
+    Filter?: DocumentClassificationJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDocumentClassificationJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListDocumentClassificationJobsRequest) => any;
+}
+export interface ListDocumentClassificationJobsResponse {
+    
+    DocumentClassificationJobPropertiesList?: DocumentClassificationJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDocumentClassificationJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListDocumentClassificationJobsResponse) => any;
+}
+
+export interface DocumentClassifierFilter {
+    
+    Status?: ModelStatus | string;
+    
+    DocumentClassifierName?: string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace DocumentClassifierFilter {
+    
+    const filterSensitiveLog: (obj: DocumentClassifierFilter) => any;
+}
+export interface ListDocumentClassifiersRequest {
+    
+    Filter?: DocumentClassifierFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDocumentClassifiersRequest {
+    
+    const filterSensitiveLog: (obj: ListDocumentClassifiersRequest) => any;
+}
+export interface ListDocumentClassifiersResponse {
+    
+    DocumentClassifierPropertiesList?: DocumentClassifierProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDocumentClassifiersResponse {
+    
+    const filterSensitiveLog: (obj: ListDocumentClassifiersResponse) => any;
+}
+export interface ListDocumentClassifierSummariesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDocumentClassifierSummariesRequest {
+    
+    const filterSensitiveLog: (obj: ListDocumentClassifierSummariesRequest) => any;
+}
+
+export interface DocumentClassifierSummary {
+    
+    DocumentClassifierName?: string;
+    
+    NumberOfVersions?: number;
+    
+    LatestVersionCreatedAt?: Date;
+    
+    LatestVersionName?: string;
+    
+    LatestVersionStatus?: ModelStatus | string;
+}
+export declare namespace DocumentClassifierSummary {
+    
+    const filterSensitiveLog: (obj: DocumentClassifierSummary) => any;
+}
+export interface ListDocumentClassifierSummariesResponse {
+    
+    DocumentClassifierSummariesList?: DocumentClassifierSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDocumentClassifierSummariesResponse {
+    
+    const filterSensitiveLog: (obj: ListDocumentClassifierSummariesResponse) => any;
+}
+
+export interface DominantLanguageDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace DominantLanguageDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: DominantLanguageDetectionJobFilter) => any;
+}
+export interface ListDominantLanguageDetectionJobsRequest {
+    
+    Filter?: DominantLanguageDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDominantLanguageDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListDominantLanguageDetectionJobsRequest) => any;
+}
+export interface ListDominantLanguageDetectionJobsResponse {
+    
+    DominantLanguageDetectionJobPropertiesList?: DominantLanguageDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDominantLanguageDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListDominantLanguageDetectionJobsResponse) => any;
+}
+
+export interface EndpointFilter {
+    
+    ModelArn?: string;
+    
+    Status?: EndpointStatus | string;
+    
+    CreationTimeBefore?: Date;
+    
+    CreationTimeAfter?: Date;
+}
+export declare namespace EndpointFilter {
+    
+    const filterSensitiveLog: (obj: EndpointFilter) => any;
+}
+export interface ListEndpointsRequest {
+    
+    Filter?: EndpointFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: ListEndpointsRequest) => any;
+}
+export interface ListEndpointsResponse {
+    
+    EndpointPropertiesList?: EndpointProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: ListEndpointsResponse) => any;
+}
+
+export interface EntitiesDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace EntitiesDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: EntitiesDetectionJobFilter) => any;
+}
+export interface ListEntitiesDetectionJobsRequest {
+    
+    Filter?: EntitiesDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEntitiesDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListEntitiesDetectionJobsRequest) => any;
+}
+export interface ListEntitiesDetectionJobsResponse {
+    
+    EntitiesDetectionJobPropertiesList?: EntitiesDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEntitiesDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListEntitiesDetectionJobsResponse) => any;
+}
+
+export interface EntityRecognizerFilter {
+    
+    Status?: ModelStatus | string;
+    
+    RecognizerName?: string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace EntityRecognizerFilter {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerFilter) => any;
+}
+export interface ListEntityRecognizersRequest {
+    
+    Filter?: EntityRecognizerFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEntityRecognizersRequest {
+    
+    const filterSensitiveLog: (obj: ListEntityRecognizersRequest) => any;
+}
+export interface ListEntityRecognizersResponse {
+    
+    EntityRecognizerPropertiesList?: EntityRecognizerProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEntityRecognizersResponse {
+    
+    const filterSensitiveLog: (obj: ListEntityRecognizersResponse) => any;
+}
+export interface ListEntityRecognizerSummariesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEntityRecognizerSummariesRequest {
+    
+    const filterSensitiveLog: (obj: ListEntityRecognizerSummariesRequest) => any;
+}
+
+export interface EntityRecognizerSummary {
+    
+    RecognizerName?: string;
+    
+    NumberOfVersions?: number;
+    
+    LatestVersionCreatedAt?: Date;
+    
+    LatestVersionName?: string;
+    
+    LatestVersionStatus?: ModelStatus | string;
+}
+export declare namespace EntityRecognizerSummary {
+    
+    const filterSensitiveLog: (obj: EntityRecognizerSummary) => any;
+}
+export interface ListEntityRecognizerSummariesResponse {
+    
+    EntityRecognizerSummariesList?: EntityRecognizerSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEntityRecognizerSummariesResponse {
+    
+    const filterSensitiveLog: (obj: ListEntityRecognizerSummariesResponse) => any;
+}
+
+export interface EventsDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace EventsDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: EventsDetectionJobFilter) => any;
+}
+export interface ListEventsDetectionJobsRequest {
+    
+    Filter?: EventsDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEventsDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListEventsDetectionJobsRequest) => any;
+}
+export interface ListEventsDetectionJobsResponse {
+    
+    EventsDetectionJobPropertiesList?: EventsDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEventsDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListEventsDetectionJobsResponse) => any;
+}
+
+export interface KeyPhrasesDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace KeyPhrasesDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: KeyPhrasesDetectionJobFilter) => any;
+}
+export interface ListKeyPhrasesDetectionJobsRequest {
+    
+    Filter?: KeyPhrasesDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListKeyPhrasesDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListKeyPhrasesDetectionJobsRequest) => any;
+}
+export interface ListKeyPhrasesDetectionJobsResponse {
+    
+    KeyPhrasesDetectionJobPropertiesList?: KeyPhrasesDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListKeyPhrasesDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListKeyPhrasesDetectionJobsResponse) => any;
+}
+
+export interface PiiEntitiesDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace PiiEntitiesDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: PiiEntitiesDetectionJobFilter) => any;
+}
+export interface ListPiiEntitiesDetectionJobsRequest {
+    
+    Filter?: PiiEntitiesDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPiiEntitiesDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListPiiEntitiesDetectionJobsRequest) => any;
+}
+export interface ListPiiEntitiesDetectionJobsResponse {
+    
+    PiiEntitiesDetectionJobPropertiesList?: PiiEntitiesDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPiiEntitiesDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListPiiEntitiesDetectionJobsResponse) => any;
+}
+
+export interface SentimentDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace SentimentDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: SentimentDetectionJobFilter) => any;
+}
+export interface ListSentimentDetectionJobsRequest {
+    
+    Filter?: SentimentDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListSentimentDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListSentimentDetectionJobsRequest) => any;
+}
+export interface ListSentimentDetectionJobsResponse {
+    
+    SentimentDetectionJobPropertiesList?: SentimentDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSentimentDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListSentimentDetectionJobsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    ResourceArn?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface TopicsDetectionJobFilter {
+    
+    JobName?: string;
+    
+    JobStatus?: JobStatus | string;
+    
+    SubmitTimeBefore?: Date;
+    
+    SubmitTimeAfter?: Date;
+}
+export declare namespace TopicsDetectionJobFilter {
+    
+    const filterSensitiveLog: (obj: TopicsDetectionJobFilter) => any;
+}
+export interface ListTopicsDetectionJobsRequest {
+    
+    Filter?: TopicsDetectionJobFilter;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTopicsDetectionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListTopicsDetectionJobsRequest) => any;
+}
+export interface ListTopicsDetectionJobsResponse {
+    
+    TopicsDetectionJobPropertiesList?: TopicsDetectionJobProperties[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTopicsDetectionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListTopicsDetectionJobsResponse) => any;
+}
+export interface StartDocumentClassificationJobRequest {
+    
+    JobName?: string;
+    
+    DocumentClassifierArn: string | undefined;
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartDocumentClassificationJobRequest {
+    
+    const filterSensitiveLog: (obj: StartDocumentClassificationJobRequest) => any;
+}
+export interface StartDocumentClassificationJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartDocumentClassificationJobResponse {
+    
+    const filterSensitiveLog: (obj: StartDocumentClassificationJobResponse) => any;
+}
+export interface StartDominantLanguageDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    ClientRequestToken?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartDominantLanguageDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartDominantLanguageDetectionJobRequest) => any;
+}
+export interface StartDominantLanguageDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartDominantLanguageDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartDominantLanguageDetectionJobResponse) => any;
+}
+export interface StartEntitiesDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    EntityRecognizerArn?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartEntitiesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartEntitiesDetectionJobRequest) => any;
+}
+export interface StartEntitiesDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartEntitiesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartEntitiesDetectionJobResponse) => any;
+}
+export interface StartEventsDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    TargetEventTypes: string[] | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartEventsDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartEventsDetectionJobRequest) => any;
+}
+export interface StartEventsDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartEventsDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartEventsDetectionJobResponse) => any;
+}
+export interface StartKeyPhrasesDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartKeyPhrasesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartKeyPhrasesDetectionJobRequest) => any;
+}
+export interface StartKeyPhrasesDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartKeyPhrasesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartKeyPhrasesDetectionJobResponse) => any;
+}
+export interface StartPiiEntitiesDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    Mode: PiiEntitiesDetectionMode | string | undefined;
+    
+    RedactionConfig?: RedactionConfig;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartPiiEntitiesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartPiiEntitiesDetectionJobRequest) => any;
+}
+export interface StartPiiEntitiesDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartPiiEntitiesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartPiiEntitiesDetectionJobResponse) => any;
+}
+export interface StartSentimentDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartSentimentDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartSentimentDetectionJobRequest) => any;
+}
+export interface StartSentimentDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartSentimentDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartSentimentDetectionJobResponse) => any;
+}
+export interface StartTopicsDetectionJobRequest {
+    
+    InputDataConfig: InputDataConfig | undefined;
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    DataAccessRoleArn: string | undefined;
+    
+    JobName?: string;
+    
+    NumberOfTopics?: number;
+    
+    ClientRequestToken?: string;
+    
+    VolumeKmsKeyId?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace StartTopicsDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartTopicsDetectionJobRequest) => any;
+}
+export interface StartTopicsDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobArn?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StartTopicsDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartTopicsDetectionJobResponse) => any;
+}
+export interface StopDominantLanguageDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace StopDominantLanguageDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StopDominantLanguageDetectionJobRequest) => any;
+}
+export interface StopDominantLanguageDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StopDominantLanguageDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StopDominantLanguageDetectionJobResponse) => any;
+}
+export interface StopEntitiesDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace StopEntitiesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StopEntitiesDetectionJobRequest) => any;
+}
+export interface StopEntitiesDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StopEntitiesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StopEntitiesDetectionJobResponse) => any;
+}
+export interface StopEventsDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace StopEventsDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StopEventsDetectionJobRequest) => any;
+}
+export interface StopEventsDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StopEventsDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StopEventsDetectionJobResponse) => any;
+}
+export interface StopKeyPhrasesDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace StopKeyPhrasesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StopKeyPhrasesDetectionJobRequest) => any;
+}
+export interface StopKeyPhrasesDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StopKeyPhrasesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StopKeyPhrasesDetectionJobResponse) => any;
+}
+export interface StopPiiEntitiesDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace StopPiiEntitiesDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StopPiiEntitiesDetectionJobRequest) => any;
+}
+export interface StopPiiEntitiesDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StopPiiEntitiesDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StopPiiEntitiesDetectionJobResponse) => any;
+}
+export interface StopSentimentDetectionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace StopSentimentDetectionJobRequest {
+    
+    const filterSensitiveLog: (obj: StopSentimentDetectionJobRequest) => any;
+}
+export interface StopSentimentDetectionJobResponse {
+    
+    JobId?: string;
+    
+    JobStatus?: JobStatus | string;
+}
+export declare namespace StopSentimentDetectionJobResponse {
+    
+    const filterSensitiveLog: (obj: StopSentimentDetectionJobResponse) => any;
+}
+export interface StopTrainingDocumentClassifierRequest {
+    
+    DocumentClassifierArn: string | undefined;
+}
+export declare namespace StopTrainingDocumentClassifierRequest {
+    
+    const filterSensitiveLog: (obj: StopTrainingDocumentClassifierRequest) => any;
+}
+export interface StopTrainingDocumentClassifierResponse {
+}
+export declare namespace StopTrainingDocumentClassifierResponse {
+    
+    const filterSensitiveLog: (obj: StopTrainingDocumentClassifierResponse) => any;
+}
+export interface StopTrainingEntityRecognizerRequest {
+    
+    EntityRecognizerArn: string | undefined;
+}
+export declare namespace StopTrainingEntityRecognizerRequest {
+    
+    const filterSensitiveLog: (obj: StopTrainingEntityRecognizerRequest) => any;
+}
+export interface StopTrainingEntityRecognizerResponse {
+}
+export declare namespace StopTrainingEntityRecognizerResponse {
+    
+    const filterSensitiveLog: (obj: StopTrainingEntityRecognizerResponse) => any;
+}
+
+export interface ConcurrentModificationException extends __SmithyException, $MetadataBearer {
+    name: "ConcurrentModificationException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ConcurrentModificationException {
+    
+    const filterSensitiveLog: (obj: ConcurrentModificationException) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+
+export interface TooManyTagKeysException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagKeysException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyTagKeysException {
+    
+    const filterSensitiveLog: (obj: TooManyTagKeysException) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateEndpointRequest {
+    
+    EndpointArn: string | undefined;
+    
+    DesiredModelArn?: string;
+    
+    DesiredInferenceUnits?: number;
+    
+    DesiredDataAccessRoleArn?: string;
+}
+export declare namespace UpdateEndpointRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointRequest) => any;
+}
+export interface UpdateEndpointResponse {
+}
+export declare namespace UpdateEndpointResponse {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointResponse) => any;
+}