AmazonBedrockSchema

type ConverseResponseStreamEvent = typeof ConverseResponseStreamEvent.Type

declare class BedrockFoundationModelId extends {} {
  constructor(_: never);
}

declare class CachePointBlock extends {
  readonly type: "default";
} {
  constructor(...args: [props: {
    readonly type: "default";
  }, options?: MakeOptions]);
}

declare class ContentBlock extends {} {
  constructor(_: never);
}

declare class ContentBlockDelta extends {} {
  constructor(_: never);
}

declare class ContentBlockDeltaEvent extends {
  readonly contentBlockIndex: unknown;
  readonly delta: never;
} {
  constructor(...args: [props: {
    readonly contentBlockIndex: unknown;
    readonly delta: never;
  }, options?: MakeOptions]);
}

declare class ContentBlockStart extends {
  readonly toolUse?: ToolUseBlockStart;
} {
  constructor(...args: [props?: {
    readonly toolUse?: ToolUseBlockStart;
  }, options?: MakeOptions]);
}

declare class ContentBlockStartEvent extends {
  readonly contentBlockIndex: unknown;
  readonly start: ContentBlockStart;
} {
  constructor(...args: [props: {
    readonly contentBlockIndex: unknown;
    readonly start: ContentBlockStart;
  }, options?: MakeOptions]);
}

declare class ContentBlockStopEvent extends {
  readonly contentBlockIndex: unknown;
} {
  constructor(...args: [props: {
    readonly contentBlockIndex: unknown;
  }, options?: MakeOptions]);
}

declare class ConverseMetrics extends {
  readonly latencyMs: Duration;
} {
  constructor(...args: [props: {
    readonly latencyMs: Duration;
  }, options?: MakeOptions]);
}

declare class ConverseOutput extends {
  readonly message: Message;
} {
  constructor(...args: [props: {
    readonly message: Message;
  }, options?: MakeOptions]);
}

declare class ConverseRequest extends {
  readonly additionalModelRequestFields?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly additionalModelResponseFieldPaths?: undefined;
  readonly guardrailConfig?: GuardrailConfiguration;
  readonly inferenceConfig?: InferenceConfiguration;
  readonly messages: readonly Array<Message>;
  readonly modelId: string;
  readonly performanceConfig?: PerformanceConfiguration;
  readonly promptVariables?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly requestMetadata?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly system?: readonly Array<unknown>;
  readonly toolConfig?: ToolConfiguration;
} {
  constructor(...args: [props: {
    readonly additionalModelRequestFields?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly additionalModelResponseFieldPaths?: undefined;
    readonly guardrailConfig?: GuardrailConfiguration;
    readonly inferenceConfig?: InferenceConfiguration;
    readonly messages: readonly Array<Message>;
    readonly modelId: string;
    readonly performanceConfig?: PerformanceConfiguration;
    readonly promptVariables?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly requestMetadata?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly system?: readonly Array<unknown>;
    readonly toolConfig?: ToolConfiguration;
  }, options?: MakeOptions]);
}

declare class ConverseResponse extends {
  readonly additionalModelResponseFields?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly metrics: ConverseMetrics;
  readonly output: ConverseOutput;
  readonly performanceConfig?: {
    readonly latency: "standard";
  };
  readonly stopReason: "content_filtered";
  readonly trace?: ConverseTrace;
  readonly usage: TokenUsage;
} {
  constructor(...args: [props: {
    readonly additionalModelResponseFields?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly metrics: ConverseMetrics;
    readonly output: ConverseOutput;
    readonly performanceConfig?: {
      readonly latency: "standard";
    };
    readonly stopReason: "content_filtered";
    readonly trace?: ConverseTrace;
    readonly usage: TokenUsage;
  }, options?: MakeOptions]);
}

declare const ConverseResponseStreamEvent: any

declare class ConverseStreamMetadataEvent extends {
  readonly metrics: ConverseStreamMetrics;
  readonly performanceConfig?: PerformanceConfiguration;
  readonly trace?: ConverseStreamTrace;
  readonly usage: TokenUsage;
} {
  constructor(...args: [props: {
    readonly metrics: ConverseStreamMetrics;
    readonly performanceConfig?: PerformanceConfiguration;
    readonly trace?: ConverseStreamTrace;
    readonly usage: TokenUsage;
  }, options?: MakeOptions]);
}

