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

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

@@ -8,6 +8,176 @@ export declare class AccessDeniedException extends __BaseException {
     opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
   );
 }
+export interface GetAsyncInvokeRequest {
+  invocationArn: string | undefined;
+}
+export interface AsyncInvokeS3OutputDataConfig {
+  s3Uri: string | undefined;
+  kmsKeyId?: string | undefined;
+  bucketOwner?: string | undefined;
+}
+export type AsyncInvokeOutputDataConfig =
+  | AsyncInvokeOutputDataConfig.S3OutputDataConfigMember
+  | AsyncInvokeOutputDataConfig.$UnknownMember;
+export declare namespace AsyncInvokeOutputDataConfig {
+  interface S3OutputDataConfigMember {
+    s3OutputDataConfig: AsyncInvokeS3OutputDataConfig;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    s3OutputDataConfig?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    s3OutputDataConfig: (value: AsyncInvokeS3OutputDataConfig) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(
+    value: AsyncInvokeOutputDataConfig,
+    visitor: Visitor<T>
+  ) => T;
+}
+export declare const AsyncInvokeStatus: {
+  readonly COMPLETED: "Completed";
+  readonly FAILED: "Failed";
+  readonly IN_PROGRESS: "InProgress";
+};
+export type AsyncInvokeStatus =
+  (typeof AsyncInvokeStatus)[keyof typeof AsyncInvokeStatus];
+export interface GetAsyncInvokeResponse {
+  invocationArn: string | undefined;
+  modelArn: string | undefined;
+  clientRequestToken?: string | undefined;
+  status: AsyncInvokeStatus | undefined;
+  failureMessage?: string | undefined;
+  submitTime: Date | undefined;
+  lastModifiedTime?: Date | undefined;
+  endTime?: Date | undefined;
+  outputDataConfig: AsyncInvokeOutputDataConfig | undefined;
+}
+export declare class InternalServerException extends __BaseException {
+  readonly name: "InternalServerException";
+  readonly $fault: "server";
+  constructor(
+    opts: __ExceptionOptionType<InternalServerException, __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 SortAsyncInvocationBy: {
+  readonly SUBMISSION_TIME: "SubmissionTime";
+};
+export type SortAsyncInvocationBy =
+  (typeof SortAsyncInvocationBy)[keyof typeof SortAsyncInvocationBy];
+export declare const SortOrder: {
+  readonly ASCENDING: "Ascending";
+  readonly DESCENDING: "Descending";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+export interface ListAsyncInvokesRequest {
+  submitTimeAfter?: Date | undefined;
+  submitTimeBefore?: Date | undefined;
+  statusEquals?: AsyncInvokeStatus | undefined;
+  maxResults?: number | undefined;
+  nextToken?: string | undefined;
+  sortBy?: SortAsyncInvocationBy | undefined;
+  sortOrder?: SortOrder | undefined;
+}
+export interface AsyncInvokeSummary {
+  invocationArn: string | undefined;
+  modelArn: string | undefined;
+  clientRequestToken?: string | undefined;
+  status?: AsyncInvokeStatus | undefined;
+  failureMessage?: string | undefined;
+  submitTime: Date | undefined;
+  lastModifiedTime?: Date | undefined;
+  endTime?: Date | undefined;
+  outputDataConfig: AsyncInvokeOutputDataConfig | undefined;
+}
+export interface ListAsyncInvokesResponse {
+  nextToken?: string | undefined;
+  asyncInvokeSummaries?: AsyncInvokeSummary[] | undefined;
+}
+export declare class ConflictException extends __BaseException {
+  readonly name: "ConflictException";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<ConflictException, __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 ServiceUnavailableException extends __BaseException {
+  readonly name: "ServiceUnavailableException";
+  readonly $fault: "server";
+  constructor(
+    opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>
+  );
+}
+export interface Tag {
+  key: string | undefined;
+  value: string | undefined;
+}
+export interface StartAsyncInvokeRequest {
+  clientRequestToken?: string | undefined;
+  modelId: string | undefined;
+  modelInput: __DocumentType | undefined;
+  outputDataConfig: AsyncInvokeOutputDataConfig | undefined;
+  tags?: Tag[] | undefined;
+}
+export interface StartAsyncInvokeResponse {
+  invocationArn: string | undefined;
+}
+export declare const GuardrailImageFormat: {
+  readonly JPEG: "jpeg";
+  readonly PNG: "png";
+};
+export type GuardrailImageFormat =
+  (typeof GuardrailImageFormat)[keyof typeof GuardrailImageFormat];
+export type GuardrailImageSource =
+  | GuardrailImageSource.BytesMember
+  | GuardrailImageSource.$UnknownMember;
+export declare namespace GuardrailImageSource {
+  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: GuardrailImageSource, visitor: Visitor<T>) => T;
+}
+export interface GuardrailImageBlock {
+  format: GuardrailImageFormat | undefined;
+  source: GuardrailImageSource | undefined;
+}
 export declare const GuardrailContentQualifier: {
   readonly GROUNDING_SOURCE: "grounding_source";
   readonly GUARD_CONTENT: "guard_content";
@@ -20,19 +190,28 @@ export interface GuardrailTextBlock {
   qualifiers?: GuardrailContentQualifier[] | undefined;
 }
 export type GuardrailContentBlock =
+  | GuardrailContentBlock.ImageMember
   | GuardrailContentBlock.TextMember
   | GuardrailContentBlock.$UnknownMember;
 export declare namespace GuardrailContentBlock {
   interface TextMember {
     text: GuardrailTextBlock;
+    image?: never;
+    $unknown?: never;
+  }
+  interface ImageMember {
+    text?: never;
+    image: GuardrailImageBlock;
     $unknown?: never;
   }
   interface $UnknownMember {
     text?: never;
+    image?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     text: (value: GuardrailTextBlock) => T;
+    image: (value: GuardrailImageBlock) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(value: GuardrailContentBlock, visitor: Visitor<T>) => T;
@@ -116,12 +295,17 @@ export interface GuardrailContextualGroundingFilter {
 export interface GuardrailContextualGroundingPolicyAssessment {
   filters?: GuardrailContextualGroundingFilter[] | undefined;
 }
+export interface GuardrailImageCoverage {
+  guarded?: number | undefined;
+  total?: number | undefined;
+}
 export interface GuardrailTextCharactersCoverage {
   guarded?: number | undefined;
   total?: number | undefined;
 }
 export interface GuardrailCoverage {
   textCharacters?: GuardrailTextCharactersCoverage | undefined;
+  images?: GuardrailImageCoverage | undefined;
 }
 export interface GuardrailUsage {
   topicPolicyUnits: number | undefined;
@@ -130,6 +314,7 @@ export interface GuardrailUsage {
   sensitiveInformationPolicyUnits: number | undefined;
   sensitiveInformationPolicyFreeUnits: number | undefined;
   contextualGroundingPolicyUnits: number | undefined;
+  contentPolicyImageUnits?: number | undefined;
 }
 export interface GuardrailInvocationMetrics {
   guardrailProcessingLatency?: number | undefined;
@@ -255,41 +440,6 @@ export interface ApplyGuardrailResponse {
   assessments: GuardrailAssessment[] | undefined;
   guardrailCoverage?: GuardrailCoverage | 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";
@@ -307,6 +457,14 @@ export interface InferenceConfiguration {
   topP?: number | undefined;
   stopSequences?: string[] | undefined;
 }
+export declare const CachePointType: {
+  readonly DEFAULT: "default";
+};
+export type CachePointType =
+  (typeof CachePointType)[keyof typeof CachePointType];
+export interface CachePointBlock {
+  type: CachePointType | undefined;
+}
 export declare const DocumentFormat: {
   readonly CSV: "csv";
   readonly DOC: "doc";
@@ -343,6 +501,37 @@ export interface DocumentBlock {
   name: string | undefined;
   source: DocumentSource | undefined;
 }
+export declare const GuardrailConverseImageFormat: {
+  readonly JPEG: "jpeg";
+  readonly PNG: "png";
+};
+export type GuardrailConverseImageFormat =
+  (typeof GuardrailConverseImageFormat)[keyof typeof GuardrailConverseImageFormat];
+export type GuardrailConverseImageSource =
+  | GuardrailConverseImageSource.BytesMember
+  | GuardrailConverseImageSource.$UnknownMember;
+export declare namespace GuardrailConverseImageSource {
+  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: GuardrailConverseImageSource,
+    visitor: Visitor<T>
+  ) => T;
+}
+export interface GuardrailConverseImageBlock {
+  format: GuardrailConverseImageFormat | undefined;
+  source: GuardrailConverseImageSource | undefined;
+}
 export declare const GuardrailConverseContentQualifier: {
   readonly GROUNDING_SOURCE: "grounding_source";
   readonly GUARD_CONTENT: "guard_content";
@@ -355,19 +544,28 @@ export interface GuardrailConverseTextBlock {
   qualifiers?: GuardrailConverseContentQualifier[] | undefined;
 }
 export type GuardrailConverseContentBlock =
+  | GuardrailConverseContentBlock.ImageMember
   | GuardrailConverseContentBlock.TextMember
   | GuardrailConverseContentBlock.$UnknownMember;
 export declare namespace GuardrailConverseContentBlock {
   interface TextMember {
     text: GuardrailConverseTextBlock;
+    image?: never;
+    $unknown?: never;
+  }
+  interface ImageMember {
+    text?: never;
+    image: GuardrailConverseImageBlock;
     $unknown?: never;
   }
   interface $UnknownMember {
     text?: never;
+    image?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     text: (value: GuardrailConverseTextBlock) => T;
+    image: (value: GuardrailConverseImageBlock) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(
@@ -402,11 +600,90 @@ export interface ImageBlock {
   format: ImageFormat | undefined;
   source: ImageSource | undefined;
 }
+export interface ReasoningTextBlock {
+  text: string | undefined;
+  signature?: string | undefined;
+}
+export type ReasoningContentBlock =
+  | ReasoningContentBlock.ReasoningTextMember
+  | ReasoningContentBlock.RedactedContentMember
+  | ReasoningContentBlock.$UnknownMember;
+export declare namespace ReasoningContentBlock {
+  interface ReasoningTextMember {
+    reasoningText: ReasoningTextBlock;
+    redactedContent?: never;
+    $unknown?: never;
+  }
+  interface RedactedContentMember {
+    reasoningText?: never;
+    redactedContent: Uint8Array;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    reasoningText?: never;
+    redactedContent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    reasoningText: (value: ReasoningTextBlock) => T;
+    redactedContent: (value: Uint8Array) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ReasoningContentBlock, visitor: Visitor<T>) => T;
+}
+export declare const VideoFormat: {
+  readonly FLV: "flv";
+  readonly MKV: "mkv";
+  readonly MOV: "mov";
+  readonly MP4: "mp4";
+  readonly MPEG: "mpeg";
+  readonly MPG: "mpg";
+  readonly THREE_GP: "three_gp";
+  readonly WEBM: "webm";
+  readonly WMV: "wmv";
+};
+export type VideoFormat = (typeof VideoFormat)[keyof typeof VideoFormat];
+export interface S3Location {
+  uri: string | undefined;
+  bucketOwner?: string | undefined;
+}
+export type VideoSource =
+  | VideoSource.BytesMember
+  | VideoSource.S3LocationMember
+  | VideoSource.$UnknownMember;
+export declare namespace VideoSource {
+  interface BytesMember {
+    bytes: Uint8Array;
+    s3Location?: never;
+    $unknown?: never;
+  }
+  interface S3LocationMember {
+    bytes?: never;
+    s3Location: S3Location;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    bytes?: never;
+    s3Location?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    bytes: (value: Uint8Array) => T;
+    s3Location: (value: S3Location) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: VideoSource, visitor: Visitor<T>) => T;
+}
+export interface VideoBlock {
+  format: VideoFormat | undefined;
+  source: VideoSource | undefined;
+}
 export type ToolResultContentBlock =
   | ToolResultContentBlock.DocumentMember
   | ToolResultContentBlock.ImageMember
   | ToolResultContentBlock.JsonMember
   | ToolResultContentBlock.TextMember
+  | ToolResultContentBlock.VideoMember
   | ToolResultContentBlock.$UnknownMember;
 export declare namespace ToolResultContentBlock {
   interface JsonMember {
@@ -414,6 +691,7 @@ export declare namespace ToolResultContentBlock {
     text?: never;
     image?: never;
     document?: never;
+    video?: never;
     $unknown?: never;
   }
   interface TextMember {
@@ -421,6 +699,7 @@ export declare namespace ToolResultContentBlock {
     text: string;
     image?: never;
     document?: never;
+    video?: never;
     $unknown?: never;
   }
   interface ImageMember {
@@ -428,6 +707,7 @@ export declare namespace ToolResultContentBlock {
     text?: never;
     image: ImageBlock;
     document?: never;
+    video?: never;
     $unknown?: never;
   }
   interface DocumentMember {
@@ -435,6 +715,15 @@ export declare namespace ToolResultContentBlock {
     text?: never;
     image?: never;
     document: DocumentBlock;
+    video?: never;
+    $unknown?: never;
+  }
+  interface VideoMember {
+    json?: never;
+    text?: never;
+    image?: never;
+    document?: never;
+    video: VideoBlock;
     $unknown?: never;
   }
   interface $UnknownMember {
@@ -442,6 +731,7 @@ export declare namespace ToolResultContentBlock {
     text?: never;
     image?: never;
     document?: never;
+    video?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
@@ -449,6 +739,7 @@ export declare namespace ToolResultContentBlock {
     text: (value: string) => T;
     image: (value: ImageBlock) => T;
     document: (value: DocumentBlock) => T;
+    video: (value: VideoBlock) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(value: ToolResultContentBlock, visitor: Visitor<T>) => T;
@@ -470,84 +761,147 @@ export interface ToolUseBlock {
   input: __DocumentType | undefined;
 }
 export type ContentBlock =
+  | ContentBlock.CachePointMember
   | ContentBlock.DocumentMember
   | ContentBlock.GuardContentMember
   | ContentBlock.ImageMember
+  | ContentBlock.ReasoningContentMember
   | ContentBlock.TextMember
   | ContentBlock.ToolResultMember
   | ContentBlock.ToolUseMember
+  | ContentBlock.VideoMember
   | ContentBlock.$UnknownMember;
 export declare namespace ContentBlock {
   interface TextMember {
     text: string;
     image?: never;
     document?: never;
+    video?: never;
     toolUse?: never;
     toolResult?: never;
     guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
     $unknown?: never;
   }
   interface ImageMember {
     text?: never;
     image: ImageBlock;
     document?: never;
+    video?: never;
     toolUse?: never;
     toolResult?: never;
     guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
     $unknown?: never;
   }
   interface DocumentMember {
     text?: never;
     image?: never;
     document: DocumentBlock;
+    video?: never;
     toolUse?: never;
     toolResult?: never;
     guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface VideoMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    video: VideoBlock;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
     $unknown?: never;
   }
   interface ToolUseMember {
     text?: never;
     image?: never;
     document?: never;
+    video?: never;
     toolUse: ToolUseBlock;
     toolResult?: never;
     guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
     $unknown?: never;
   }
   interface ToolResultMember {
     text?: never;
     image?: never;
     document?: never;
+    video?: never;
     toolUse?: never;
     toolResult: ToolResultBlock;
     guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
     $unknown?: never;
   }
   interface GuardContentMember {
     text?: never;
     image?: never;
     document?: never;
+    video?: never;
     toolUse?: never;
     toolResult?: never;
     guardContent: GuardrailConverseContentBlock;
+    cachePoint?: never;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface CachePointMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    video?: never;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    cachePoint: CachePointBlock;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ReasoningContentMember {
+    text?: never;
+    image?: never;
+    document?: never;
+    video?: never;
+    toolUse?: never;
+    toolResult?: never;
+    guardContent?: never;
+    cachePoint?: never;
+    reasoningContent: ReasoningContentBlock;
     $unknown?: never;
   }
   interface $UnknownMember {
     text?: never;
     image?: never;
     document?: never;
+    video?: never;
     toolUse?: never;
     toolResult?: never;
     guardContent?: never;
+    cachePoint?: never;
+    reasoningContent?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     text: (value: string) => T;
     image: (value: ImageBlock) => T;
     document: (value: DocumentBlock) => T;
+    video: (value: VideoBlock) => T;
     toolUse: (value: ToolUseBlock) => T;
     toolResult: (value: ToolResultBlock) => T;
     guardContent: (value: GuardrailConverseContentBlock) => T;
+    cachePoint: (value: CachePointBlock) => T;
+    reasoningContent: (value: ReasoningContentBlock) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(value: ContentBlock, visitor: Visitor<T>) => T;
@@ -562,6 +916,15 @@ export interface Message {
   role: ConversationRole | undefined;
   content: ContentBlock[] | undefined;
 }
+export declare const PerformanceConfigLatency: {
+  readonly OPTIMIZED: "optimized";
+  readonly STANDARD: "standard";
+};
+export type PerformanceConfigLatency =
+  (typeof PerformanceConfigLatency)[keyof typeof PerformanceConfigLatency];
+export interface PerformanceConfiguration {
+  latency?: PerformanceConfigLatency | undefined;
+}
 export type PromptVariableValues =
   | PromptVariableValues.TextMember
   | PromptVariableValues.$UnknownMember;
@@ -581,6 +944,7 @@ export declare namespace PromptVariableValues {
   const visit: <T>(value: PromptVariableValues, visitor: Visitor<T>) => T;
 }
 export type SystemContentBlock =
+  | SystemContentBlock.CachePointMember
   | SystemContentBlock.GuardContentMember
   | SystemContentBlock.TextMember
   | SystemContentBlock.$UnknownMember;
@@ -588,21 +952,31 @@ export declare namespace SystemContentBlock {
   interface TextMember {
     text: string;
     guardContent?: never;
+    cachePoint?: never;
     $unknown?: never;
   }
   interface GuardContentMember {
     text?: never;
     guardContent: GuardrailConverseContentBlock;
+    cachePoint?: never;
+    $unknown?: never;
+  }
+  interface CachePointMember {
+    text?: never;
+    guardContent?: never;
+    cachePoint: CachePointBlock;
     $unknown?: never;
   }
   interface $UnknownMember {
     text?: never;
     guardContent?: never;
+    cachePoint?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     text: (value: string) => T;
     guardContent: (value: GuardrailConverseContentBlock) => T;
+    cachePoint: (value: CachePointBlock) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(value: SystemContentBlock, visitor: Visitor<T>) => T;
@@ -673,18 +1047,29 @@ export interface ToolSpecification {
   description?: string | undefined;
   inputSchema: ToolInputSchema | undefined;
 }
-export type Tool = Tool.ToolSpecMember | Tool.$UnknownMember;
+export type Tool =
+  | Tool.CachePointMember
+  | Tool.ToolSpecMember
+  | Tool.$UnknownMember;
 export declare namespace Tool {
   interface ToolSpecMember {
     toolSpec: ToolSpecification;
+    cachePoint?: never;
+    $unknown?: never;
+  }
+  interface CachePointMember {
+    toolSpec?: never;
+    cachePoint: CachePointBlock;
     $unknown?: never;
   }
   interface $UnknownMember {
     toolSpec?: never;
+    cachePoint?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     toolSpec: (value: ToolSpecification) => T;
+    cachePoint: (value: CachePointBlock) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(value: Tool, visitor: Visitor<T>) => T;
@@ -703,6 +1088,8 @@ export interface ConverseRequest {
   additionalModelRequestFields?: __DocumentType | undefined;
   promptVariables?: Record<string, PromptVariableValues> | undefined;
   additionalModelResponseFieldPaths?: string[] | undefined;
+  requestMetadata?: Record<string, string> | undefined;
+  performanceConfig?: PerformanceConfiguration | undefined;
 }
 export interface ConverseMetrics {
   latencyMs: number | undefined;
@@ -739,13 +1126,19 @@ export interface GuardrailTraceAssessment {
   inputAssessment?: Record<string, GuardrailAssessment> | undefined;
   outputAssessments?: Record<string, GuardrailAssessment[]> | undefined;
 }
+export interface PromptRouterTrace {
+  invokedModelId?: string | undefined;
+}
 export interface ConverseTrace {
   guardrail?: GuardrailTraceAssessment | undefined;
+  promptRouter?: PromptRouterTrace | undefined;
 }
 export interface TokenUsage {
   inputTokens: number | undefined;
   outputTokens: number | undefined;
   totalTokens: number | undefined;
+  cacheReadInputTokens?: number | undefined;
+  cacheWriteInputTokens?: number | undefined;
 }
 export interface ConverseResponse {
   output: ConverseOutput | undefined;
@@ -754,6 +1147,7 @@ export interface ConverseResponse {
   metrics: ConverseMetrics | undefined;
   additionalModelResponseFields?: __DocumentType | undefined;
   trace?: ConverseTrace | undefined;
+  performanceConfig?: PerformanceConfiguration | undefined;
 }
 export declare class ModelErrorException extends __BaseException {
   readonly name: "ModelErrorException";
@@ -779,13 +1173,6 @@ export declare class ModelTimeoutException extends __BaseException {
     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";
@@ -808,11 +1195,52 @@ export interface ConverseStreamRequest {
   additionalModelRequestFields?: __DocumentType | undefined;
   promptVariables?: Record<string, PromptVariableValues> | undefined;
   additionalModelResponseFieldPaths?: string[] | undefined;
+  requestMetadata?: Record<string, string> | undefined;
+  performanceConfig?: PerformanceConfiguration | undefined;
+}
+export type ReasoningContentBlockDelta =
+  | ReasoningContentBlockDelta.RedactedContentMember
+  | ReasoningContentBlockDelta.SignatureMember
+  | ReasoningContentBlockDelta.TextMember
+  | ReasoningContentBlockDelta.$UnknownMember;
+export declare namespace ReasoningContentBlockDelta {
+  interface TextMember {
+    text: string;
+    redactedContent?: never;
+    signature?: never;
+    $unknown?: never;
+  }
+  interface RedactedContentMember {
+    text?: never;
+    redactedContent: Uint8Array;
+    signature?: never;
+    $unknown?: never;
+  }
+  interface SignatureMember {
+    text?: never;
+    redactedContent?: never;
+    signature: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    redactedContent?: never;
+    signature?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    redactedContent: (value: Uint8Array) => T;
+    signature: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ReasoningContentBlockDelta, visitor: Visitor<T>) => T;
 }
 export interface ToolUseBlockDelta {
   input: string | undefined;
 }
 export type ContentBlockDelta =
+  | ContentBlockDelta.ReasoningContentMember
   | ContentBlockDelta.TextMember
   | ContentBlockDelta.ToolUseMember
   | ContentBlockDelta.$UnknownMember;
@@ -820,21 +1248,31 @@ export declare namespace ContentBlockDelta {
   interface TextMember {
     text: string;
     toolUse?: never;
+    reasoningContent?: never;
     $unknown?: never;
   }
   interface ToolUseMember {
     text?: never;
     toolUse: ToolUseBlockDelta;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ReasoningContentMember {
+    text?: never;
+    toolUse?: never;
+    reasoningContent: ReasoningContentBlockDelta;
     $unknown?: never;
   }
   interface $UnknownMember {
     text?: never;
     toolUse?: never;
+    reasoningContent?: never;
     $unknown: [string, any];
   }
   interface Visitor<T> {
     text: (value: string) => T;
     toolUse: (value: ToolUseBlockDelta) => T;
+    reasoningContent: (value: ReasoningContentBlockDelta) => T;
     _: (name: string, value: any) => T;
   }
   const visit: <T>(value: ContentBlockDelta, visitor: Visitor<T>) => T;
@@ -884,11 +1322,13 @@ export interface ConverseStreamMetrics {
 }
 export interface ConverseStreamTrace {
   guardrail?: GuardrailTraceAssessment | undefined;
+  promptRouter?: PromptRouterTrace | undefined;
 }
 export interface ConverseStreamMetadataEvent {
   usage: TokenUsage | undefined;
   metrics: ConverseStreamMetrics | undefined;
   trace?: ConverseStreamTrace | undefined;
+  performanceConfig?: PerformanceConfiguration | undefined;
 }
 export declare class ModelStreamErrorException extends __BaseException {
   readonly name: "ModelStreamErrorException";
@@ -1113,10 +1553,12 @@ export interface InvokeModelRequest {
   trace?: Trace | undefined;
   guardrailIdentifier?: string | undefined;
   guardrailVersion?: string | undefined;
+  performanceConfigLatency?: PerformanceConfigLatency | undefined;
 }
 export interface InvokeModelResponse {
   body: Uint8Array | undefined;
   contentType: string | undefined;
+  performanceConfigLatency?: PerformanceConfigLatency | undefined;
 }
 export interface InvokeModelWithResponseStreamRequest {
   body?: Uint8Array | undefined;
@@ -1126,6 +1568,7 @@ export interface InvokeModelWithResponseStreamRequest {
   trace?: Trace | undefined;
   guardrailIdentifier?: string | undefined;
   guardrailVersion?: string | undefined;
+  performanceConfigLatency?: PerformanceConfigLatency | undefined;
 }
 export interface PayloadPart {
   bytes?: Uint8Array | undefined;
@@ -1235,13 +1678,73 @@ export declare namespace ResponseStream {
 export interface InvokeModelWithResponseStreamResponse {
   body: AsyncIterable<ResponseStream> | undefined;
   contentType: string | undefined;
+  performanceConfigLatency?: PerformanceConfigLatency | undefined;
 }
+export declare const GetAsyncInvokeResponseFilterSensitiveLog: (
+  obj: GetAsyncInvokeResponse
+) => any;
+export declare const AsyncInvokeSummaryFilterSensitiveLog: (
+  obj: AsyncInvokeSummary
+) => any;
+export declare const ListAsyncInvokesResponseFilterSensitiveLog: (
+  obj: ListAsyncInvokesResponse
+) => any;
+export declare const StartAsyncInvokeRequestFilterSensitiveLog: (
+  obj: StartAsyncInvokeRequest
+) => any;
+export declare const GuardrailImageSourceFilterSensitiveLog: (
+  obj: GuardrailImageSource
+) => any;
+export declare const GuardrailImageBlockFilterSensitiveLog: (
+  obj: GuardrailImageBlock
+) => any;
+export declare const GuardrailContentBlockFilterSensitiveLog: (
+  obj: GuardrailContentBlock
+) => any;
+export declare const ApplyGuardrailRequestFilterSensitiveLog: (
+  obj: ApplyGuardrailRequest
+) => any;
+export declare const GuardrailConverseImageSourceFilterSensitiveLog: (
+  obj: GuardrailConverseImageSource
+) => any;
+export declare const GuardrailConverseImageBlockFilterSensitiveLog: (
+  obj: GuardrailConverseImageBlock
+) => any;
+export declare const GuardrailConverseContentBlockFilterSensitiveLog: (
+  obj: GuardrailConverseContentBlock
+) => any;
+export declare const ReasoningTextBlockFilterSensitiveLog: (
+  obj: ReasoningTextBlock
+) => any;
+export declare const ReasoningContentBlockFilterSensitiveLog: (
+  obj: ReasoningContentBlock
+) => any;
+export declare const ContentBlockFilterSensitiveLog: (obj: ContentBlock) => any;
+export declare const MessageFilterSensitiveLog: (obj: Message) => any;
+export declare const SystemContentBlockFilterSensitiveLog: (
+  obj: SystemContentBlock
+) => any;
 export declare const ConverseRequestFilterSensitiveLog: (
   obj: ConverseRequest
 ) => any;
+export declare const ConverseOutputFilterSensitiveLog: (
+  obj: ConverseOutput
+) => any;
+export declare const ConverseResponseFilterSensitiveLog: (
+  obj: ConverseResponse
+) => any;
 export declare const ConverseStreamRequestFilterSensitiveLog: (
   obj: ConverseStreamRequest
 ) => any;
+export declare const ReasoningContentBlockDeltaFilterSensitiveLog: (
+  obj: ReasoningContentBlockDelta
+) => any;
+export declare const ContentBlockDeltaFilterSensitiveLog: (
+  obj: ContentBlockDelta
+) => any;
+export declare const ContentBlockDeltaEventFilterSensitiveLog: (
+  obj: ContentBlockDeltaEvent
+) => any;
 export declare const ConverseStreamOutputFilterSensitiveLog: (
   obj: ConverseStreamOutput
 ) => any;