@aws-amplify/graphql-api-construct 1.20.0 → 1.20.2

package/node_modules/@aws-amplify/ai-constructs/node_modules/@aws-sdk/client-bedrock-runtime/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1212 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { DocumentType as __DocumentType } from "@smithy/types";
+import { BedrockRuntimeServiceException as __BaseException } from "./BedrockRuntimeServiceException";
+export declare class AccessDeniedException extends __BaseException {
+  readonly name: "AccessDeniedException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
+  );
+}
+export declare const GuardrailContentQualifier: {
+  readonly GROUNDING_SOURCE: "grounding_source";
+  readonly GUARD_CONTENT: "guard_content";
+  readonly QUERY: "query";
+};
+export type GuardrailContentQualifier =
+  (typeof GuardrailContentQualifier)[keyof typeof GuardrailContentQualifier];
+export interface GuardrailTextBlock {
+  text: string | undefined;
+  qualifiers?: GuardrailContentQualifier[];
+}
+export type GuardrailContentBlock =
+  | GuardrailContentBlock.TextMember
+  | GuardrailContentBlock.$UnknownMember;
+export declare namespace GuardrailContentBlock {
+  interface TextMember {
+    text: GuardrailTextBlock;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: GuardrailTextBlock) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: GuardrailContentBlock, visitor: Visitor<T>) => T;
+}
+export declare const GuardrailContentSource: {
+  readonly INPUT: "INPUT";
+  readonly OUTPUT: "OUTPUT";
+};
+export type GuardrailContentSource =
+  (typeof GuardrailContentSource)[keyof typeof GuardrailContentSource];
+export interface ApplyGuardrailRequest {
+  guardrailIdentifier: string | undefined;
+  guardrailVersion: string | undefined;
+  source: GuardrailContentSource | undefined;
+  content: GuardrailContentBlock[] | undefined;
+}
+export declare const GuardrailAction: {
+  readonly GUARDRAIL_INTERVENED: "GUARDRAIL_INTERVENED";
+  readonly NONE: "NONE";
+};
+export type GuardrailAction =
+  (typeof GuardrailAction)[keyof typeof GuardrailAction];
+export declare const GuardrailContentPolicyAction: {
+  readonly BLOCKED: "BLOCKED";
+};
+export type GuardrailContentPolicyAction =
+  (typeof GuardrailContentPolicyAction)[keyof typeof GuardrailContentPolicyAction];
+export declare const GuardrailContentFilterConfidence: {
+  readonly HIGH: "HIGH";
+  readonly LOW: "LOW";
+  readonly MEDIUM: "MEDIUM";
+  readonly NONE: "NONE";
+};
+export type GuardrailContentFilterConfidence =
+  (typeof GuardrailContentFilterConfidence)[keyof typeof GuardrailContentFilterConfidence];
+export declare const GuardrailContentFilterType: {
+  readonly HATE: "HATE";
+  readonly INSULTS: "INSULTS";
+  readonly MISCONDUCT: "MISCONDUCT";
+  readonly PROMPT_ATTACK: "PROMPT_ATTACK";
+  readonly SEXUAL: "SEXUAL";
+  readonly VIOLENCE: "VIOLENCE";
+};
+export type GuardrailContentFilterType =
+  (typeof GuardrailContentFilterType)[keyof typeof GuardrailContentFilterType];
+export interface GuardrailContentFilter {
+  type: GuardrailContentFilterType | undefined;
+  confidence: GuardrailContentFilterConfidence | undefined;
+  action: GuardrailContentPolicyAction | undefined;
+}
+export interface GuardrailContentPolicyAssessment {
+  filters: GuardrailContentFilter[] | undefined;
+}
+export declare const GuardrailContextualGroundingPolicyAction: {
+  readonly BLOCKED: "BLOCKED";
+  readonly NONE: "NONE";
+};
+export type GuardrailContextualGroundingPolicyAction =
+  (typeof GuardrailContextualGroundingPolicyAction)[keyof typeof GuardrailContextualGroundingPolicyAction];
+export declare const GuardrailContextualGroundingFilterType: {
+  readonly GROUNDING: "GROUNDING";
+  readonly RELEVANCE: "RELEVANCE";
+};
+export type GuardrailContextualGroundingFilterType =
+  (typeof GuardrailContextualGroundingFilterType)[keyof typeof GuardrailContextualGroundingFilterType];
+export interface GuardrailContextualGroundingFilter {
+  type: GuardrailContextualGroundingFilterType | undefined;
+  threshold: number | undefined;
+  score: number | undefined;
+  action: GuardrailContextualGroundingPolicyAction | undefined;
+}
+export interface GuardrailContextualGroundingPolicyAssessment {
+  filters?: GuardrailContextualGroundingFilter[];
+}
+export declare const GuardrailSensitiveInformationPolicyAction: {
+  readonly ANONYMIZED: "ANONYMIZED";
+  readonly BLOCKED: "BLOCKED";
+};
+export type GuardrailSensitiveInformationPolicyAction =
+  (typeof GuardrailSensitiveInformationPolicyAction)[keyof typeof GuardrailSensitiveInformationPolicyAction];
+export declare const GuardrailPiiEntityType: {
+  readonly ADDRESS: "ADDRESS";
+  readonly AGE: "AGE";
+  readonly AWS_ACCESS_KEY: "AWS_ACCESS_KEY";
+  readonly AWS_SECRET_KEY: "AWS_SECRET_KEY";
+  readonly CA_HEALTH_NUMBER: "CA_HEALTH_NUMBER";
+  readonly CA_SOCIAL_INSURANCE_NUMBER: "CA_SOCIAL_INSURANCE_NUMBER";
+  readonly CREDIT_DEBIT_CARD_CVV: "CREDIT_DEBIT_CARD_CVV";
+  readonly CREDIT_DEBIT_CARD_EXPIRY: "CREDIT_DEBIT_CARD_EXPIRY";
+  readonly CREDIT_DEBIT_CARD_NUMBER: "CREDIT_DEBIT_CARD_NUMBER";
+  readonly DRIVER_ID: "DRIVER_ID";
+  readonly EMAIL: "EMAIL";
+  readonly INTERNATIONAL_BANK_ACCOUNT_NUMBER: "INTERNATIONAL_BANK_ACCOUNT_NUMBER";
+  readonly IP_ADDRESS: "IP_ADDRESS";
+  readonly LICENSE_PLATE: "LICENSE_PLATE";
+  readonly MAC_ADDRESS: "MAC_ADDRESS";
+  readonly NAME: "NAME";
+  readonly PASSWORD: "PASSWORD";
+  readonly PHONE: "PHONE";
+  readonly PIN: "PIN";
+  readonly SWIFT_CODE: "SWIFT_CODE";
+  readonly UK_NATIONAL_HEALTH_SERVICE_NUMBER: "UK_NATIONAL_HEALTH_SERVICE_NUMBER";
+  readonly UK_NATIONAL_INSURANCE_NUMBER: "UK_NATIONAL_INSURANCE_NUMBER";
+  readonly UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER: "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER";
+  readonly URL: "URL";
+  readonly USERNAME: "USERNAME";
+  readonly US_BANK_ACCOUNT_NUMBER: "US_BANK_ACCOUNT_NUMBER";
+  readonly US_BANK_ROUTING_NUMBER: "US_BANK_ROUTING_NUMBER";
+  readonly US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER: "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER";
+  readonly US_PASSPORT_NUMBER: "US_PASSPORT_NUMBER";
+  readonly US_SOCIAL_SECURITY_NUMBER: "US_SOCIAL_SECURITY_NUMBER";
+  readonly VEHICLE_IDENTIFICATION_NUMBER: "VEHICLE_IDENTIFICATION_NUMBER";
+};
+export type GuardrailPiiEntityType =
+  (typeof GuardrailPiiEntityType)[keyof typeof GuardrailPiiEntityType];
+export interface GuardrailPiiEntityFilter {
+  match: string | undefined;
+  type: GuardrailPiiEntityType | undefined;
+  action: GuardrailSensitiveInformationPolicyAction | undefined;
+}
+export interface GuardrailRegexFilter {
+  name?: string;
+  match?: string;
+  regex?: string;
+  action: GuardrailSensitiveInformationPolicyAction | undefined;
+}
+export interface GuardrailSensitiveInformationPolicyAssessment {
+  piiEntities: GuardrailPiiEntityFilter[] | undefined;
+  regexes: GuardrailRegexFilter[] | undefined;
+}
+export declare const GuardrailTopicPolicyAction: {
+  readonly BLOCKED: "BLOCKED";
+};
+export type GuardrailTopicPolicyAction =
+  (typeof GuardrailTopicPolicyAction)[keyof typeof GuardrailTopicPolicyAction];
+export declare const GuardrailTopicType: {
+  readonly DENY: "DENY";
+};
+export type GuardrailTopicType =
+  (typeof GuardrailTopicType)[keyof typeof GuardrailTopicType];
+export interface GuardrailTopic {
+  name: string | undefined;
+  type: GuardrailTopicType | undefined;
+  action: GuardrailTopicPolicyAction | undefined;
+}
+export interface GuardrailTopicPolicyAssessment {
+  topics: GuardrailTopic[] | undefined;
+}
+export declare const GuardrailWordPolicyAction: {
+  readonly BLOCKED: "BLOCKED";
+};
+export type GuardrailWordPolicyAction =
+  (typeof GuardrailWordPolicyAction)[keyof typeof GuardrailWordPolicyAction];
+export interface GuardrailCustomWord {
+  match: string | undefined;
+  action: GuardrailWordPolicyAction | undefined;
+}
+export declare const GuardrailManagedWordType: {
+  readonly PROFANITY: "PROFANITY";
+};
+export type GuardrailManagedWordType =
+  (typeof GuardrailManagedWordType)[keyof typeof GuardrailManagedWordType];
+export interface GuardrailManagedWord {
+  match: string | undefined;
+  type: GuardrailManagedWordType | undefined;
+  action: GuardrailWordPolicyAction | undefined;
+}
+export interface GuardrailWordPolicyAssessment {
+  customWords: GuardrailCustomWord[] | undefined;
+  managedWordLists: GuardrailManagedWord[] | undefined;
+}
+export interface GuardrailAssessment {
+  topicPolicy?: GuardrailTopicPolicyAssessment;
+  contentPolicy?: GuardrailContentPolicyAssessment;
+  wordPolicy?: GuardrailWordPolicyAssessment;
+  sensitiveInformationPolicy?: GuardrailSensitiveInformationPolicyAssessment;
+  contextualGroundingPolicy?: GuardrailContextualGroundingPolicyAssessment;
+}
+export interface GuardrailOutputContent {
+  text?: string;
+}
+export interface GuardrailUsage {
+  topicPolicyUnits: number | undefined;
+  contentPolicyUnits: number | undefined;
+  wordPolicyUnits: number | undefined;
+  sensitiveInformationPolicyUnits: number | undefined;
+  sensitiveInformationPolicyFreeUnits: number | undefined;
+  contextualGroundingPolicyUnits: number | undefined;
+}
+export interface ApplyGuardrailResponse {
+  usage: GuardrailUsage | undefined;
+  action: GuardrailAction | undefined;
+  outputs: GuardrailOutputContent[] | undefined;
+  assessments: GuardrailAssessment[] | undefined;
+}
+export declare class InternalServerException extends __BaseException {
+  readonly name: "InternalServerException";
+  readonly $fault: "server";
+  constructor(
+    opts: __ExceptionOptionType<InternalServerException, __BaseException>
+  );
+}
+export declare class ResourceNotFoundException extends __BaseException {
+  readonly name: "ResourceNotFoundException";
+  readonly $fault: "client";
+  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 ThrottlingException extends __BaseException {
+  readonly name: "ThrottlingException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
+  );
+}
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export declare const GuardrailTrace: {
+  readonly DISABLED: "disabled";
+  readonly ENABLED: "enabled";
+};
+export type GuardrailTrace =
+  (typeof GuardrailTrace)[keyof typeof GuardrailTrace];
+export interface GuardrailConfiguration {
+  guardrailIdentifier: string | undefined;
+  guardrailVersion: string | undefined;
+  trace?: GuardrailTrace;
+}
+export interface InferenceConfiguration {
+  maxTokens?: number;
+  temperature?: number;
+  topP?: number;
+  stopSequences?: string[];
+}
+export declare const DocumentFormat: {
+  readonly CSV: "csv";
+  readonly DOC: "doc";
+  readonly DOCX: "docx";
+  readonly HTML: "html";
+  readonly MD: "md";
+  readonly PDF: "pdf";
+  readonly TXT: "txt";
+  readonly XLS: "xls";
+  readonly XLSX: "xlsx";
+};
+export type DocumentFormat =
+  (typeof DocumentFormat)[keyof typeof DocumentFormat];
+export type DocumentSource =
+  | DocumentSource.BytesMember
+  | DocumentSource.$UnknownMember;
+export declare namespace DocumentSource {
+  interface BytesMember {
+    bytes: Uint8Array;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    bytes?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    bytes: (value: Uint8Array) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: DocumentSource, visitor: Visitor<T>) => T;
+}
+export interface DocumentBlock {
+  format: DocumentFormat | undefined;
+  name: string | undefined;
+  source: DocumentSource | undefined;
+}
+export declare const GuardrailConverseContentQualifier: {
+  readonly GROUNDING_SOURCE: "grounding_source";
+  readonly GUARD_CONTENT: "guard_content";
+  readonly QUERY: "query";
+};
+export type GuardrailConverseContentQualifier =
+  (typeof GuardrailConverseContentQualifier)[keyof typeof GuardrailConverseContentQualifier];
+export interface GuardrailConverseTextBlock {
+  text: string | undefined;
+  qualifiers?: GuardrailConverseContentQualifier[];
+}
+export type GuardrailConverseContentBlock =
+  | GuardrailConverseContentBlock.TextMember
+  | GuardrailConverseContentBlock.$UnknownMember;
+export declare namespace GuardrailConverseContentBlock {
+  interface TextMember {
+    text: GuardrailConverseTextBlock;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: GuardrailConverseTextBlock) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(
+    value: GuardrailConverseContentBlock,
+    visitor: Visitor<T>
+  ) => T;
+}
+export declare const ImageFormat: {
+  readonly GIF: "gif";
+  readonly JPEG: "jpeg";
+  readonly PNG: "png";
+  readonly WEBP: "webp";
+};
+export type ImageFormat = (typeof ImageFormat)[keyof typeof ImageFormat];
+export type ImageSource = ImageSource.BytesMember | ImageSource.$UnknownMember;
+export declare namespace ImageSource {
+  interface BytesMember {
+    bytes: Uint8Array;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    bytes?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    bytes: (value: Uint8Array) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ImageSource, visitor: Visitor<T>) => T;
+}
+export interface ImageBlock {
+  format: ImageFormat | undefined;
+  source: ImageSource | undefined;
+}
+export type ToolResultContentBlock =
+  | ToolResultContentBlock.DocumentMember
+  | ToolResultContentBlock.ImageMember
+  | ToolResultContentBlock.JsonMember
+  | ToolResultContentBlock.TextMember
+  | ToolResultContentBlock.$UnknownMember;
+export declare namespace ToolResultContentBlock {
+  interface JsonMember {
+    json: __DocumentType;
+    text?: never;
+    image?: never;
+    document?: never;
+    $unknown?: never;
+  }
+  interface TextMember {
+    json?: never;
+    text: string;
+    image?: never;
+    document?: never;
+    $unknown?: never;
+  }
+  interface ImageMember {
+    json?: never;
+    text?: never;
+    image: ImageBlock;
+    document?: never;
+    $unknown?: never;
+  }
+  interface DocumentMember {
+    json?: never;
+    text?: never;
+    image?: never;
+    document: DocumentBlock;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    json?: never;
+    text?: never;
+    image?: never;
+    document?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    json: (value: __DocumentType) => T;
+    text: (value: string) => T;
+    image: (value: ImageBlock) => T;
+    document: (value: DocumentBlock) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ToolResultContentBlock, visitor: Visitor<T>) => T;
+}
+export declare const ToolResultStatus: {
+  readonly ERROR: "error";
+  readonly SUCCESS: "success";
+};
+export type ToolResultStatus =
+  (typeof ToolResultStatus)[keyof typeof ToolResultStatus];
+export interface ToolResultBlock {
+  toolUseId: string | undefined;
+  content: ToolResultContentBlock[] | undefined;
+  status?: ToolResultStatus;
+}
+export interface ToolUseBlock {
+  toolUseId: string | undefined;
+  name: string | undefined;
+  input: __DocumentType | undefined;
+}
+export type ContentBlock =
+  | ContentBlock.DocumentMember
+  | ContentBlock.GuardContentMember
+  | ContentBlock.ImageMember
+  | ContentBlock.TextMember
+  | ContentBlock.ToolResultMember
+  | ContentBlock.ToolUseMember
+  | ContentBlock.$UnknownMember;
+export declare namespace ContentBlock {
+  interface TextMember {
+    text: string;
+    image?: never;
+    document?: never;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    $unknown?: never;
+  }
+  interface ImageMember {
+    text?: never;
+    image: ImageBlock;
+    document?: never;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    $unknown?: never;
+  }
+  interface DocumentMember {
+    text?: never;
+    image?: never;
+    document: DocumentBlock;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    $unknown?: never;
+  }
+  interface ToolUseMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    toolUse: ToolUseBlock;
+    toolResult?: never;
+    guardContent?: never;
+    $unknown?: never;
+  }
+  interface ToolResultMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    toolUse?: never;
+    toolResult: ToolResultBlock;
+    guardContent?: never;
+    $unknown?: never;
+  }
+  interface GuardContentMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent: GuardrailConverseContentBlock;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    image: (value: ImageBlock) => T;
+    document: (value: DocumentBlock) => T;
+    toolUse: (value: ToolUseBlock) => T;
+    toolResult: (value: ToolResultBlock) => T;
+    guardContent: (value: GuardrailConverseContentBlock) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ContentBlock, visitor: Visitor<T>) => T;
+}
+export declare const ConversationRole: {
+  readonly ASSISTANT: "assistant";
+  readonly USER: "user";
+};
+export type ConversationRole =
+  (typeof ConversationRole)[keyof typeof ConversationRole];
+export interface Message {
+  role: ConversationRole | undefined;
+  content: ContentBlock[] | undefined;
+}
+export type SystemContentBlock =
+  | SystemContentBlock.GuardContentMember
+  | SystemContentBlock.TextMember
+  | SystemContentBlock.$UnknownMember;
+export declare namespace SystemContentBlock {
+  interface TextMember {
+    text: string;
+    guardContent?: never;
+    $unknown?: never;
+  }
+  interface GuardContentMember {
+    text?: never;
+    guardContent: GuardrailConverseContentBlock;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    guardContent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    guardContent: (value: GuardrailConverseContentBlock) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: SystemContentBlock, visitor: Visitor<T>) => T;
+}
+export interface AnyToolChoice {}
+export interface AutoToolChoice {}
+export interface SpecificToolChoice {
+  name: string | undefined;
+}
+export type ToolChoice =
+  | ToolChoice.AnyMember
+  | ToolChoice.AutoMember
+  | ToolChoice.ToolMember
+  | ToolChoice.$UnknownMember;
+export declare namespace ToolChoice {
+  interface AutoMember {
+    auto: AutoToolChoice;
+    any?: never;
+    tool?: never;
+    $unknown?: never;
+  }
+  interface AnyMember {
+    auto?: never;
+    any: AnyToolChoice;
+    tool?: never;
+    $unknown?: never;
+  }
+  interface ToolMember {
+    auto?: never;
+    any?: never;
+    tool: SpecificToolChoice;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    auto?: never;
+    any?: never;
+    tool?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    auto: (value: AutoToolChoice) => T;
+    any: (value: AnyToolChoice) => T;
+    tool: (value: SpecificToolChoice) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ToolChoice, visitor: Visitor<T>) => T;
+}
+export type ToolInputSchema =
+  | ToolInputSchema.JsonMember
+  | ToolInputSchema.$UnknownMember;
+export declare namespace ToolInputSchema {
+  interface JsonMember {
+    json: __DocumentType;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    json?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    json: (value: __DocumentType) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ToolInputSchema, visitor: Visitor<T>) => T;
+}
+export interface ToolSpecification {
+  name: string | undefined;
+  description?: string;
+  inputSchema: ToolInputSchema | undefined;
+}
+export type Tool = Tool.ToolSpecMember | Tool.$UnknownMember;
+export declare namespace Tool {
+  interface ToolSpecMember {
+    toolSpec: ToolSpecification;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    toolSpec?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    toolSpec: (value: ToolSpecification) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: Tool, visitor: Visitor<T>) => T;
+}
+export interface ToolConfiguration {
+  tools: Tool[] | undefined;
+  toolChoice?: ToolChoice;
+}
+export interface ConverseRequest {
+  modelId: string | undefined;
+  messages: Message[] | undefined;
+  system?: SystemContentBlock[];
+  inferenceConfig?: InferenceConfiguration;
+  toolConfig?: ToolConfiguration;
+  guardrailConfig?: GuardrailConfiguration;
+  additionalModelRequestFields?: __DocumentType;
+  additionalModelResponseFieldPaths?: string[];
+}
+export interface ConverseMetrics {
+  latencyMs: number | undefined;
+}
+export type ConverseOutput =
+  | ConverseOutput.MessageMember
+  | ConverseOutput.$UnknownMember;
+export declare namespace ConverseOutput {
+  interface MessageMember {
+    message: Message;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    message?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    message: (value: Message) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ConverseOutput, visitor: Visitor<T>) => T;
+}
+export declare const StopReason: {
+  readonly CONTENT_FILTERED: "content_filtered";
+  readonly END_TURN: "end_turn";
+  readonly GUARDRAIL_INTERVENED: "guardrail_intervened";
+  readonly MAX_TOKENS: "max_tokens";
+  readonly STOP_SEQUENCE: "stop_sequence";
+  readonly TOOL_USE: "tool_use";
+};
+export type StopReason = (typeof StopReason)[keyof typeof StopReason];
+export interface GuardrailTraceAssessment {
+  modelOutput?: string[];
+  inputAssessment?: Record<string, GuardrailAssessment>;
+  outputAssessments?: Record<string, GuardrailAssessment[]>;
+}
+export interface ConverseTrace {
+  guardrail?: GuardrailTraceAssessment;
+}
+export interface TokenUsage {
+  inputTokens: number | undefined;
+  outputTokens: number | undefined;
+  totalTokens: number | undefined;
+}
+export interface ConverseResponse {
+  output: ConverseOutput | undefined;
+  stopReason: StopReason | undefined;
+  usage: TokenUsage | undefined;
+  metrics: ConverseMetrics | undefined;
+  additionalModelResponseFields?: __DocumentType;
+  trace?: ConverseTrace;
+}
+export declare class ModelErrorException extends __BaseException {
+  readonly name: "ModelErrorException";
+  readonly $fault: "client";
+  originalStatusCode?: number;
+  resourceName?: string;
+  constructor(
+    opts: __ExceptionOptionType<ModelErrorException, __BaseException>
+  );
+}
+export declare class ModelNotReadyException extends __BaseException {
+  readonly name: "ModelNotReadyException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ModelNotReadyException, __BaseException>
+  );
+}
+export declare class ModelTimeoutException extends __BaseException {
+  readonly name: "ModelTimeoutException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ModelTimeoutException, __BaseException>
+  );
+}
+export declare class ServiceUnavailableException extends __BaseException {
+  readonly name: "ServiceUnavailableException";
+  readonly $fault: "server";
+  constructor(
+    opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>
+  );
+}
+export declare const GuardrailStreamProcessingMode: {
+  readonly ASYNC: "async";
+  readonly SYNC: "sync";
+};
+export type GuardrailStreamProcessingMode =
+  (typeof GuardrailStreamProcessingMode)[keyof typeof GuardrailStreamProcessingMode];
+export interface GuardrailStreamConfiguration {
+  guardrailIdentifier: string | undefined;
+  guardrailVersion: string | undefined;
+  trace?: GuardrailTrace;
+  streamProcessingMode?: GuardrailStreamProcessingMode;
+}
+export interface ConverseStreamRequest {
+  modelId: string | undefined;
+  messages: Message[] | undefined;
+  system?: SystemContentBlock[];
+  inferenceConfig?: InferenceConfiguration;
+  toolConfig?: ToolConfiguration;
+  guardrailConfig?: GuardrailStreamConfiguration;
+  additionalModelRequestFields?: __DocumentType;
+  additionalModelResponseFieldPaths?: string[];
+}
+export interface ToolUseBlockDelta {
+  input: string | undefined;
+}
+export type ContentBlockDelta =
+  | ContentBlockDelta.TextMember
+  | ContentBlockDelta.ToolUseMember
+  | ContentBlockDelta.$UnknownMember;
+export declare namespace ContentBlockDelta {
+  interface TextMember {
+    text: string;
+    toolUse?: never;
+    $unknown?: never;
+  }
+  interface ToolUseMember {
+    text?: never;
+    toolUse: ToolUseBlockDelta;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    toolUse?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    toolUse: (value: ToolUseBlockDelta) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ContentBlockDelta, visitor: Visitor<T>) => T;
+}
+export interface ContentBlockDeltaEvent {
+  delta: ContentBlockDelta | undefined;
+  contentBlockIndex: number | undefined;
+}
+export interface ToolUseBlockStart {
+  toolUseId: string | undefined;
+  name: string | undefined;
+}
+export type ContentBlockStart =
+  | ContentBlockStart.ToolUseMember
+  | ContentBlockStart.$UnknownMember;
+export declare namespace ContentBlockStart {
+  interface ToolUseMember {
+    toolUse: ToolUseBlockStart;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    toolUse?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    toolUse: (value: ToolUseBlockStart) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ContentBlockStart, visitor: Visitor<T>) => T;
+}
+export interface ContentBlockStartEvent {
+  start: ContentBlockStart | undefined;
+  contentBlockIndex: number | undefined;
+}
+export interface ContentBlockStopEvent {
+  contentBlockIndex: number | undefined;
+}
+export interface MessageStartEvent {
+  role: ConversationRole | undefined;
+}
+export interface MessageStopEvent {
+  stopReason: StopReason | undefined;
+  additionalModelResponseFields?: __DocumentType;
+}
+export interface ConverseStreamMetrics {
+  latencyMs: number | undefined;
+}
+export interface ConverseStreamTrace {
+  guardrail?: GuardrailTraceAssessment;
+}
+export interface ConverseStreamMetadataEvent {
+  usage: TokenUsage | undefined;
+  metrics: ConverseStreamMetrics | undefined;
+  trace?: ConverseStreamTrace;
+}
+export declare class ModelStreamErrorException extends __BaseException {
+  readonly name: "ModelStreamErrorException";
+  readonly $fault: "client";
+  originalStatusCode?: number;
+  originalMessage?: string;
+  constructor(
+    opts: __ExceptionOptionType<ModelStreamErrorException, __BaseException>
+  );
+}
+export type ConverseStreamOutput =
+  | ConverseStreamOutput.ContentBlockDeltaMember
+  | ConverseStreamOutput.ContentBlockStartMember
+  | ConverseStreamOutput.ContentBlockStopMember
+  | ConverseStreamOutput.InternalServerExceptionMember
+  | ConverseStreamOutput.MessageStartMember
+  | ConverseStreamOutput.MessageStopMember
+  | ConverseStreamOutput.MetadataMember
+  | ConverseStreamOutput.ModelStreamErrorExceptionMember
+  | ConverseStreamOutput.ServiceUnavailableExceptionMember
+  | ConverseStreamOutput.ThrottlingExceptionMember
+  | ConverseStreamOutput.ValidationExceptionMember
+  | ConverseStreamOutput.$UnknownMember;
+export declare namespace ConverseStreamOutput {
+  interface MessageStartMember {
+    messageStart: MessageStartEvent;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ContentBlockStartMember {
+    messageStart?: never;
+    contentBlockStart: ContentBlockStartEvent;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ContentBlockDeltaMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta: ContentBlockDeltaEvent;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ContentBlockStopMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop: ContentBlockStopEvent;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface MessageStopMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop: MessageStopEvent;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface MetadataMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata: ConverseStreamMetadataEvent;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface InternalServerExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException: InternalServerException;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ModelStreamErrorExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException: ModelStreamErrorException;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ValidationExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException: ValidationException;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ThrottlingExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException: ThrottlingException;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ServiceUnavailableExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException: ServiceUnavailableException;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    serviceUnavailableException?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    messageStart: (value: MessageStartEvent) => T;
+    contentBlockStart: (value: ContentBlockStartEvent) => T;
+    contentBlockDelta: (value: ContentBlockDeltaEvent) => T;
+    contentBlockStop: (value: ContentBlockStopEvent) => T;
+    messageStop: (value: MessageStopEvent) => T;
+    metadata: (value: ConverseStreamMetadataEvent) => T;
+    internalServerException: (value: InternalServerException) => T;
+    modelStreamErrorException: (value: ModelStreamErrorException) => T;
+    validationException: (value: ValidationException) => T;
+    throttlingException: (value: ThrottlingException) => T;
+    serviceUnavailableException: (value: ServiceUnavailableException) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ConverseStreamOutput, visitor: Visitor<T>) => T;
+}
+export interface ConverseStreamResponse {
+  stream?: AsyncIterable<ConverseStreamOutput>;
+}
+export declare const Trace: {
+  readonly DISABLED: "DISABLED";
+  readonly ENABLED: "ENABLED";
+};
+export type Trace = (typeof Trace)[keyof typeof Trace];
+export interface InvokeModelRequest {
+  body: Uint8Array | undefined;
+  contentType?: string;
+  accept?: string;
+  modelId: string | undefined;
+  trace?: Trace;
+  guardrailIdentifier?: string;
+  guardrailVersion?: string;
+}
+export interface InvokeModelResponse {
+  body: Uint8Array | undefined;
+  contentType: string | undefined;
+}
+export interface InvokeModelWithResponseStreamRequest {
+  body: Uint8Array | undefined;
+  contentType?: string;
+  accept?: string;
+  modelId: string | undefined;
+  trace?: Trace;
+  guardrailIdentifier?: string;
+  guardrailVersion?: string;
+}
+export interface PayloadPart {
+  bytes?: Uint8Array;
+}
+export type ResponseStream =
+  | ResponseStream.ChunkMember
+  | ResponseStream.InternalServerExceptionMember
+  | ResponseStream.ModelStreamErrorExceptionMember
+  | ResponseStream.ModelTimeoutExceptionMember
+  | ResponseStream.ServiceUnavailableExceptionMember
+  | ResponseStream.ThrottlingExceptionMember
+  | ResponseStream.ValidationExceptionMember
+  | ResponseStream.$UnknownMember;
+export declare namespace ResponseStream {
+  interface ChunkMember {
+    chunk: PayloadPart;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    modelTimeoutException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface InternalServerExceptionMember {
+    chunk?: never;
+    internalServerException: InternalServerException;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    modelTimeoutException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ModelStreamErrorExceptionMember {
+    chunk?: never;
+    internalServerException?: never;
+    modelStreamErrorException: ModelStreamErrorException;
+    validationException?: never;
+    throttlingException?: never;
+    modelTimeoutException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ValidationExceptionMember {
+    chunk?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException: ValidationException;
+    throttlingException?: never;
+    modelTimeoutException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ThrottlingExceptionMember {
+    chunk?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException: ThrottlingException;
+    modelTimeoutException?: never;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ModelTimeoutExceptionMember {
+    chunk?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    modelTimeoutException: ModelTimeoutException;
+    serviceUnavailableException?: never;
+    $unknown?: never;
+  }
+  interface ServiceUnavailableExceptionMember {
+    chunk?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    modelTimeoutException?: never;
+    serviceUnavailableException: ServiceUnavailableException;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    chunk?: never;
+    internalServerException?: never;
+    modelStreamErrorException?: never;
+    validationException?: never;
+    throttlingException?: never;
+    modelTimeoutException?: never;
+    serviceUnavailableException?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    chunk: (value: PayloadPart) => T;
+    internalServerException: (value: InternalServerException) => T;
+    modelStreamErrorException: (value: ModelStreamErrorException) => T;
+    validationException: (value: ValidationException) => T;
+    throttlingException: (value: ThrottlingException) => T;
+    modelTimeoutException: (value: ModelTimeoutException) => T;
+    serviceUnavailableException: (value: ServiceUnavailableException) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ResponseStream, visitor: Visitor<T>) => T;
+}
+export interface InvokeModelWithResponseStreamResponse {
+  body: AsyncIterable<ResponseStream> | undefined;
+  contentType: string | undefined;
+}
+export declare const ConverseStreamOutputFilterSensitiveLog: (
+  obj: ConverseStreamOutput
+) => any;
+export declare const ConverseStreamResponseFilterSensitiveLog: (
+  obj: ConverseStreamResponse
+) => any;
+export declare const InvokeModelRequestFilterSensitiveLog: (
+  obj: InvokeModelRequest
+) => any;
+export declare const InvokeModelResponseFilterSensitiveLog: (
+  obj: InvokeModelResponse
+) => any;
+export declare const InvokeModelWithResponseStreamRequestFilterSensitiveLog: (
+  obj: InvokeModelWithResponseStreamRequest
+) => any;
+export declare const PayloadPartFilterSensitiveLog: (obj: PayloadPart) => any;
+export declare const ResponseStreamFilterSensitiveLog: (
+  obj: ResponseStream
+) => any;
+export declare const InvokeModelWithResponseStreamResponseFilterSensitiveLog: (
+  obj: InvokeModelWithResponseStreamResponse
+) => any;