declare class ConverseStreamMetrics extends {
  readonly latencyMs: Duration;
} {
  constructor(...args: [props: {
    readonly latencyMs: Duration;
  }, options?: MakeOptions]);
}

declare class ConverseStreamTrace extends {
  readonly guardrail?: GuardrailTraceAssessment;
  readonly promptRouter?: PromptRouterTrace;
} {
  constructor(...args: [props?: {
    readonly guardrail?: GuardrailTraceAssessment;
    readonly promptRouter?: PromptRouterTrace;
  }, options?: MakeOptions]);
}

declare class ConverseTrace extends {
  readonly guardrail?: GuardrailTraceAssessment;
  readonly promptRouter?: PromptRouterTrace;
} {
  constructor(...args: [props?: {
    readonly guardrail?: GuardrailTraceAssessment;
    readonly promptRouter?: PromptRouterTrace;
  }, options?: MakeOptions]);
}

declare class DocumentBlock extends {
  readonly format: "csv";
  readonly name: unknown;
  readonly source: {
    readonly bytes: string;
  };
} {
  constructor(...args: [props: {
    readonly format: "csv";
    readonly name: unknown;
    readonly source: {
      readonly bytes: string;
    };
  }, options?: MakeOptions]);
}

declare const DocumentFormat: Literal<"csv">

type DocumentFormat = typeof DocumentFormat.Type

declare class GuardrailAssessment extends {
  readonly contentPolicy?: GuardrailContentPolicyAssessment;
  readonly contextualGroundingPolicy?: GuardrailContextualGroundingPolicyAssessment;
  readonly invocationMetrics?: GuardrailInvocationMetrics;
  readonly sensitiveInformationPolicy?: GuardrailSensitiveInformationPolicyAssessment;
  readonly topicPolicy?: GuardrailTopicPolicyAssessment;
  readonly wordPolicy?: GuardrailWordPolicyAssessment;
} {
  constructor(...args: [props?: {
    readonly contentPolicy?: GuardrailContentPolicyAssessment;
    readonly contextualGroundingPolicy?: GuardrailContextualGroundingPolicyAssessment;
    readonly invocationMetrics?: GuardrailInvocationMetrics;
    readonly sensitiveInformationPolicy?: GuardrailSensitiveInformationPolicyAssessment;
    readonly topicPolicy?: GuardrailTopicPolicyAssessment;
    readonly wordPolicy?: GuardrailWordPolicyAssessment;
  }, options?: MakeOptions]);
}

declare class GuardrailConfiguration extends {
  readonly guardrailIdentifier: unknown;
  readonly guardrailVersion: unknown;
  readonly trace?: "enabled";
} {
  constructor(...args: [props: {
    readonly guardrailIdentifier: unknown;
    readonly guardrailVersion: unknown;
    readonly trace?: "enabled";
  }, options?: MakeOptions]);
}

declare class GuardrailContentFilter extends {
  readonly action: "BLOCKED";
  readonly confidence: "NONE";
  readonly detected?: boolean;
  readonly filterStrength?: "NONE";
  readonly type: "HATE";
} {
  constructor(...args: [props: {
    readonly action: "BLOCKED";
    readonly confidence: "NONE";
    readonly detected?: boolean;
    readonly filterStrength?: "NONE";
    readonly type: "HATE";
  }, options?: MakeOptions]);
}

declare class GuardrailContentPolicyAssessment extends {
  readonly filters: readonly Array<GuardrailContentFilter>;
} {
  constructor(...args: [props: {
    readonly filters: readonly Array<GuardrailContentFilter>;
  }, options?: MakeOptions]);
}

declare class GuardrailContextualGroundingFilter extends {
  readonly action: "BLOCKED";
  readonly detected?: boolean;
  readonly score: unknown;
  readonly threshold: unknown;
  readonly type: "GROUNDING";
} {
  constructor(...args: [props: {
    readonly action: "BLOCKED";
    readonly detected?: boolean;
    readonly score: unknown;
    readonly threshold: unknown;
    readonly type: "GROUNDING";
  }, options?: MakeOptions]);
}

