AmazonBedrockSchema

type ConverseResponseStreamEvent = typeof ConverseResponseStreamEvent.Type;

declare class BedrockFoundationModelId extends any {
  constructor();
}

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

declare class ContentBlock extends any {
  constructor();
}

declare class ContentBlockDelta extends any {
  constructor();
}

declare class ContentBlockDeltaEvent extends ReadonlySide<Fields, "Type"> {
  [key: string]: unknown;
  [key: number]: unknown;
  [key: symbol]: unknown;
  constructor(...args: [props?: ReadonlyMakeIn<Fields>, options?: MakeOptions]);
}

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

declare class ContentBlockStartEvent extends ReadonlySide<
  {
    readonly contentBlockIndex: Constraint;
    readonly start: typeof ContentBlockStart;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly contentBlockIndex: Constraint;
        readonly start: typeof ContentBlockStart;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class ContentBlockStopEvent extends ReadonlySide<
  {
    readonly contentBlockIndex: Constraint;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly contentBlockIndex: Constraint;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class ConverseMetrics extends ReadonlySide<
  {
    readonly latencyMs: DurationFromMillis;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly latencyMs: DurationFromMillis;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class ConverseOutput extends ReadonlySide<
  {
    readonly message: typeof Message;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly message: typeof 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?: ReadonlySide<{
    readonly latency: Literal<"standard">;
  }, "Type">;
  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?: ReadonlyMakeIn<{
      readonly latency: Literal<"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 ReadonlySide<
  {
    readonly latencyMs: DurationFromMillis;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly latencyMs: DurationFromMillis;
      }>,
      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 ReadonlySide<
  {
    readonly format: Literal<"csv">;
    readonly name: Constraint;
    readonly source: Struct<{
      readonly bytes: NonEmptyString;
    }>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly format: Literal<"csv">;
        readonly name: Constraint;
        readonly source: Struct<{
          readonly bytes: NonEmptyString;
        }>;
      }>,
      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 ReadonlySide<
  {
    readonly filters: $Array<typeof GuardrailContentFilter>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly filters: $Array<typeof 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 any {
  constructor();
}

declare class GuardrailConverseImageBlock extends ReadonlySide<
  {
    readonly format: Literal<"png">;
    readonly source: Struct<{
      readonly bytes: NonEmptyString;
    }>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly format: Literal<"png">;
        readonly source: Struct<{
          readonly bytes: NonEmptyString;
        }>;
      }>,
      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 ReadonlySide<
  {
    readonly piiEntities: $Array<typeof GuardrailPiiEntityFilter>;
    readonly regexes: $Array<typeof GuardrailRegexFilter>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly piiEntities: $Array<typeof GuardrailPiiEntityFilter>;
        readonly regexes: $Array<typeof 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 ReadonlySide<
  {
    readonly topics: $Array<typeof GuardrailTopic>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly topics: $Array<typeof 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 ReadonlySide<
  {
    readonly customWords: typeof GuardrailCustomWord;
    readonly managedWordLists: typeof GuardrailManagedWord;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly customWords: typeof GuardrailCustomWord;
        readonly managedWordLists: typeof GuardrailManagedWord;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class ImageBlock extends ReadonlySide<
  {
    readonly format: Literal<"gif">;
    readonly source: Struct<{
      readonly bytes: NonEmptyString;
    }>;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly format: Literal<"gif">;
        readonly source: Struct<{
          readonly bytes: NonEmptyString;
        }>;
      }>,
      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 ReadonlySide<
  {
    readonly json: Unknown;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly json: Unknown;
      }>,
      options?: MakeOptions,
    ]
  );
}

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

declare class MessageStartEvent extends ReadonlySide<
  {
    readonly role: Literal<"user">;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly role: Literal<"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 any {
  constructor();
}

declare class ReasoningContentBlockDelta extends any {
  constructor();
}

declare const StopReason: Literal<"end_turn">;

type StopReason = typeof StopReason.Type;

declare class SystemContentBlock extends any {
  constructor();
}

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 any {
  constructor();
}

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: ReadonlySide<{
    readonly json: $Record<Key, Constraint>;
  }, "Type">;
  readonly name: unknown;
} {
  constructor(...args: [props: {
    readonly description?: undefined;
    readonly inputSchema: ReadonlyMakeIn<{
      readonly json: $Record<Key, Constraint>;
    }>;
    readonly name: unknown;
  }, options?: MakeOptions]);
}

declare class ToolUseBlock extends ReadonlySide<
  {
    readonly input: Unknown;
    readonly name: Constraint;
    readonly toolUseId: Constraint;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly input: Unknown;
        readonly name: Constraint;
        readonly toolUseId: Constraint;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class ToolUseBlockDelta extends ReadonlySide<
  {
    readonly input: String;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly input: String;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class ToolUseBlockStart extends ReadonlySide<
  {
    readonly name: Constraint;
    readonly toolUseId: Constraint;
  },
  "Type"
> {
  constructor(
    ...args: [
      props: ReadonlyMakeIn<{
        readonly name: Constraint;
        readonly toolUseId: Constraint;
      }>,
      options?: MakeOptions,
    ]
  );
}

declare class VideoBlock extends ReadonlySide<{
  readonly format: Literal<"flv">;
  readonly source: Union<readonly Array<Constraint>>;
}, "Type"> {
  constructor(...args: [props: ReadonlyMakeIn<{
    readonly format: Literal<"flv">;
    readonly source: Union<readonly Array<Constraint>>;
  }>, options?: MakeOptions]);
}