@homeflare/distilled-litellm 0.2.0

package/dist/services/policies.d.ts

@@ -0,0 +1,618 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type LitellmOpError, type LitellmOpContext } from "../protocol.ts";
+export type { LitellmOpError, LitellmOpContext };
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+export interface GetPolicyInfoPolicyInfoPolicyNameGetRequest {
+    policy_name: string;
+}
+export declare const GetPolicyInfoPolicyInfoPolicyNameGetRequest: S.Schema<GetPolicyInfoPolicyInfoPolicyNameGetRequest>;
+export type PolicyGuardrailsResponseAddList = Array<string>;
+export declare const PolicyGuardrailsResponseAddList: S.Schema<PolicyGuardrailsResponseAddList>;
+export type PolicyGuardrailsResponseRemoveList = Array<string>;
+export declare const PolicyGuardrailsResponseRemoveList: S.Schema<PolicyGuardrailsResponseRemoveList>;
+/** Guardrails configuration for a policy. */
+export interface PolicyGuardrailsResponse {
+    add?: PolicyGuardrailsResponseAddList;
+    remove?: PolicyGuardrailsResponseRemoveList;
+}
+export declare const PolicyGuardrailsResponse: S.Schema<PolicyGuardrailsResponse>;
+export type PolicyInfoResponseInheritanceChainList = Array<string>;
+export declare const PolicyInfoResponseInheritanceChainList: S.Schema<PolicyInfoResponseInheritanceChainList>;
+export type PolicyInfoResponseResolvedGuardrailsList = Array<string>;
+export declare const PolicyInfoResponseResolvedGuardrailsList: S.Schema<PolicyInfoResponseResolvedGuardrailsList>;
+export type PolicyScopeResponseKeysList = Array<string>;
+export declare const PolicyScopeResponseKeysList: S.Schema<PolicyScopeResponseKeysList>;
+export type PolicyScopeResponseModelsList = Array<string>;
+export declare const PolicyScopeResponseModelsList: S.Schema<PolicyScopeResponseModelsList>;
+export type PolicyScopeResponseTagsList = Array<string>;
+export declare const PolicyScopeResponseTagsList: S.Schema<PolicyScopeResponseTagsList>;
+export type PolicyScopeResponseTeamsList = Array<string>;
+export declare const PolicyScopeResponseTeamsList: S.Schema<PolicyScopeResponseTeamsList>;
+/** Scope configuration for a policy. */
+export interface PolicyScopeResponse {
+    keys?: PolicyScopeResponseKeysList;
+    models?: PolicyScopeResponseModelsList;
+    tags?: PolicyScopeResponseTagsList;
+    teams?: PolicyScopeResponseTeamsList;
+}
+export declare const PolicyScopeResponse: S.Schema<PolicyScopeResponse>;
+/** Response for /policy/info/{policy_name} endpoint. */
+export interface PolicyInfoResponse {
+    guardrails: PolicyGuardrailsResponse;
+    inherit?: string | null;
+    inheritance_chain: PolicyInfoResponseInheritanceChainList;
+    policy_name: string;
+    resolved_guardrails: PolicyInfoResponseResolvedGuardrailsList;
+    scope: PolicyScopeResponse;
+}
+export declare const PolicyInfoResponse: S.Schema<PolicyInfoResponse>;
+export interface GetPolicyTemplatesPolicyTemplatesGetRequest {
+}
+export declare const GetPolicyTemplatesPolicyTemplatesGetRequest: S.Schema<GetPolicyTemplatesPolicyTemplatesGetRequest>;
+export type GetPolicyTemplatesPolicyTemplatesGetResponseBodyList = Array<unknown>;
+export declare const GetPolicyTemplatesPolicyTemplatesGetResponseBodyList: S.Schema<GetPolicyTemplatesPolicyTemplatesGetResponseBodyList>;
+export interface GetPolicyTemplatesPolicyTemplatesGetResponse {
+    body: GetPolicyTemplatesPolicyTemplatesGetResponseBodyList;
+}
+export declare const GetPolicyTemplatesPolicyTemplatesGetResponse: S.Schema<GetPolicyTemplatesPolicyTemplatesGetResponse>;
+export interface ListPoliciesPolicyListGetRequest {
+}
+export declare const ListPoliciesPolicyListGetRequest: S.Schema<ListPoliciesPolicyListGetRequest>;
+export type PolicySummaryItemInheritanceChainList = Array<string>;
+export declare const PolicySummaryItemInheritanceChainList: S.Schema<PolicySummaryItemInheritanceChainList>;
+export type PolicySummaryItemResolvedGuardrailsList = Array<string>;
+export declare const PolicySummaryItemResolvedGuardrailsList: S.Schema<PolicySummaryItemResolvedGuardrailsList>;
+/** Summary of a single policy for list endpoint. */
+export interface PolicySummaryItem {
+    guardrails: PolicyGuardrailsResponse;
+    inherit?: string | null;
+    inheritance_chain: PolicySummaryItemInheritanceChainList;
+    resolved_guardrails: PolicySummaryItemResolvedGuardrailsList;
+    scope: PolicyScopeResponse;
+}
+export declare const PolicySummaryItem: S.Schema<PolicySummaryItem>;
+export type PolicyListResponsePoliciesMap = {
+    [key: string]: PolicySummaryItem | undefined;
+};
+export declare const PolicyListResponsePoliciesMap: S.Schema<PolicyListResponsePoliciesMap>;
+/** Response for /policy/list endpoint. */
+export interface PolicyListResponse {
+    policies: PolicyListResponsePoliciesMap;
+    total_count: number;
+}
+export declare const PolicyListResponse: S.Schema<PolicyListResponse>;
+export type PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestCompetitorsList = Array<string>;
+export declare const PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestCompetitorsList: S.Schema<PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestCompetitorsList>;
+export type PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestParametersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestParametersMap: S.Schema<PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestParametersMap>;
+export interface PostEnrichPolicyTemplatePolicyTemplatesEnrichRequest {
+    /** Optional list of competitor names */
+    competitors?: PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestCompetitorsList | null;
+    /** Refinement instruction for modifying the competitor list (e.g. 'add 10 more from Asia') */
+    instruction?: string | null;
+    model?: string | null;
+    parameters: PostEnrichPolicyTemplatePolicyTemplatesEnrichRequestParametersMap;
+    template_id: string;
+}
+export declare const PostEnrichPolicyTemplatePolicyTemplatesEnrichRequest: S.Schema<PostEnrichPolicyTemplatePolicyTemplatesEnrichRequest>;
+export type PostEnrichPolicyTemplatePolicyTemplatesEnrichResponseBodyMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostEnrichPolicyTemplatePolicyTemplatesEnrichResponseBodyMap: S.Schema<PostEnrichPolicyTemplatePolicyTemplatesEnrichResponseBodyMap>;
+export interface PostEnrichPolicyTemplatePolicyTemplatesEnrichResponse {
+    body: PostEnrichPolicyTemplatePolicyTemplatesEnrichResponseBodyMap;
+}
+export declare const PostEnrichPolicyTemplatePolicyTemplatesEnrichResponse: S.Schema<PostEnrichPolicyTemplatePolicyTemplatesEnrichResponse>;
+export type PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestCompetitorsList = Array<string>;
+export declare const PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestCompetitorsList: S.Schema<PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestCompetitorsList>;
+export type PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestParametersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestParametersMap: S.Schema<PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestParametersMap>;
+export interface PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequest {
+    /** Optional list of competitor names */
+    competitors?: PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestCompetitorsList | null;
+    /** Refinement instruction for modifying the competitor list (e.g. 'add 10 more from Asia') */
+    instruction?: string | null;
+    model?: string | null;
+    parameters: PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequestParametersMap;
+    template_id: string;
+}
+export declare const PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequest: S.Schema<PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequest>;
+export interface PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamResponse {
+    body: unknown;
+}
+export declare const PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamResponse: S.Schema<PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamResponse>;
+export type PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequestAttackExamplesList = Array<string>;
+export declare const PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequestAttackExamplesList: S.Schema<PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequestAttackExamplesList>;
+export interface PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequest {
+    attack_examples?: PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequestAttackExamplesList;
+    description?: string;
+    model?: string | null;
+}
+export declare const PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequest: S.Schema<PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequest>;
+export type PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponseBodyMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponseBodyMap: S.Schema<PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponseBodyMap>;
+export interface PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponse {
+    body: PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponseBodyMap;
+}
+export declare const PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponse: S.Schema<PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponse>;
+export type PostTestPolicyMatchingPolicyTestRequestTagsList = Array<string>;
+export declare const PostTestPolicyMatchingPolicyTestRequestTagsList: S.Schema<PostTestPolicyMatchingPolicyTestRequestTagsList>;
+export interface PostTestPolicyMatchingPolicyTestRequest {
+    /** API key alias from the request. */
+    key_alias?: string | null;
+    /** Model name from the request. */
+    model?: string | null;
+    /** Tags from key/team metadata. */
+    tags?: PostTestPolicyMatchingPolicyTestRequestTagsList | null;
+    /** Team alias from the request. */
+    team_alias?: string | null;
+}
+export declare const PostTestPolicyMatchingPolicyTestRequest: S.Schema<PostTestPolicyMatchingPolicyTestRequest>;
+export type PolicyMatchContextTagsList = Array<string>;
+export declare const PolicyMatchContextTagsList: S.Schema<PolicyMatchContextTagsList>;
+/** Context used to match a request against policies. Contains the team alias, key alias, and model from the incoming request. */
+export interface PolicyMatchContext {
+    /** API key alias from the request. */
+    key_alias?: string | null;
+    /** Model name from the request. */
+    model?: string | null;
+    /** Tags from key/team metadata. */
+    tags?: PolicyMatchContextTagsList | null;
+    /** Team alias from the request. */
+    team_alias?: string | null;
+}
+export declare const PolicyMatchContext: S.Schema<PolicyMatchContext>;
+export type PolicyTestResponseMatchingPoliciesList = Array<string>;
+export declare const PolicyTestResponseMatchingPoliciesList: S.Schema<PolicyTestResponseMatchingPoliciesList>;
+export type PolicyTestResponseResolvedGuardrailsList = Array<string>;
+export declare const PolicyTestResponseResolvedGuardrailsList: S.Schema<PolicyTestResponseResolvedGuardrailsList>;
+/** Response for /policy/test endpoint. */
+export interface PolicyTestResponse {
+    context: PolicyMatchContext;
+    matching_policies: PolicyTestResponseMatchingPoliciesList;
+    message?: string | null;
+    resolved_guardrails: PolicyTestResponseResolvedGuardrailsList;
+}
+export declare const PolicyTestResponse: S.Schema<PolicyTestResponse>;
+export type PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsItemMap: S.Schema<PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsItemMap>;
+/** All guardrailDefinitions from the policy template */
+export type PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsList = Array<PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsItemMap>;
+export declare const PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsList: S.Schema<PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsList>;
+export interface PostTestPolicyTemplatePolicyTemplatesTestRequest {
+    /** All guardrailDefinitions from the policy template */
+    guardrail_definitions: PostTestPolicyTemplatePolicyTemplatesTestRequestGuardrailDefinitionsList;
+    /** Test input text to run guardrails against */
+    text: string;
+}
+export declare const PostTestPolicyTemplatePolicyTemplatesTestRequest: S.Schema<PostTestPolicyTemplatePolicyTemplatesTestRequest>;
+export interface GuardrailTestResultEntry {
+    action: string;
+    details: string;
+    guardrail_name: string;
+    output_text: string;
+}
+export declare const GuardrailTestResultEntry: S.Schema<GuardrailTestResultEntry>;
+export type TestPolicyTemplateResponseResultsList = Array<GuardrailTestResultEntry>;
+export declare const TestPolicyTemplateResponseResultsList: S.Schema<TestPolicyTemplateResponseResultsList>;
+export interface TestPolicyTemplateResponse {
+    overall_action: string;
+    results: TestPolicyTemplateResponseResultsList;
+}
+export declare const TestPolicyTemplateResponse: S.Schema<TestPolicyTemplateResponse>;
+export type TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestGuardrailNamesList = Array<string>;
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestGuardrailNamesList: S.Schema<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestGuardrailNamesList>;
+/** Whether inputs are request or response */
+export type TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputType = "request" | "response";
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputType: any;
+export type GenericGuardrailAPIInputsImagesList = Array<string>;
+export declare const GenericGuardrailAPIInputsImagesList: S.Schema<GenericGuardrailAPIInputsImagesList>;
+export type GenericGuardrailAPIInputsStreamHoldbackCharsList = Array<number>;
+export declare const GenericGuardrailAPIInputsStreamHoldbackCharsList: S.Schema<GenericGuardrailAPIInputsStreamHoldbackCharsList>;
+export type ChatCompletionCachedContentTtl = "5m" | "1h";
+export declare const ChatCompletionCachedContentTtl: any;
+export interface ChatCompletionCachedContent {
+    ttl?: ChatCompletionCachedContentTtl | (string & {});
+    type: string;
+}
+export declare const ChatCompletionCachedContent: S.Schema<ChatCompletionCachedContent>;
+export interface ChatCompletionTextObject {
+    cache_control?: ChatCompletionCachedContent;
+    text: string;
+    type: string;
+}
+export declare const ChatCompletionTextObject: S.Schema<ChatCompletionTextObject>;
+export interface ChatCompletionImageUrlObject {
+    detail?: string;
+    format?: string;
+    url: string;
+}
+export declare const ChatCompletionImageUrlObject: S.Schema<ChatCompletionImageUrlObject>;
+export type ChatCompletionImageObjectImageUrl = string | ChatCompletionImageUrlObject;
+export declare const ChatCompletionImageObjectImageUrl: S.Schema<ChatCompletionImageObjectImageUrl>;
+export interface ChatCompletionImageObject {
+    image_url: ChatCompletionImageObjectImageUrl;
+    type: string;
+}
+export declare const ChatCompletionImageObject: S.Schema<ChatCompletionImageObject>;
+export type InputAudioFormat = "wav" | "mp3";
+export declare const InputAudioFormat: any;
+export interface InputAudio {
+    data: string;
+    format: InputAudioFormat | (string & {});
+}
+export declare const InputAudio: S.Schema<InputAudio>;
+export interface ChatCompletionAudioObject {
+    input_audio: InputAudio;
+    type: string;
+}
+export declare const ChatCompletionAudioObject: S.Schema<ChatCompletionAudioObject>;
+export interface CitationsObject {
+    enabled: boolean;
+}
+export declare const CitationsObject: S.Schema<CitationsObject>;
+export interface DocumentObject {
+    data: string;
+    media_type: string;
+    type: string;
+}
+export declare const DocumentObject: S.Schema<DocumentObject>;
+export interface ChatCompletionDocumentObject {
+    citations: CitationsObject | null;
+    context: string;
+    source: DocumentObject;
+    title: string;
+    type: string;
+}
+export declare const ChatCompletionDocumentObject: S.Schema<ChatCompletionDocumentObject>;
+export interface ChatCompletionVideoUrlObject {
+    detail?: string;
+    url: string;
+}
+export declare const ChatCompletionVideoUrlObject: S.Schema<ChatCompletionVideoUrlObject>;
+export type ChatCompletionVideoObjectVideoUrl = string | ChatCompletionVideoUrlObject;
+export declare const ChatCompletionVideoObjectVideoUrl: S.Schema<ChatCompletionVideoObjectVideoUrl>;
+export interface ChatCompletionVideoObject {
+    type: string;
+    video_url: ChatCompletionVideoObjectVideoUrl;
+}
+export declare const ChatCompletionVideoObject: S.Schema<ChatCompletionVideoObject>;
+export type ChatCompletionFileObjectFileVideoMetadataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionFileObjectFileVideoMetadataMap: S.Schema<ChatCompletionFileObjectFileVideoMetadataMap>;
+export interface ChatCompletionFileObjectFile {
+    detail?: string;
+    file_data?: string;
+    file_id?: string;
+    filename?: string;
+    format?: string;
+    video_metadata?: ChatCompletionFileObjectFileVideoMetadataMap;
+}
+export declare const ChatCompletionFileObjectFile: S.Schema<ChatCompletionFileObjectFile>;
+export interface ChatCompletionFileObject {
+    file: ChatCompletionFileObjectFile;
+    type: string;
+}
+export declare const ChatCompletionFileObject: S.Schema<ChatCompletionFileObject>;
+export type ChatCompletionUserMessageContentCase1Item = ChatCompletionTextObject | ChatCompletionImageObject | ChatCompletionAudioObject | ChatCompletionDocumentObject | ChatCompletionVideoObject | ChatCompletionFileObject;
+export declare const ChatCompletionUserMessageContentCase1Item: S.Schema<ChatCompletionUserMessageContentCase1Item>;
+export type ChatCompletionUserMessageContentCase1List = Array<ChatCompletionUserMessageContentCase1Item>;
+export declare const ChatCompletionUserMessageContentCase1List: S.Schema<ChatCompletionUserMessageContentCase1List>;
+export type ChatCompletionUserMessageContent = string | ChatCompletionUserMessageContentCase1List;
+export declare const ChatCompletionUserMessageContent: S.Schema<ChatCompletionUserMessageContent>;
+export interface ChatCompletionUserMessage {
+    cache_control?: ChatCompletionCachedContent;
+    content: ChatCompletionUserMessageContent;
+    role: string;
+}
+export declare const ChatCompletionUserMessage: S.Schema<ChatCompletionUserMessage>;
+export type ChatCompletionThinkingBlockCacheControlCase0Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionThinkingBlockCacheControlCase0Map: S.Schema<ChatCompletionThinkingBlockCacheControlCase0Map>;
+export type ChatCompletionThinkingBlockCacheControl = ChatCompletionThinkingBlockCacheControlCase0Map | ChatCompletionCachedContent;
+export declare const ChatCompletionThinkingBlockCacheControl: S.Schema<ChatCompletionThinkingBlockCacheControl>;
+export interface ChatCompletionThinkingBlock {
+    cache_control?: ChatCompletionThinkingBlockCacheControl | null;
+    signature?: string | null;
+    thinking?: string;
+    type: string;
+}
+export declare const ChatCompletionThinkingBlock: S.Schema<ChatCompletionThinkingBlock>;
+export type ChatCompletionRedactedThinkingBlockCacheControlCase0Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionRedactedThinkingBlockCacheControlCase0Map: S.Schema<ChatCompletionRedactedThinkingBlockCacheControlCase0Map>;
+export type ChatCompletionRedactedThinkingBlockCacheControl = ChatCompletionRedactedThinkingBlockCacheControlCase0Map | ChatCompletionCachedContent;
+export declare const ChatCompletionRedactedThinkingBlockCacheControl: S.Schema<ChatCompletionRedactedThinkingBlockCacheControl>;
+export interface ChatCompletionRedactedThinkingBlock {
+    cache_control?: ChatCompletionRedactedThinkingBlockCacheControl | null;
+    data?: string;
+    type: string;
+}
+export declare const ChatCompletionRedactedThinkingBlock: S.Schema<ChatCompletionRedactedThinkingBlock>;
+export type ChatCompletionAssistantMessageContentCase1Item = ChatCompletionTextObject | ChatCompletionThinkingBlock | ChatCompletionRedactedThinkingBlock | ChatCompletionImageObject;
+export declare const ChatCompletionAssistantMessageContentCase1Item: S.Schema<ChatCompletionAssistantMessageContentCase1Item>;
+export type ChatCompletionAssistantMessageContentCase1List = Array<ChatCompletionAssistantMessageContentCase1Item>;
+export declare const ChatCompletionAssistantMessageContentCase1List: S.Schema<ChatCompletionAssistantMessageContentCase1List>;
+export type ChatCompletionAssistantMessageContent = string | ChatCompletionAssistantMessageContentCase1List;
+export declare const ChatCompletionAssistantMessageContent: S.Schema<ChatCompletionAssistantMessageContent>;
+export type ChatCompletionToolCallFunctionChunkProviderSpecificFieldsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionToolCallFunctionChunkProviderSpecificFieldsMap: S.Schema<ChatCompletionToolCallFunctionChunkProviderSpecificFieldsMap>;
+export interface ChatCompletionToolCallFunctionChunk {
+    arguments?: string;
+    name?: string | null;
+    provider_specific_fields?: ChatCompletionToolCallFunctionChunkProviderSpecificFieldsMap | null;
+}
+export declare const ChatCompletionToolCallFunctionChunk: S.Schema<ChatCompletionToolCallFunctionChunk>;
+export interface ChatCompletionReasoningSummaryTextBlock {
+    text?: string;
+    type: string;
+}
+export declare const ChatCompletionReasoningSummaryTextBlock: S.Schema<ChatCompletionReasoningSummaryTextBlock>;
+export type ChatCompletionReasoningItemSummaryList = Array<ChatCompletionReasoningSummaryTextBlock>;
+export declare const ChatCompletionReasoningItemSummaryList: S.Schema<ChatCompletionReasoningItemSummaryList>;
+/** Represents an OpenAI Responses API reasoning item for round-tripping in conversation history. */
+export interface ChatCompletionReasoningItem {
+    encrypted_content?: string | null;
+    id?: string;
+    summary?: ChatCompletionReasoningItemSummaryList;
+    type: string;
+}
+export declare const ChatCompletionReasoningItem: S.Schema<ChatCompletionReasoningItem>;
+export type ChatCompletionAssistantMessageReasoningItemsList = Array<ChatCompletionReasoningItem>;
+export declare const ChatCompletionAssistantMessageReasoningItemsList: S.Schema<ChatCompletionAssistantMessageReasoningItemsList>;
+export type ChatCompletionAssistantMessageThinkingBlocksItem = ChatCompletionThinkingBlock | ChatCompletionRedactedThinkingBlock;
+export declare const ChatCompletionAssistantMessageThinkingBlocksItem: S.Schema<ChatCompletionAssistantMessageThinkingBlocksItem>;
+export type ChatCompletionAssistantMessageThinkingBlocksList = Array<ChatCompletionAssistantMessageThinkingBlocksItem>;
+export declare const ChatCompletionAssistantMessageThinkingBlocksList: S.Schema<ChatCompletionAssistantMessageThinkingBlocksList>;
+export interface ChatCompletionAssistantToolCall {
+    function: ChatCompletionToolCallFunctionChunk;
+    id: string | null;
+    type: string;
+}
+export declare const ChatCompletionAssistantToolCall: S.Schema<ChatCompletionAssistantToolCall>;
+export type ChatCompletionAssistantMessageToolCallsList = Array<ChatCompletionAssistantToolCall>;
+export declare const ChatCompletionAssistantMessageToolCallsList: S.Schema<ChatCompletionAssistantMessageToolCallsList>;
+export interface ChatCompletionAssistantMessage {
+    cache_control?: ChatCompletionCachedContent;
+    content?: ChatCompletionAssistantMessageContent | null;
+    function_call?: ChatCompletionToolCallFunctionChunk | null;
+    name?: string | null;
+    reasoning_content?: string | null;
+    reasoning_items?: ChatCompletionAssistantMessageReasoningItemsList | null;
+    role: string;
+    thinking_blocks?: ChatCompletionAssistantMessageThinkingBlocksList | null;
+    tool_calls?: ChatCompletionAssistantMessageToolCallsList | null;
+}
+export declare const ChatCompletionAssistantMessage: S.Schema<ChatCompletionAssistantMessage>;
+/** Anthropic tool-search result block, carried through untouched so it survives a round trip. */
+export interface ChatCompletionToolReferenceObject {
+    tool_name: string;
+    type: string;
+}
+export declare const ChatCompletionToolReferenceObject: S.Schema<ChatCompletionToolReferenceObject>;
+export type ChatCompletionToolMessageContentCase1Item = ChatCompletionTextObject | ChatCompletionImageObject | ChatCompletionToolReferenceObject;
+export declare const ChatCompletionToolMessageContentCase1Item: S.Schema<ChatCompletionToolMessageContentCase1Item>;
+export type ChatCompletionToolMessageContentCase1List = Array<ChatCompletionToolMessageContentCase1Item>;
+export declare const ChatCompletionToolMessageContentCase1List: S.Schema<ChatCompletionToolMessageContentCase1List>;
+export type ChatCompletionToolMessageContent = string | ChatCompletionToolMessageContentCase1List;
+export declare const ChatCompletionToolMessageContent: S.Schema<ChatCompletionToolMessageContent>;
+export interface ChatCompletionToolMessage {
+    content: ChatCompletionToolMessageContent;
+    role: string;
+    tool_call_id: string;
+}
+export declare const ChatCompletionToolMessage: S.Schema<ChatCompletionToolMessage>;
+export type ChatCompletionSystemMessageContentCase1List = Array<unknown>;
+export declare const ChatCompletionSystemMessageContentCase1List: S.Schema<ChatCompletionSystemMessageContentCase1List>;
+export type ChatCompletionSystemMessageContent = string | ChatCompletionSystemMessageContentCase1List;
+export declare const ChatCompletionSystemMessageContent: S.Schema<ChatCompletionSystemMessageContent>;
+export interface ChatCompletionSystemMessage {
+    cache_control?: ChatCompletionCachedContent;
+    content: ChatCompletionSystemMessageContent;
+    name?: string;
+    role: string;
+}
+export declare const ChatCompletionSystemMessage: S.Schema<ChatCompletionSystemMessage>;
+export type ChatCompletionFunctionMessageContentCase1List = Array<ChatCompletionTextObject>;
+export declare const ChatCompletionFunctionMessageContentCase1List: S.Schema<ChatCompletionFunctionMessageContentCase1List>;
+export type ChatCompletionFunctionMessageContent = string | ChatCompletionFunctionMessageContentCase1List;
+export declare const ChatCompletionFunctionMessageContent: S.Schema<ChatCompletionFunctionMessageContent>;
+export interface ChatCompletionFunctionMessage {
+    content: ChatCompletionFunctionMessageContent | null;
+    name: string;
+    role: string;
+    tool_call_id: string | null;
+}
+export declare const ChatCompletionFunctionMessage: S.Schema<ChatCompletionFunctionMessage>;
+export type ChatCompletionDeveloperMessageContentCase1List = Array<unknown>;
+export declare const ChatCompletionDeveloperMessageContentCase1List: S.Schema<ChatCompletionDeveloperMessageContentCase1List>;
+export type ChatCompletionDeveloperMessageContent = string | ChatCompletionDeveloperMessageContentCase1List;
+export declare const ChatCompletionDeveloperMessageContent: S.Schema<ChatCompletionDeveloperMessageContent>;
+export interface ChatCompletionDeveloperMessage {
+    cache_control?: ChatCompletionCachedContent;
+    content: ChatCompletionDeveloperMessageContent;
+    name?: string;
+    role: string;
+}
+export declare const ChatCompletionDeveloperMessage: S.Schema<ChatCompletionDeveloperMessage>;
+export type GenericGuardrailAPIInputsStructuredMessagesItem = ChatCompletionUserMessage | ChatCompletionAssistantMessage | ChatCompletionToolMessage | ChatCompletionSystemMessage | ChatCompletionFunctionMessage | ChatCompletionDeveloperMessage;
+export declare const GenericGuardrailAPIInputsStructuredMessagesItem: S.Schema<GenericGuardrailAPIInputsStructuredMessagesItem>;
+export type GenericGuardrailAPIInputsStructuredMessagesList = Array<GenericGuardrailAPIInputsStructuredMessagesItem>;
+export declare const GenericGuardrailAPIInputsStructuredMessagesList: S.Schema<GenericGuardrailAPIInputsStructuredMessagesList>;
+export type GenericGuardrailAPIInputsTextsList = Array<string>;
+export declare const GenericGuardrailAPIInputsTextsList: S.Schema<GenericGuardrailAPIInputsTextsList>;
+export interface ChatCompletionToolCallChunk {
+    function: ChatCompletionToolCallFunctionChunk;
+    id: string | null;
+    index: number;
+    type: string;
+}
+export declare const ChatCompletionToolCallChunk: S.Schema<ChatCompletionToolCallChunk>;
+export type GenericGuardrailAPIInputsToolCallsCase0List = Array<ChatCompletionToolCallChunk>;
+export declare const GenericGuardrailAPIInputsToolCallsCase0List: S.Schema<GenericGuardrailAPIInputsToolCallsCase0List>;
+export type ChatCompletionMessageToolCall = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionMessageToolCall: S.Schema<ChatCompletionMessageToolCall>;
+export type GenericGuardrailAPIInputsToolCallsCase1List = Array<ChatCompletionMessageToolCall>;
+export declare const GenericGuardrailAPIInputsToolCallsCase1List: S.Schema<GenericGuardrailAPIInputsToolCallsCase1List>;
+export type GenericGuardrailAPIInputsToolCalls = GenericGuardrailAPIInputsToolCallsCase0List | GenericGuardrailAPIInputsToolCallsCase1List;
+export declare const GenericGuardrailAPIInputsToolCalls: S.Schema<GenericGuardrailAPIInputsToolCalls>;
+export type ChatCompletionToolParamAllowedCallersList = Array<string>;
+export declare const ChatCompletionToolParamAllowedCallersList: S.Schema<ChatCompletionToolParamAllowedCallersList>;
+export type ChatCompletionToolParamFunctionChunkParametersMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ChatCompletionToolParamFunctionChunkParametersMap: S.Schema<ChatCompletionToolParamFunctionChunkParametersMap>;
+export interface ChatCompletionToolParamFunctionChunk {
+    description?: string;
+    name: string;
+    parameters?: ChatCompletionToolParamFunctionChunkParametersMap;
+    strict?: boolean;
+}
+export declare const ChatCompletionToolParamFunctionChunk: S.Schema<ChatCompletionToolParamFunctionChunk>;
+export interface ChatCompletionToolParam {
+    allowed_callers?: ChatCompletionToolParamAllowedCallersList;
+    cache_control?: ChatCompletionCachedContent;
+    function: ChatCompletionToolParamFunctionChunk;
+    type: string;
+}
+export declare const ChatCompletionToolParam: S.Schema<ChatCompletionToolParam>;
+export type GenericGuardrailAPIInputsToolsList = Array<ChatCompletionToolParam>;
+export declare const GenericGuardrailAPIInputsToolsList: S.Schema<GenericGuardrailAPIInputsToolsList>;
+export interface GenericGuardrailAPIInputs {
+    images?: GenericGuardrailAPIInputsImagesList;
+    model?: string | null;
+    stream_holdback_chars?: GenericGuardrailAPIInputsStreamHoldbackCharsList;
+    structured_messages?: GenericGuardrailAPIInputsStructuredMessagesList;
+    texts?: GenericGuardrailAPIInputsTextsList;
+    tool_calls?: GenericGuardrailAPIInputsToolCalls;
+    tools?: GenericGuardrailAPIInputsToolsList;
+}
+export declare const GenericGuardrailAPIInputs: S.Schema<GenericGuardrailAPIInputs>;
+/** List of GenericGuardrailAPIInputs; each item processed separately (for batch compliance testing). */
+export type TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputsListList = Array<GenericGuardrailAPIInputs>;
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputsListList: S.Schema<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputsListList>;
+export type TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestPolicyNamesList = Array<string>;
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestPolicyNamesList: S.Schema<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestPolicyNamesList>;
+/** Request context (model, user_id, etc.) */
+export type TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestRequestDataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestRequestDataMap: S.Schema<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestRequestDataMap>;
+export interface TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequest {
+    /** When set, call chat completion with this model/agent for each input and include the response in the result. */
+    agent_id?: string | null;
+    /** Guardrail names to apply directly */
+    guardrail_names?: TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestGuardrailNamesList | null;
+    /** Whether inputs are request or response */
+    input_type?: TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputType | (string & {});
+    /** List of GenericGuardrailAPIInputs; each item processed separately (for batch compliance testing). */
+    inputs_list?: TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestInputsListList;
+    /** Policy names to resolve guardrails from */
+    policy_names?: TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestPolicyNamesList | null;
+    /** Request context (model, user_id, etc.) */
+    request_data?: TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequestRequestDataMap;
+}
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequest: S.Schema<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequest>;
+export interface TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostResponse {
+    body: unknown;
+}
+export declare const TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostResponse: S.Schema<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostResponse>;
+/** Policy configuration to validate. Map of policy names to policy definitions. */
+export type ValidatePolicyPolicyValidatePostRequestPoliciesMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ValidatePolicyPolicyValidatePostRequestPoliciesMap: S.Schema<ValidatePolicyPolicyValidatePostRequestPoliciesMap>;
+export interface ValidatePolicyPolicyValidatePostRequest {
+    /** Policy configuration to validate. Map of policy names to policy definitions. */
+    policies: ValidatePolicyPolicyValidatePostRequestPoliciesMap;
+}
+export declare const ValidatePolicyPolicyValidatePostRequest: S.Schema<ValidatePolicyPolicyValidatePostRequest>;
+/** Types of validation errors that can occur. */
+export type PolicyValidationErrorType = "invalid_guardrail" | "invalid_team" | "invalid_key" | "invalid_model" | "invalid_inheritance" | "circular_inheritance" | "invalid_scope" | "invalid_syntax";
+export declare const PolicyValidationErrorType: any;
+/** Represents a validation error or warning for a policy. */
+export interface PolicyValidationError {
+    /** Type of validation error. */
+    error_type: PolicyValidationErrorType;
+    /** Specific field that caused the error (e.g., 'guardrails.add', 'scope.teams'). */
+    field?: string | null;
+    /** Human-readable error message. */
+    message: string;
+    /** Name of the policy with the issue. */
+    policy_name: string;
+    /** The invalid value that caused the error. */
+    value?: string | null;
+}
+export declare const PolicyValidationError: S.Schema<PolicyValidationError>;
+/** List of blocking validation errors. */
+export type PolicyValidationResponseErrorsList = Array<PolicyValidationError>;
+export declare const PolicyValidationResponseErrorsList: S.Schema<PolicyValidationResponseErrorsList>;
+/** List of non-blocking validation warnings. */
+export type PolicyValidationResponseWarningsList = Array<PolicyValidationError>;
+export declare const PolicyValidationResponseWarningsList: S.Schema<PolicyValidationResponseWarningsList>;
+/** Response from policy validation. - `valid`: True if no blocking errors were found - `errors`: List of blocking errors (prevent policy from being applied) - `warnings`: List of non-blocking warnings (policy can still be applied) */
+export interface PolicyValidationResponse {
+    /** List of blocking validation errors. */
+    errors?: PolicyValidationResponseErrorsList;
+    /** True if the policy configuration is valid. */
+    valid: boolean;
+    /** List of non-blocking validation warnings. */
+    warnings?: PolicyValidationResponseWarningsList;
+}
+export declare const PolicyValidationResponse: S.Schema<PolicyValidationResponse>;
+export type GetPolicyInfoPolicyInfoPolicyNameGetError = UnprocessableEntity | LitellmOpError;
+/** Get Policy Info Get detailed information about a specific policy. Returns: - Policy configuration - Resolved guardrails (after inheritance) - Inheritance chain */
+export declare const getPolicyInfoPolicyInfoPolicyNameGet: API.OperationMethod<GetPolicyInfoPolicyInfoPolicyNameGetRequest, PolicyInfoResponse, GetPolicyInfoPolicyInfoPolicyNameGetError, LitellmOpContext>;
+export type GetPolicyTemplatesPolicyTemplatesGetError = LitellmOpError;
+/** Get Policy Templates Get policy templates for the UI (pre-configured guardrail combinations). Fetches from GitHub with automatic fallback to local backup on failure. Set LITELLM_LOCAL_POLICY_TEMPLATES=true to skip GitHub and use local backup only. */
+export declare const getPolicyTemplatesPolicyTemplatesGet: API.OperationMethod<GetPolicyTemplatesPolicyTemplatesGetRequest, GetPolicyTemplatesPolicyTemplatesGetResponse, GetPolicyTemplatesPolicyTemplatesGetError, LitellmOpContext>;
+export type ListPoliciesPolicyListGetError = LitellmOpError;
+/** List Policies List all loaded policies with their resolved guardrails. Returns information about each policy including: - Inheritance configuration - Scope (teams, keys, models) - Guardrails to add/remove - Resolved guardrails (after inheritance) - Inheritance chain */
+export declare const listPoliciesPolicyListGet: API.OperationMethod<ListPoliciesPolicyListGetRequest, PolicyListResponse, ListPoliciesPolicyListGetError, LitellmOpContext>;
+export type PostEnrichPolicyTemplatePolicyTemplatesEnrichError = UnprocessableEntity | LitellmOpError;
+/** Enrich Policy Template Enrich a policy template with LLM-discovered data (e.g. competitor names). Calls an onboarded LLM to discover competitors for the given brand name, then returns enriched guardrailDefinitions with the discovered data populated. */
+export declare const postEnrichPolicyTemplatePolicyTemplatesEnrich: API.OperationMethod<PostEnrichPolicyTemplatePolicyTemplatesEnrichRequest, PostEnrichPolicyTemplatePolicyTemplatesEnrichResponse, PostEnrichPolicyTemplatePolicyTemplatesEnrichError, LitellmOpContext>;
+export type PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamError = UnprocessableEntity | LitellmOpError;
+/** Enrich Policy Template Stream Stream competitor names as SSE events as the LLM generates them. Events: - data: {"type": "competitor", "name": "..."} — each competitor as discovered - data: {"type": "done", "competitors": [...], "competitor_variations": {...}, "guardrailDefinitions": [...]} */
+export declare const postEnrichPolicyTemplateStreamPolicyTemplatesEnrichStream: API.OperationMethod<PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamRequest, PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamResponse, PostEnrichPolicyTemplateStreamPolicyTemplatesEnrichStreamError, LitellmOpContext>;
+export type PostSuggestPolicyTemplatesPolicyTemplatesSuggestError = UnprocessableEntity | LitellmOpError;
+/** Suggest Policy Templates Use AI to suggest policy templates based on attack examples and descriptions. Calls an LLM with tool calling to match user requirements to available templates. */
+export declare const postSuggestPolicyTemplatesPolicyTemplatesSuggest: API.OperationMethod<PostSuggestPolicyTemplatesPolicyTemplatesSuggestRequest, PostSuggestPolicyTemplatesPolicyTemplatesSuggestResponse, PostSuggestPolicyTemplatesPolicyTemplatesSuggestError, LitellmOpContext>;
+export type PostTestPolicyMatchingPolicyTestError = UnprocessableEntity | LitellmOpError;
+/** Test Policy Matching Test which policies would match a given request context. This is useful for debugging and understanding policy behavior. Request body: ```json { "team_alias": "healthcare-team", "key_alias": "my-api-key", "model": "gpt-4" } ``` Returns: - matching_policies: List of policy names that match - resolved_guardrails: Final list of guardrails that would be applied */
+export declare const postTestPolicyMatchingPolicyTest: API.OperationMethod<PostTestPolicyMatchingPolicyTestRequest, PolicyTestResponse, PostTestPolicyMatchingPolicyTestError, LitellmOpContext>;
+export type PostTestPolicyTemplatePolicyTemplatesTestError = UnprocessableEntity | LitellmOpError;
+/** Test Policy Template Test a policy template's guardrails against a text input without creating them. Instantiates temporary guardrails from the template definitions, runs them against the provided text, and returns per-guardrail results so users can verify the template solves their problem before creating it. */
+export declare const postTestPolicyTemplatePolicyTemplatesTest: API.OperationMethod<PostTestPolicyTemplatePolicyTemplatesTestRequest, TestPolicyTemplateResponse, PostTestPolicyTemplatePolicyTemplatesTestError, LitellmOpContext>;
+export type TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostError = UnprocessableEntity | LitellmOpError;
+/** Test Policies And Guardrails Apply policies and/or guardrails to inputs (for compliance UI testing). Use inputs_list for batch testing: each input is processed as a separate call so per-input block/allow and errors are returned. Use inputs for a single call (legacy). */
+export declare const testPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPost: API.OperationMethod<TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostRequest, TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostResponse, TestPoliciesAndGuardrailsUtilsTestPoliciesAndGuardrailsPostError, LitellmOpContext>;
+export type ValidatePolicyPolicyValidatePostError = UnprocessableEntity | LitellmOpError;
+/** Validate Policy Validate a policy configuration before applying it. Checks: - All referenced guardrails exist in the guardrail registry - All non-wildcard team aliases exist in the database - All non-wildcard key aliases exist in the database - Inheritance chains are valid (no cycles, parents exist) - Scope patterns are syntactically valid Returns: - valid: True if the policy configuration is valid (no blocking errors) - errors: List of blocking validation errors - warnings: List of non-blocking validation warnings Example request: ```json { "policies": { "global-baseline": { "guardrails": { "add": ["pii_blocker", "phi_blocker"] }, "scope": { "teams": ["*"], "keys": ["*"], "models": ["*"] } }, "healthcare-compliance": { "inherit": "global-baseline", "guardrails": { "add": ["hipaa_audit"] }, "scope": { "teams": ["healthcare-team"] } } } } ``` */
+export declare const validatePolicyPolicyValidatePost: API.OperationMethod<ValidatePolicyPolicyValidatePostRequest, PolicyValidationResponse, ValidatePolicyPolicyValidatePostError, LitellmOpContext>;
+//# sourceMappingURL=policies.d.ts.map