declare class GuardrailContextualGroundingPolicyAssessment extends {
  readonly filters?: readonly Array<GuardrailContextualGroundingFilter>;
} {
  constructor(...args: [props?: {
    readonly filters?: readonly Array<GuardrailContextualGroundingFilter>;
  }, options?: MakeOptions]);
}

declare class GuardrailConverseContentBlock extends {} {
  constructor(_: never);
}

declare class GuardrailConverseImageBlock extends {
  readonly format: "png";
  readonly source: {
    readonly bytes: string;
  };
} {
  constructor(...args: [props: {
    readonly format: "png";
    readonly source: {
      readonly bytes: string;
    };
  }, options?: MakeOptions]);
}

declare class GuardrailConverseTextBlock extends {
  readonly qualifiers?: readonly Array<"guard_content">;
  readonly text: string;
} {
  constructor(...args: [props: {
    readonly qualifiers?: readonly Array<"guard_content">;
    readonly text: string;
  }, options?: MakeOptions]);
}

declare class GuardrailCoverage extends {
  readonly images?: GuardrailImageCoverage;
  readonly textCharacters?: GuardrailTextCharactersCoverage;
} {
  constructor(...args: [props?: {
    readonly images?: GuardrailImageCoverage;
    readonly textCharacters?: GuardrailTextCharactersCoverage;
  }, options?: MakeOptions]);
}

declare class GuardrailCustomWord extends {
  readonly action: "BLOCKED";
  readonly detected?: boolean;
  readonly match: string;
} {
  constructor(...args: [props: {
    readonly action: "BLOCKED";
    readonly detected?: boolean;
    readonly match: string;
  }, options?: MakeOptions]);
}

declare class GuardrailImageCoverage extends {
  readonly guarded?: number;
  readonly total?: number;
} {
  constructor(...args: [props?: {
    readonly guarded?: number;
    readonly total?: number;
  }, options?: MakeOptions]);
}

declare class GuardrailInvocationMetrics extends {
  readonly guardrailCoverage?: GuardrailCoverage;
  readonly guardrailProcessingLatency?: number;
  readonly usage?: GuardrailUsage;
} {
  constructor(...args: [props?: {
    readonly guardrailCoverage?: GuardrailCoverage;
    readonly guardrailProcessingLatency?: number;
    readonly usage?: GuardrailUsage;
  }, options?: MakeOptions]);
}

declare class GuardrailManagedWord extends {
  readonly action: "BLOCKED";
  readonly detected?: boolean;
  readonly match: string;
  readonly type: "PROFANITY";
} {
  constructor(...args: [props: {
    readonly action: "BLOCKED";
    readonly detected?: boolean;
    readonly match: string;
    readonly type: "PROFANITY";
  }, options?: MakeOptions]);
}

declare class GuardrailPiiEntityFilter extends {
  readonly action: "ANONYMIZED";
  readonly detected?: boolean;
  readonly match: string;
  readonly type: "ADDRESS";
} {
  constructor(...args: [props: {
    readonly action: "ANONYMIZED";
    readonly detected?: boolean;
    readonly match: string;
    readonly type: "ADDRESS";
  }, options?: MakeOptions]);
}

declare class GuardrailRegexFilter extends {
  readonly action: "ANONYMIZED";
  readonly detected?: boolean;
  readonly match?: string;
  readonly name?: string;
  readonly regex?: string;
} {
  constructor(...args: [props: {
    readonly action: "ANONYMIZED";
    readonly detected?: boolean;
    readonly match?: string;
    readonly name?: string;
    readonly regex?: string;
  }, options?: MakeOptions]);
}

declare class GuardrailSensitiveInformationPolicyAssessment extends {
  readonly piiEntities: readonly Array<GuardrailPiiEntityFilter>;
  readonly regexes: readonly Array<GuardrailRegexFilter>;
} {
  constructor(...args: [props: {
    readonly piiEntities: readonly Array<GuardrailPiiEntityFilter>;
    readonly regexes: readonly Array<GuardrailRegexFilter>;
  }, options?: MakeOptions]);
}

