@aws-sdk/client-wisdom 3.50.0 → 3.53.0

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

@@ -0,0 +1,1235 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { WisdomServiceException as __BaseException } from "./WisdomServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export interface AppIntegrationsConfiguration {
+    
+    appIntegrationArn: string | undefined;
+    
+    objectFields: string[] | undefined;
+}
+export declare namespace AppIntegrationsConfiguration {
+    
+    const filterSensitiveLog: (obj: AppIntegrationsConfiguration) => any;
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare type AssistantAssociationInputData = AssistantAssociationInputData.KnowledgeBaseIdMember | AssistantAssociationInputData.$UnknownMember;
+export declare namespace AssistantAssociationInputData {
+    
+    interface KnowledgeBaseIdMember {
+        knowledgeBaseId: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        knowledgeBaseId?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        knowledgeBaseId: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AssistantAssociationInputData, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: AssistantAssociationInputData) => any;
+}
+export declare enum AssociationType {
+    KNOWLEDGE_BASE = "KNOWLEDGE_BASE"
+}
+export interface CreateAssistantAssociationRequest {
+    
+    assistantId: string | undefined;
+    
+    associationType: AssociationType | string | undefined;
+    
+    association: AssistantAssociationInputData | undefined;
+    
+    clientToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateAssistantAssociationRequest {
+    
+    const filterSensitiveLog: (obj: CreateAssistantAssociationRequest) => any;
+}
+
+export interface KnowledgeBaseAssociationData {
+    
+    knowledgeBaseId?: string;
+    
+    knowledgeBaseArn?: string;
+}
+export declare namespace KnowledgeBaseAssociationData {
+    
+    const filterSensitiveLog: (obj: KnowledgeBaseAssociationData) => any;
+}
+
+export declare type AssistantAssociationOutputData = AssistantAssociationOutputData.KnowledgeBaseAssociationMember | AssistantAssociationOutputData.$UnknownMember;
+export declare namespace AssistantAssociationOutputData {
+    
+    interface KnowledgeBaseAssociationMember {
+        knowledgeBaseAssociation: KnowledgeBaseAssociationData;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        knowledgeBaseAssociation?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        knowledgeBaseAssociation: (value: KnowledgeBaseAssociationData) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AssistantAssociationOutputData, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: AssistantAssociationOutputData) => any;
+}
+
+export interface AssistantAssociationData {
+    
+    assistantAssociationId: string | undefined;
+    
+    assistantAssociationArn: string | undefined;
+    
+    assistantId: string | undefined;
+    
+    assistantArn: string | undefined;
+    
+    associationType: AssociationType | string | undefined;
+    
+    associationData: AssistantAssociationOutputData | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AssistantAssociationData {
+    
+    const filterSensitiveLog: (obj: AssistantAssociationData) => any;
+}
+export interface CreateAssistantAssociationResponse {
+    
+    assistantAssociation?: AssistantAssociationData;
+}
+export declare namespace CreateAssistantAssociationResponse {
+    
+    const filterSensitiveLog: (obj: CreateAssistantAssociationResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    resourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface DeleteAssistantAssociationRequest {
+    
+    assistantAssociationId: string | undefined;
+    
+    assistantId: string | undefined;
+}
+export declare namespace DeleteAssistantAssociationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAssistantAssociationRequest) => any;
+}
+export interface DeleteAssistantAssociationResponse {
+}
+export declare namespace DeleteAssistantAssociationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAssistantAssociationResponse) => any;
+}
+export interface GetAssistantAssociationRequest {
+    
+    assistantAssociationId: string | undefined;
+    
+    assistantId: string | undefined;
+}
+export declare namespace GetAssistantAssociationRequest {
+    
+    const filterSensitiveLog: (obj: GetAssistantAssociationRequest) => any;
+}
+export interface GetAssistantAssociationResponse {
+    
+    assistantAssociation?: AssistantAssociationData;
+}
+export declare namespace GetAssistantAssociationResponse {
+    
+    const filterSensitiveLog: (obj: GetAssistantAssociationResponse) => any;
+}
+export interface ListAssistantAssociationsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    assistantId: string | undefined;
+}
+export declare namespace ListAssistantAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: ListAssistantAssociationsRequest) => any;
+}
+
+export interface AssistantAssociationSummary {
+    
+    assistantAssociationId: string | undefined;
+    
+    assistantAssociationArn: string | undefined;
+    
+    assistantId: string | undefined;
+    
+    assistantArn: string | undefined;
+    
+    associationType: AssociationType | string | undefined;
+    
+    associationData: AssistantAssociationOutputData | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AssistantAssociationSummary {
+    
+    const filterSensitiveLog: (obj: AssistantAssociationSummary) => any;
+}
+export interface ListAssistantAssociationsResponse {
+    
+    assistantAssociationSummaries: AssistantAssociationSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListAssistantAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: ListAssistantAssociationsResponse) => any;
+}
+
+export interface ServerSideEncryptionConfiguration {
+    
+    kmsKeyId?: string;
+}
+export declare namespace ServerSideEncryptionConfiguration {
+    
+    const filterSensitiveLog: (obj: ServerSideEncryptionConfiguration) => any;
+}
+export declare enum AssistantType {
+    AGENT = "AGENT"
+}
+export interface CreateAssistantRequest {
+    
+    clientToken?: string;
+    
+    name: string | undefined;
+    
+    type: AssistantType | string | undefined;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    serverSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
+}
+export declare namespace CreateAssistantRequest {
+    
+    const filterSensitiveLog: (obj: CreateAssistantRequest) => any;
+}
+export declare enum AssistantStatus {
+    ACTIVE = "ACTIVE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETED = "DELETED",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS"
+}
+
+export interface AssistantData {
+    
+    assistantId: string | undefined;
+    
+    assistantArn: string | undefined;
+    
+    name: string | undefined;
+    
+    type: AssistantType | string | undefined;
+    
+    status: AssistantStatus | string | undefined;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    serverSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
+}
+export declare namespace AssistantData {
+    
+    const filterSensitiveLog: (obj: AssistantData) => any;
+}
+export interface CreateAssistantResponse {
+    
+    assistant?: AssistantData;
+}
+export declare namespace CreateAssistantResponse {
+    
+    const filterSensitiveLog: (obj: CreateAssistantResponse) => any;
+}
+export interface DeleteAssistantRequest {
+    
+    assistantId: string | undefined;
+}
+export declare namespace DeleteAssistantRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAssistantRequest) => any;
+}
+export interface DeleteAssistantResponse {
+}
+export declare namespace DeleteAssistantResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAssistantResponse) => any;
+}
+export interface GetAssistantRequest {
+    
+    assistantId: string | undefined;
+}
+export declare namespace GetAssistantRequest {
+    
+    const filterSensitiveLog: (obj: GetAssistantRequest) => any;
+}
+export interface GetAssistantResponse {
+    
+    assistant?: AssistantData;
+}
+export declare namespace GetAssistantResponse {
+    
+    const filterSensitiveLog: (obj: GetAssistantResponse) => any;
+}
+export interface GetRecommendationsRequest {
+    
+    assistantId: string | undefined;
+    
+    sessionId: string | undefined;
+    
+    maxResults?: number;
+    
+    waitTimeSeconds?: number;
+}
+export declare namespace GetRecommendationsRequest {
+    
+    const filterSensitiveLog: (obj: GetRecommendationsRequest) => any;
+}
+
+export interface ContentReference {
+    
+    knowledgeBaseArn?: string;
+    
+    knowledgeBaseId?: string;
+    
+    contentArn?: string;
+    
+    contentId?: string;
+}
+export declare namespace ContentReference {
+    
+    const filterSensitiveLog: (obj: ContentReference) => any;
+}
+
+export interface Highlight {
+    
+    beginOffsetInclusive?: number;
+    
+    endOffsetExclusive?: number;
+}
+export declare namespace Highlight {
+    
+    const filterSensitiveLog: (obj: Highlight) => any;
+}
+
+export interface DocumentText {
+    
+    text?: string;
+    
+    highlights?: Highlight[];
+}
+export declare namespace DocumentText {
+    
+    const filterSensitiveLog: (obj: DocumentText) => any;
+}
+
+export interface Document {
+    
+    contentReference: ContentReference | undefined;
+    
+    title?: DocumentText;
+    
+    excerpt?: DocumentText;
+}
+export declare namespace Document {
+    
+    const filterSensitiveLog: (obj: Document) => any;
+}
+export declare enum RelevanceLevel {
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM"
+}
+
+export interface RecommendationData {
+    
+    recommendationId: string | undefined;
+    
+    document: Document | undefined;
+    
+    relevanceScore?: number;
+    
+    relevanceLevel?: RelevanceLevel | string;
+}
+export declare namespace RecommendationData {
+    
+    const filterSensitiveLog: (obj: RecommendationData) => any;
+}
+export interface GetRecommendationsResponse {
+    
+    recommendations: RecommendationData[] | undefined;
+}
+export declare namespace GetRecommendationsResponse {
+    
+    const filterSensitiveLog: (obj: GetRecommendationsResponse) => any;
+}
+export interface ListAssistantsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListAssistantsRequest {
+    
+    const filterSensitiveLog: (obj: ListAssistantsRequest) => any;
+}
+
+export interface AssistantSummary {
+    
+    assistantId: string | undefined;
+    
+    assistantArn: string | undefined;
+    
+    name: string | undefined;
+    
+    type: AssistantType | string | undefined;
+    
+    status: AssistantStatus | string | undefined;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    serverSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
+}
+export declare namespace AssistantSummary {
+    
+    const filterSensitiveLog: (obj: AssistantSummary) => any;
+}
+export interface ListAssistantsResponse {
+    
+    assistantSummaries: AssistantSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListAssistantsResponse {
+    
+    const filterSensitiveLog: (obj: ListAssistantsResponse) => any;
+}
+export interface NotifyRecommendationsReceivedRequest {
+    
+    assistantId: string | undefined;
+    
+    sessionId: string | undefined;
+    
+    recommendationIds: string[] | undefined;
+}
+export declare namespace NotifyRecommendationsReceivedRequest {
+    
+    const filterSensitiveLog: (obj: NotifyRecommendationsReceivedRequest) => any;
+}
+
+export interface NotifyRecommendationsReceivedError {
+    
+    recommendationId?: string;
+    
+    message?: string;
+}
+export declare namespace NotifyRecommendationsReceivedError {
+    
+    const filterSensitiveLog: (obj: NotifyRecommendationsReceivedError) => any;
+}
+export interface NotifyRecommendationsReceivedResponse {
+    
+    recommendationIds?: string[];
+    
+    errors?: NotifyRecommendationsReceivedError[];
+}
+export declare namespace NotifyRecommendationsReceivedResponse {
+    
+    const filterSensitiveLog: (obj: NotifyRecommendationsReceivedResponse) => any;
+}
+export interface QueryAssistantRequest {
+    
+    assistantId: string | undefined;
+    
+    queryText: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace QueryAssistantRequest {
+    
+    const filterSensitiveLog: (obj: QueryAssistantRequest) => any;
+}
+
+export interface ResultData {
+    
+    resultId: string | undefined;
+    
+    document: Document | undefined;
+    
+    relevanceScore?: number;
+}
+export declare namespace ResultData {
+    
+    const filterSensitiveLog: (obj: ResultData) => any;
+}
+export interface QueryAssistantResponse {
+    
+    results: ResultData[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace QueryAssistantResponse {
+    
+    const filterSensitiveLog: (obj: QueryAssistantResponse) => any;
+}
+export declare enum FilterField {
+    NAME = "NAME"
+}
+export declare enum FilterOperator {
+    EQUALS = "EQUALS"
+}
+
+export interface Filter {
+    
+    field: FilterField | string | undefined;
+    
+    operator: FilterOperator | string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+
+export interface SearchExpression {
+    
+    filters: Filter[] | undefined;
+}
+export declare namespace SearchExpression {
+    
+    const filterSensitiveLog: (obj: SearchExpression) => any;
+}
+export interface SearchSessionsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    assistantId: string | undefined;
+    
+    searchExpression: SearchExpression | undefined;
+}
+export declare namespace SearchSessionsRequest {
+    
+    const filterSensitiveLog: (obj: SearchSessionsRequest) => any;
+}
+
+export interface SessionSummary {
+    
+    sessionId: string | undefined;
+    
+    sessionArn: string | undefined;
+    
+    assistantId: string | undefined;
+    
+    assistantArn: string | undefined;
+}
+export declare namespace SessionSummary {
+    
+    const filterSensitiveLog: (obj: SessionSummary) => any;
+}
+export interface SearchSessionsResponse {
+    
+    sessionSummaries: SessionSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace SearchSessionsResponse {
+    
+    const filterSensitiveLog: (obj: SearchSessionsResponse) => any;
+}
+export interface CreateSessionRequest {
+    
+    clientToken?: string;
+    
+    assistantId: string | undefined;
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSessionRequest {
+    
+    const filterSensitiveLog: (obj: CreateSessionRequest) => any;
+}
+
+export interface SessionData {
+    
+    sessionArn: string | undefined;
+    
+    sessionId: string | undefined;
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace SessionData {
+    
+    const filterSensitiveLog: (obj: SessionData) => any;
+}
+export interface CreateSessionResponse {
+    
+    session?: SessionData;
+}
+export declare namespace CreateSessionResponse {
+    
+    const filterSensitiveLog: (obj: CreateSessionResponse) => any;
+}
+export interface GetSessionRequest {
+    
+    assistantId: string | undefined;
+    
+    sessionId: string | undefined;
+}
+export declare namespace GetSessionRequest {
+    
+    const filterSensitiveLog: (obj: GetSessionRequest) => any;
+}
+export interface GetSessionResponse {
+    
+    session?: SessionData;
+}
+export declare namespace GetSessionResponse {
+    
+    const filterSensitiveLog: (obj: GetSessionResponse) => any;
+}
+export interface CreateContentRequest {
+    
+    knowledgeBaseId: string | undefined;
+    
+    name: string | undefined;
+    
+    title?: string;
+    
+    overrideLinkOutUri?: string;
+    
+    metadata?: {
+        [key: string]: string;
+    };
+    
+    uploadId: string | undefined;
+    
+    clientToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateContentRequest {
+    
+    const filterSensitiveLog: (obj: CreateContentRequest) => any;
+}
+export declare enum ContentStatus {
+    ACTIVE = "ACTIVE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETED = "DELETED",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    UPDATE_FAILED = "UPDATE_FAILED"
+}
+
+export interface ContentData {
+    
+    contentArn: string | undefined;
+    
+    contentId: string | undefined;
+    
+    knowledgeBaseArn: string | undefined;
+    
+    knowledgeBaseId: string | undefined;
+    
+    name: string | undefined;
+    
+    revisionId: string | undefined;
+    
+    title: string | undefined;
+    
+    contentType: string | undefined;
+    
+    status: ContentStatus | string | undefined;
+    
+    metadata: {
+        [key: string]: string;
+    } | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    linkOutUri?: string;
+    
+    url: string | undefined;
+    
+    urlExpiry: Date | undefined;
+}
+export declare namespace ContentData {
+    
+    const filterSensitiveLog: (obj: ContentData) => any;
+}
+export interface CreateContentResponse {
+    
+    content?: ContentData;
+}
+export declare namespace CreateContentResponse {
+    
+    const filterSensitiveLog: (obj: CreateContentResponse) => any;
+}
+export interface DeleteContentRequest {
+    
+    knowledgeBaseId: string | undefined;
+    
+    contentId: string | undefined;
+}
+export declare namespace DeleteContentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteContentRequest) => any;
+}
+export interface DeleteContentResponse {
+}
+export declare namespace DeleteContentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteContentResponse) => any;
+}
+export interface GetContentRequest {
+    
+    contentId: string | undefined;
+    
+    knowledgeBaseId: string | undefined;
+}
+export declare namespace GetContentRequest {
+    
+    const filterSensitiveLog: (obj: GetContentRequest) => any;
+}
+export interface GetContentResponse {
+    
+    content?: ContentData;
+}
+export declare namespace GetContentResponse {
+    
+    const filterSensitiveLog: (obj: GetContentResponse) => any;
+}
+export interface GetContentSummaryRequest {
+    
+    contentId: string | undefined;
+    
+    knowledgeBaseId: string | undefined;
+}
+export declare namespace GetContentSummaryRequest {
+    
+    const filterSensitiveLog: (obj: GetContentSummaryRequest) => any;
+}
+
+export interface ContentSummary {
+    
+    contentArn: string | undefined;
+    
+    contentId: string | undefined;
+    
+    knowledgeBaseArn: string | undefined;
+    
+    knowledgeBaseId: string | undefined;
+    
+    name: string | undefined;
+    
+    revisionId: string | undefined;
+    
+    title: string | undefined;
+    
+    contentType: string | undefined;
+    
+    status: ContentStatus | string | undefined;
+    
+    metadata: {
+        [key: string]: string;
+    } | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ContentSummary {
+    
+    const filterSensitiveLog: (obj: ContentSummary) => any;
+}
+export interface GetContentSummaryResponse {
+    
+    contentSummary?: ContentSummary;
+}
+export declare namespace GetContentSummaryResponse {
+    
+    const filterSensitiveLog: (obj: GetContentSummaryResponse) => any;
+}
+export interface ListContentsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    knowledgeBaseId: string | undefined;
+}
+export declare namespace ListContentsRequest {
+    
+    const filterSensitiveLog: (obj: ListContentsRequest) => any;
+}
+export interface ListContentsResponse {
+    
+    contentSummaries: ContentSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListContentsResponse {
+    
+    const filterSensitiveLog: (obj: ListContentsResponse) => any;
+}
+
+export declare class PreconditionFailedException extends __BaseException {
+    readonly name: "PreconditionFailedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PreconditionFailedException, __BaseException>);
+}
+export interface UpdateContentRequest {
+    
+    knowledgeBaseId: string | undefined;
+    
+    contentId: string | undefined;
+    
+    revisionId?: string;
+    
+    title?: string;
+    
+    overrideLinkOutUri?: string;
+    
+    removeOverrideLinkOutUri?: boolean;
+    
+    metadata?: {
+        [key: string]: string;
+    };
+    
+    uploadId?: string;
+}
+export declare namespace UpdateContentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContentRequest) => any;
+}
+export interface UpdateContentResponse {
+    
+    content?: ContentData;
+}
+export declare namespace UpdateContentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateContentResponse) => any;
+}
+export declare enum KnowledgeBaseType {
+    CUSTOM = "CUSTOM",
+    EXTERNAL = "EXTERNAL"
+}
+
+export interface RenderingConfiguration {
+    
+    templateUri?: string;
+}
+export declare namespace RenderingConfiguration {
+    
+    const filterSensitiveLog: (obj: RenderingConfiguration) => any;
+}
+
+export declare type SourceConfiguration = SourceConfiguration.AppIntegrationsMember | SourceConfiguration.$UnknownMember;
+export declare namespace SourceConfiguration {
+    
+    interface AppIntegrationsMember {
+        appIntegrations: AppIntegrationsConfiguration;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        appIntegrations?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        appIntegrations: (value: AppIntegrationsConfiguration) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: SourceConfiguration, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: SourceConfiguration) => any;
+}
+export interface CreateKnowledgeBaseRequest {
+    
+    clientToken?: string;
+    
+    name: string | undefined;
+    
+    knowledgeBaseType: KnowledgeBaseType | string | undefined;
+    
+    sourceConfiguration?: SourceConfiguration;
+    
+    renderingConfiguration?: RenderingConfiguration;
+    
+    serverSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateKnowledgeBaseRequest {
+    
+    const filterSensitiveLog: (obj: CreateKnowledgeBaseRequest) => any;
+}
+export declare enum KnowledgeBaseStatus {
+    ACTIVE = "ACTIVE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETED = "DELETED",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS"
+}
+
+export interface KnowledgeBaseData {
+    
+    knowledgeBaseId: string | undefined;
+    
+    knowledgeBaseArn: string | undefined;
+    
+    name: string | undefined;
+    
+    knowledgeBaseType: KnowledgeBaseType | string | undefined;
+    
+    status: KnowledgeBaseStatus | string | undefined;
+    
+    lastContentModificationTime?: Date;
+    
+    sourceConfiguration?: SourceConfiguration;
+    
+    renderingConfiguration?: RenderingConfiguration;
+    
+    serverSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace KnowledgeBaseData {
+    
+    const filterSensitiveLog: (obj: KnowledgeBaseData) => any;
+}
+export interface CreateKnowledgeBaseResponse {
+    
+    knowledgeBase?: KnowledgeBaseData;
+}
+export declare namespace CreateKnowledgeBaseResponse {
+    
+    const filterSensitiveLog: (obj: CreateKnowledgeBaseResponse) => any;
+}
+export interface DeleteKnowledgeBaseRequest {
+    
+    knowledgeBaseId: string | undefined;
+}
+export declare namespace DeleteKnowledgeBaseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteKnowledgeBaseRequest) => any;
+}
+export interface DeleteKnowledgeBaseResponse {
+}
+export declare namespace DeleteKnowledgeBaseResponse {
+    
+    const filterSensitiveLog: (obj: DeleteKnowledgeBaseResponse) => any;
+}
+export interface GetKnowledgeBaseRequest {
+    
+    knowledgeBaseId: string | undefined;
+}
+export declare namespace GetKnowledgeBaseRequest {
+    
+    const filterSensitiveLog: (obj: GetKnowledgeBaseRequest) => any;
+}
+export interface GetKnowledgeBaseResponse {
+    
+    knowledgeBase?: KnowledgeBaseData;
+}
+export declare namespace GetKnowledgeBaseResponse {
+    
+    const filterSensitiveLog: (obj: GetKnowledgeBaseResponse) => any;
+}
+export interface ListKnowledgeBasesRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListKnowledgeBasesRequest {
+    
+    const filterSensitiveLog: (obj: ListKnowledgeBasesRequest) => any;
+}
+
+export interface KnowledgeBaseSummary {
+    
+    knowledgeBaseId: string | undefined;
+    
+    knowledgeBaseArn: string | undefined;
+    
+    name: string | undefined;
+    
+    knowledgeBaseType: KnowledgeBaseType | string | undefined;
+    
+    status: KnowledgeBaseStatus | string | undefined;
+    
+    sourceConfiguration?: SourceConfiguration;
+    
+    renderingConfiguration?: RenderingConfiguration;
+    
+    serverSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
+    
+    description?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace KnowledgeBaseSummary {
+    
+    const filterSensitiveLog: (obj: KnowledgeBaseSummary) => any;
+}
+export interface ListKnowledgeBasesResponse {
+    
+    knowledgeBaseSummaries: KnowledgeBaseSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListKnowledgeBasesResponse {
+    
+    const filterSensitiveLog: (obj: ListKnowledgeBasesResponse) => any;
+}
+export interface RemoveKnowledgeBaseTemplateUriRequest {
+    
+    knowledgeBaseId: string | undefined;
+}
+export declare namespace RemoveKnowledgeBaseTemplateUriRequest {
+    
+    const filterSensitiveLog: (obj: RemoveKnowledgeBaseTemplateUriRequest) => any;
+}
+export interface RemoveKnowledgeBaseTemplateUriResponse {
+}
+export declare namespace RemoveKnowledgeBaseTemplateUriResponse {
+    
+    const filterSensitiveLog: (obj: RemoveKnowledgeBaseTemplateUriResponse) => any;
+}
+export interface SearchContentRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    knowledgeBaseId: string | undefined;
+    
+    searchExpression: SearchExpression | undefined;
+}
+export declare namespace SearchContentRequest {
+    
+    const filterSensitiveLog: (obj: SearchContentRequest) => any;
+}
+export interface SearchContentResponse {
+    
+    contentSummaries: ContentSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace SearchContentResponse {
+    
+    const filterSensitiveLog: (obj: SearchContentResponse) => any;
+}
+export interface StartContentUploadRequest {
+    
+    knowledgeBaseId: string | undefined;
+    
+    contentType: string | undefined;
+}
+export declare namespace StartContentUploadRequest {
+    
+    const filterSensitiveLog: (obj: StartContentUploadRequest) => any;
+}
+export interface StartContentUploadResponse {
+    
+    uploadId: string | undefined;
+    
+    url: string | undefined;
+    
+    urlExpiry: Date | undefined;
+    
+    headersToInclude: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace StartContentUploadResponse {
+    
+    const filterSensitiveLog: (obj: StartContentUploadResponse) => any;
+}
+export interface UpdateKnowledgeBaseTemplateUriRequest {
+    
+    knowledgeBaseId: string | undefined;
+    
+    templateUri: string | undefined;
+}
+export declare namespace UpdateKnowledgeBaseTemplateUriRequest {
+    
+    const filterSensitiveLog: (obj: UpdateKnowledgeBaseTemplateUriRequest) => any;
+}
+export interface UpdateKnowledgeBaseTemplateUriResponse {
+    
+    knowledgeBase?: KnowledgeBaseData;
+}
+export declare namespace UpdateKnowledgeBaseTemplateUriResponse {
+    
+    const filterSensitiveLog: (obj: UpdateKnowledgeBaseTemplateUriResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    
+    resourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+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;
+}