declare class GuardrailTextCharactersCoverage extends {
  readonly guarded?: number;
  readonly total?: number;
} {
  constructor(...args: [props?: {
    readonly guarded?: number;
    readonly total?: number;
  }, options?: MakeOptions]);
}

declare class GuardrailTopic extends {
  readonly action: "BLOCKED";
  readonly detected?: boolean;
  readonly name: string;
  readonly type: "DENY";
} {
  constructor(...args: [props: {
    readonly action: "BLOCKED";
    readonly detected?: boolean;
    readonly name: string;
    readonly type: "DENY";
  }, options?: MakeOptions]);
}

declare class GuardrailTopicPolicyAssessment extends {
  readonly topics: readonly Array<GuardrailTopic>;
} {
  constructor(...args: [props: {
    readonly topics: readonly Array<GuardrailTopic>;
  }, options?: MakeOptions]);
}

declare class GuardrailTraceAssessment extends {
  readonly actionReason?: string;
  readonly inputAssessment?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly modelOutput?: readonly Array<string>;
  readonly outputAssessments?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
} {
  constructor(...args: [props?: {
    readonly actionReason?: string;
    readonly inputAssessment?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly modelOutput?: readonly Array<string>;
    readonly outputAssessments?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
  }, options?: MakeOptions]);
}

declare class GuardrailUsage extends {
  readonly contentPolicyImageUnits?: number;
  readonly contentPolicyUnits: number;
  readonly contextualGroundingPolicyUnits: number;
  readonly sensitiveInformationPolicyFreeUnits: number;
  readonly sensitiveInformationPolicyUnits: number;
  readonly topicPolicyUnits: number;
  readonly wordPolicyUnits: number;
} {
  constructor(...args: [props: {
    readonly contentPolicyImageUnits?: number;
    readonly contentPolicyUnits: number;
    readonly contextualGroundingPolicyUnits: number;
    readonly sensitiveInformationPolicyFreeUnits: number;
    readonly sensitiveInformationPolicyUnits: number;
    readonly topicPolicyUnits: number;
    readonly wordPolicyUnits: number;
  }, options?: MakeOptions]);
}

declare class GuardrailWordPolicyAssessment extends {
  readonly customWords: GuardrailCustomWord;
  readonly managedWordLists: GuardrailManagedWord;
} {
  constructor(...args: [props: {
    readonly customWords: GuardrailCustomWord;
    readonly managedWordLists: GuardrailManagedWord;
  }, options?: MakeOptions]);
}

declare class ImageBlock extends {
  readonly format: "gif";
  readonly source: {
    readonly bytes: string;
  };
} {
  constructor(...args: [props: {
    readonly format: "gif";
    readonly source: {
      readonly bytes: string;
    };
  }, options?: MakeOptions]);
}

declare const ImageFormat: Literal<"gif">

type ImageFormat = typeof ImageFormat.Type

declare class InferenceConfiguration extends {
  readonly maxTokens?: undefined;
  readonly stopSequences?: undefined;
  readonly temperature?: undefined;
  readonly topP?: undefined;
} {
  constructor(...args: [props?: {
    readonly maxTokens?: undefined;
    readonly stopSequences?: undefined;
    readonly temperature?: undefined;
    readonly topP?: undefined;
  }, options?: MakeOptions]);
}

declare const IntZeroOrGreater: never

declare class JsonBlock extends {
  readonly json: unknown;
} {
  constructor(...args: [props: {
    readonly json: unknown;
  }, options?: MakeOptions]);
}

declare class Message extends {
  readonly content: readonly Array<never>;
  readonly role: "user";
} {
  constructor(...args: [props: {
    readonly content: readonly Array<never>;
    readonly role: "user";
  }, options?: MakeOptions]);
}

declare class MessageStartEvent extends {
  readonly role: "user";
} {
  constructor(...args: [props: {
    readonly role: "user";
  }, options?: MakeOptions]);
}

declare class MessageStopEvent extends {
  readonly additionalModelResponseFields?: {
    [key: string]: unknown;
    [key: number]: unknown;
    [key: symbol]: unknown;
  };
  readonly stopReason: "end_turn";
} {
  constructor(...args: [props: {
    readonly additionalModelResponseFields?: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
    readonly stopReason: "end_turn";
  }, options?: MakeOptions]);
}

declare class PerformanceConfiguration extends {
  readonly latency?: "standard";
} {
  constructor(...args: [props?: {
    readonly latency?: "standard";
  }, options?: MakeOptions]);
}

declare class PromptRouterTrace extends {
  readonly invokedModelId?: undefined;
} {
  constructor(...args: [props?: {
    readonly invokedModelId?: undefined;
  }, options?: MakeOptions]);
}

declare class ReasoningContentBlock extends {} {
  constructor(_: never);
}

declare class ReasoningContentBlockDelta extends {} {
  constructor(_: never);
}

declare const StopReason: Literal<"end_turn">

type StopReason = typeof StopReason.Type

declare class SystemContentBlock extends {} {
  constructor(_: never);
}

declare class TokenUsage extends {
  readonly cacheReadInputTokens?: undefined;
  readonly cacheWriteInputTokens?: undefined;
  inputTokens?: undefined;
  outputTokens?: undefined;
  totalTokens?: undefined;
} {
  constructor(...args: [props?: {
    readonly cacheReadInputTokens?: undefined;
    readonly cacheWriteInputTokens?: undefined;
    readonly inputTokens?: undefined;
    readonly outputTokens?: undefined;
    readonly totalTokens?: undefined;
  }, options?: MakeOptions]);
}

declare class Tool extends {
  readonly cachePoint?: CachePointBlock;
  readonly toolSpec?: ToolSpecification;
} {
  constructor(...args: [props?: {
    readonly cachePoint?: CachePointBlock;
    readonly toolSpec?: ToolSpecification;
  }, options?: MakeOptions]);
}

declare class ToolChoice extends {} {
  constructor(_: never);
}

declare class ToolConfiguration extends {
  readonly toolChoice?: unknown;
  readonly tools: unknown;
} {
  constructor(...args: [props: {
    readonly toolChoice?: unknown;
    readonly tools: unknown;
  }, options?: MakeOptions]);
}

declare class ToolResultBlock extends {
  readonly content: readonly Array<unknown>;
  readonly status?: "success";
  readonly toolUseId: unknown;
} {
  constructor(...args: [props: {
    readonly content: readonly Array<unknown>;
    readonly status?: "success";
    readonly toolUseId: unknown;
  }, options?: MakeOptions]);
}

declare class ToolSpecification extends {
  readonly description?: undefined;
  readonly inputSchema: {
    readonly json: {
      [key: string]: unknown;
      [key: number]: unknown;
      [key: symbol]: unknown;
    };
  };
  readonly name: unknown;
} {
  constructor(...args: [props: {
    readonly description?: undefined;
    readonly inputSchema: {
      readonly json: {
        [key: string]: unknown;
        [key: number]: unknown;
        [key: symbol]: unknown;
      };
    };
    readonly name: unknown;
  }, options?: MakeOptions]);
}

declare class ToolUseBlock extends {
  readonly input: unknown;
  readonly name: unknown;
  readonly toolUseId: unknown;
} {
  constructor(...args: [props: {
    readonly input: unknown;
    readonly name: unknown;
    readonly toolUseId: unknown;
  }, options?: MakeOptions]);
}

declare class ToolUseBlockDelta extends {
  readonly input: string;
} {
  constructor(...args: [props: {
    readonly input: string;
  }, options?: MakeOptions]);
}

declare class ToolUseBlockStart extends {
  readonly name: unknown;
  readonly toolUseId: unknown;
} {
  constructor(...args: [props: {
    readonly name: unknown;
    readonly toolUseId: unknown;
  }, options?: MakeOptions]);
}

declare class VideoBlock extends {
  readonly format: "flv";
  readonly source: unknown;
} {
  constructor(...args: [props: {
    readonly format: "flv";
    readonly source: unknown;
  }, options?: MakeOptions]);
}