@homeflare/distilled-litellm 0.2.0

package/dist/services/guardrails.d.ts

@@ -0,0 +1,1221 @@
+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 type PiiEntityType = "CREDIT_CARD" | "CRYPTO" | "DATE_TIME" | "EMAIL_ADDRESS" | "IBAN_CODE" | "IP_ADDRESS" | "NRP" | "LOCATION" | "PERSON" | "PHONE_NUMBER" | "MEDICAL_LICENSE" | "URL" | "US_BANK_NUMBER" | "US_DRIVER_LICENSE" | "US_ITIN" | "US_PASSPORT" | "US_SSN" | "UK_NHS" | "UK_NINO" | "UK_PASSPORT" | "UK_POSTCODE" | "UK_VEHICLE_REGISTRATION" | "ES_NIF" | "ES_NIE" | "IT_FISCAL_CODE" | "IT_DRIVER_LICENSE" | "IT_VAT_CODE" | "IT_PASSPORT" | "IT_IDENTITY_CARD" | "PL_PESEL" | "SG_NRIC_FIN" | "SG_UEN" | "AU_ABN" | "AU_ACN" | "AU_TFN" | "AU_MEDICARE" | "IN_PAN" | "IN_AADHAAR" | "IN_VEHICLE_REGISTRATION" | "IN_VOTER" | "IN_PASSPORT" | "FI_PERSONAL_IDENTITY_CODE";
+export declare const PiiEntityType: any;
+export type ApplyGuardrailApplyGuardrailPostRequestEntitiesList = Array<PiiEntityType | (string & {})>;
+export declare const ApplyGuardrailApplyGuardrailPostRequestEntitiesList: S.Schema<ApplyGuardrailApplyGuardrailPostRequestEntitiesList>;
+export type ApplyGuardrailApplyGuardrailPostRequestMessagesItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ApplyGuardrailApplyGuardrailPostRequestMessagesItemMap: S.Schema<ApplyGuardrailApplyGuardrailPostRequestMessagesItemMap>;
+export type ApplyGuardrailApplyGuardrailPostRequestMessagesList = Array<ApplyGuardrailApplyGuardrailPostRequestMessagesItemMap>;
+export declare const ApplyGuardrailApplyGuardrailPostRequestMessagesList: S.Schema<ApplyGuardrailApplyGuardrailPostRequestMessagesList>;
+export type ApplyGuardrailApplyGuardrailPostRequestMetadataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ApplyGuardrailApplyGuardrailPostRequestMetadataMap: S.Schema<ApplyGuardrailApplyGuardrailPostRequestMetadataMap>;
+export interface ApplyGuardrailApplyGuardrailPostRequest {
+    entities?: ApplyGuardrailApplyGuardrailPostRequestEntitiesList | null;
+    guardrail_name: string;
+    input_type?: string;
+    language?: string | null;
+    messages?: ApplyGuardrailApplyGuardrailPostRequestMessagesList | null;
+    metadata?: ApplyGuardrailApplyGuardrailPostRequestMetadataMap | null;
+    text: string;
+}
+export declare const ApplyGuardrailApplyGuardrailPostRequest: S.Schema<ApplyGuardrailApplyGuardrailPostRequest>;
+export interface ApplyGuardrailResponse {
+    response_text: string;
+}
+export declare const ApplyGuardrailResponse: S.Schema<ApplyGuardrailResponse>;
+export type ApplyGuardrailGuardrailsApplyGuardrailPostRequestEntitiesList = Array<PiiEntityType | (string & {})>;
+export declare const ApplyGuardrailGuardrailsApplyGuardrailPostRequestEntitiesList: S.Schema<ApplyGuardrailGuardrailsApplyGuardrailPostRequestEntitiesList>;
+export type ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesItemMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesItemMap: S.Schema<ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesItemMap>;
+export type ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesList = Array<ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesItemMap>;
+export declare const ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesList: S.Schema<ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesList>;
+export type ApplyGuardrailGuardrailsApplyGuardrailPostRequestMetadataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ApplyGuardrailGuardrailsApplyGuardrailPostRequestMetadataMap: S.Schema<ApplyGuardrailGuardrailsApplyGuardrailPostRequestMetadataMap>;
+export interface ApplyGuardrailGuardrailsApplyGuardrailPostRequest {
+    entities?: ApplyGuardrailGuardrailsApplyGuardrailPostRequestEntitiesList | null;
+    guardrail_name: string;
+    input_type?: string;
+    language?: string | null;
+    messages?: ApplyGuardrailGuardrailsApplyGuardrailPostRequestMessagesList | null;
+    metadata?: ApplyGuardrailGuardrailsApplyGuardrailPostRequestMetadataMap | null;
+    text: string;
+}
+export declare const ApplyGuardrailGuardrailsApplyGuardrailPostRequest: S.Schema<ApplyGuardrailGuardrailsApplyGuardrailPostRequest>;
+export interface ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostRequest {
+    guardrail_id: string;
+}
+export declare const ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostRequest: S.Schema<ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostRequest>;
+export interface ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostResponse {
+    body: unknown;
+}
+export declare const ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostResponse: S.Schema<ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostResponse>;
+export type GuardrailGuardrailInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GuardrailGuardrailInfoMap: S.Schema<GuardrailGuardrailInfoMap>;
+/** 'block' raises an error; 'mask' replaces the code block with a placeholder. */
+export type LitellmParamsAction = "block" | "mask";
+export declare const LitellmParamsAction: any;
+export type LitellmParamsAdditionalProviderSpecificParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmParamsAdditionalProviderSpecificParamsMap: S.Schema<LitellmParamsAdditionalProviderSpecificParamsMap>;
+export type LitellmParamsAssertionsList = Array<string>;
+export declare const LitellmParamsAssertionsList: S.Schema<LitellmParamsAssertionsList>;
+export type LitellmParamsBlockedLanguagesList = Array<string>;
+export declare const LitellmParamsBlockedLanguagesList: S.Schema<LitellmParamsBlockedLanguagesList>;
+/** Action to take when content filter detects a match */
+export type ContentFilterAction = "BLOCK" | "MASK";
+export declare const ContentFilterAction: any;
+/** Represents a blocked word with its action and optional description */
+export interface BlockedWord {
+    /** Action to take when keyword is detected (BLOCK or MASK) */
+    action: ContentFilterAction | (string & {});
+    /** Optional description explaining why this keyword is sensitive */
+    description?: string | null;
+    /** The keyword to block or mask */
+    keyword: string;
+}
+export declare const BlockedWord: S.Schema<BlockedWord>;
+export type LitellmParamsBlockedWordsList = Array<BlockedWord>;
+export declare const LitellmParamsBlockedWordsList: S.Schema<LitellmParamsBlockedWordsList>;
+/** The action to take when the category is detected */
+export type ContentFilterCategoryConfigAction = "BLOCK" | "MASK";
+export declare const ContentFilterCategoryConfigAction: any;
+/** The severity threshold to detect the category */
+export type ContentFilterCategoryConfigSeverityThreshold = "high" | "medium" | "low";
+export declare const ContentFilterCategoryConfigSeverityThreshold: any;
+/** category: "harmful_self_harm" enabled: true action: "BLOCK" severity_threshold: "medium" category_file: "/path/to/custom_file.yaml" # optional override */
+export interface ContentFilterCategoryConfig {
+    /** The action to take when the category is detected */
+    action: ContentFilterCategoryConfigAction | (string & {});
+    /** The category to detect */
+    category: string;
+    /** Optional override. Use your own category file instead of the default one. */
+    category_file?: string | null;
+    /** Whether the category is enabled */
+    enabled?: boolean;
+    /** The severity threshold to detect the category */
+    severity_threshold?: ContentFilterCategoryConfigSeverityThreshold | (string & {});
+}
+export declare const ContentFilterCategoryConfig: S.Schema<ContentFilterCategoryConfig>;
+export type LitellmParamsCategoriesList = Array<ContentFilterCategoryConfig>;
+export declare const LitellmParamsCategoriesList: S.Schema<LitellmParamsCategoriesList>;
+export interface LakeraCategoryThresholds {
+    jailbreak?: number;
+    prompt_injection?: number;
+}
+export declare const LakeraCategoryThresholds: S.Schema<LakeraCategoryThresholds>;
+export type BedrockChecksContentFilterCategoryItemCategory = "VIOLENCE" | "HATE" | "SEXUAL" | "MISCONDUCT" | "INSULTS";
+export declare const BedrockChecksContentFilterCategoryItemCategory: any;
+export interface BedrockChecksContentFilterCategoryItem {
+    category: BedrockChecksContentFilterCategoryItemCategory | (string & {});
+}
+export declare const BedrockChecksContentFilterCategoryItem: S.Schema<BedrockChecksContentFilterCategoryItem>;
+export type BedrockChecksContentFilterModelCategoriesList = Array<BedrockChecksContentFilterCategoryItem>;
+export declare const BedrockChecksContentFilterModelCategoriesList: S.Schema<BedrockChecksContentFilterModelCategoriesList>;
+export interface BedrockChecksContentFilterModel {
+    categories: BedrockChecksContentFilterModelCategoriesList;
+}
+export declare const BedrockChecksContentFilterModel: S.Schema<BedrockChecksContentFilterModel>;
+export type BedrockChecksPromptAttackCategoryItemCategory = "JAILBREAK" | "PROMPT_INJECTION" | "PROMPT_LEAKAGE";
+export declare const BedrockChecksPromptAttackCategoryItemCategory: any;
+export interface BedrockChecksPromptAttackCategoryItem {
+    category: BedrockChecksPromptAttackCategoryItemCategory | (string & {});
+}
+export declare const BedrockChecksPromptAttackCategoryItem: S.Schema<BedrockChecksPromptAttackCategoryItem>;
+export type BedrockChecksPromptAttackModelCategoriesList = Array<BedrockChecksPromptAttackCategoryItem>;
+export declare const BedrockChecksPromptAttackModelCategoriesList: S.Schema<BedrockChecksPromptAttackModelCategoriesList>;
+export interface BedrockChecksPromptAttackModel {
+    categories: BedrockChecksPromptAttackModelCategoriesList;
+}
+export declare const BedrockChecksPromptAttackModel: S.Schema<BedrockChecksPromptAttackModel>;
+export type BedrockChecksSensitiveInformationEntityItemType = "ADDRESS" | "AGE" | "AWS_ACCESS_KEY" | "AWS_SECRET_KEY" | "CA_HEALTH_NUMBER" | "CA_SOCIAL_INSURANCE_NUMBER" | "CREDIT_DEBIT_CARD_CVV" | "CREDIT_DEBIT_CARD_EXPIRY" | "CREDIT_DEBIT_CARD_NUMBER" | "DRIVER_ID" | "EMAIL" | "INTERNATIONAL_BANK_ACCOUNT_NUMBER" | "IP_ADDRESS" | "LICENSE_PLATE" | "MAC_ADDRESS" | "NAME" | "PASSWORD" | "PHONE" | "PIN" | "SWIFT_CODE" | "UK_NATIONAL_HEALTH_SERVICE_NUMBER" | "UK_NATIONAL_INSURANCE_NUMBER" | "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER" | "URL" | "USERNAME" | "US_BANK_ACCOUNT_NUMBER" | "US_BANK_ROUTING_NUMBER" | "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER" | "US_PASSPORT_NUMBER" | "US_SOCIAL_SECURITY_NUMBER" | "VEHICLE_IDENTIFICATION_NUMBER";
+export declare const BedrockChecksSensitiveInformationEntityItemType: any;
+export interface BedrockChecksSensitiveInformationEntityItem {
+    type: BedrockChecksSensitiveInformationEntityItemType | (string & {});
+}
+export declare const BedrockChecksSensitiveInformationEntityItem: S.Schema<BedrockChecksSensitiveInformationEntityItem>;
+export type BedrockChecksSensitiveInformationModelEntitiesList = Array<BedrockChecksSensitiveInformationEntityItem>;
+export declare const BedrockChecksSensitiveInformationModelEntitiesList: S.Schema<BedrockChecksSensitiveInformationModelEntitiesList>;
+export interface BedrockChecksSensitiveInformationModel {
+    entities: BedrockChecksSensitiveInformationModelEntitiesList;
+}
+export declare const BedrockChecksSensitiveInformationModel: S.Schema<BedrockChecksSensitiveInformationModel>;
+/** Inline `checks` config for the resource-less Bedrock InvokeGuardrailChecks API. Include only the checks you want to run; at least one must be set. */
+export interface BedrockChecksConfigModel {
+    contentFilter?: BedrockChecksContentFilterModel | null;
+    promptAttack?: BedrockChecksPromptAttackModel | null;
+    sensitiveInformation?: BedrockChecksSensitiveInformationModel | null;
+}
+export declare const BedrockChecksConfigModel: S.Schema<BedrockChecksConfigModel>;
+export type LitellmParamsConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmParamsConfigMap: S.Schema<LitellmParamsConfigMap>;
+/** Fallback decision when no rule matches */
+export type LitellmParamsDefaultAction = "allow" | "deny";
+export declare const LitellmParamsDefaultAction: any;
+export type LitellmParamsDetectSecretsConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmParamsDetectSecretsConfigMap: S.Schema<LitellmParamsDetectSecretsConfigMap>;
+export type LitellmParamsDetectorsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmParamsDetectorsMap: S.Schema<LitellmParamsDetectorsMap>;
+export type LitellmParamsExtraHeadersList = Array<string>;
+export declare const LitellmParamsExtraHeadersList: S.Schema<LitellmParamsExtraHeadersList>;
+export type LitellmParamsGroundingStrictness = "BALANCED" | "STRICT";
+export declare const LitellmParamsGroundingStrictness: any;
+export type LitellmParamsMetadataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmParamsMetadataMap: S.Schema<LitellmParamsMetadataMap>;
+export type LitellmParamsMockRedactedTextMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const LitellmParamsMockRedactedTextMap: S.Schema<LitellmParamsMockRedactedTextMap>;
+export type LitellmParamsModeCase1List = Array<string>;
+export declare const LitellmParamsModeCase1List: S.Schema<LitellmParamsModeCase1List>;
+export type ModeDefaultCase1List = Array<string>;
+export declare const ModeDefaultCase1List: S.Schema<ModeDefaultCase1List>;
+/** Default mode when no tags match */
+export type ModeDefault = string | ModeDefaultCase1List;
+export declare const ModeDefault: S.Schema<ModeDefault>;
+export type ModeTagsValueCase1List = Array<string>;
+export declare const ModeTagsValueCase1List: S.Schema<ModeTagsValueCase1List>;
+export type ModeTagsValue = string | ModeTagsValueCase1List;
+export declare const ModeTagsValue: S.Schema<ModeTagsValue>;
+/** Tags for the guardrail mode */
+export type ModeTagsMap = {
+    [key: string]: ModeTagsValue | undefined;
+};
+export declare const ModeTagsMap: S.Schema<ModeTagsMap>;
+export interface Mode {
+    /** Default mode when no tags match */
+    default?: ModeDefault | null;
+    /** Tags for the guardrail mode */
+    tags: ModeTagsMap;
+}
+export declare const Mode: S.Schema<Mode>;
+/** When to apply the guardrail (pre_call, post_call, during_call, logging_only) */
+export type LitellmParamsMode = string | LitellmParamsModeCase1List | Mode;
+export declare const LitellmParamsMode: S.Schema<LitellmParamsMode>;
+/** Choose whether disallowed tools block the request or get rewritten out of the payload */
+export type LitellmParamsOnDisallowedAction = "block" | "rewrite";
+export declare const LitellmParamsOnDisallowedAction: any;
+export type LitellmParamsOnFlagged = "block" | "monitor" | "inject_system_message";
+export declare const LitellmParamsOnFlagged: any;
+export type LitellmParamsOnSensitiveData = "block" | "route";
+export declare const LitellmParamsOnSensitiveData: any;
+export type LitellmParamsOnViolation = "warn" | "end_session";
+export declare const LitellmParamsOnViolation: any;
+export type CiscoAIDefenseRuleEntityTypesList = Array<string>;
+export declare const CiscoAIDefenseRuleEntityTypesList: S.Schema<CiscoAIDefenseRuleEntityTypesList>;
+/** The canonical Cisco AI Defense rule name to evaluate. */
+export type CiscoAIDefenseRuleRuleName = "Code Detection" | "Harassment" | "Hate Speech" | "PCI" | "PHI" | "PII" | "Prompt Injection" | "Profanity" | "Sexual Content & Exploitation" | "Social Division & Polarization" | "Violence & Public Safety Threats";
+export declare const CiscoAIDefenseRuleRuleName: any;
+/** A single rule to enable for Cisco AI Defense inspection. */
+export interface CiscoAIDefenseRule {
+    /** Optional list of entity types for the rule (e.g. 'Email Address', 'Phone Number'). Applies to rules such as PII, PCI, and PHI. */
+    entity_types?: CiscoAIDefenseRuleEntityTypesList | null;
+    /** The canonical Cisco AI Defense rule name to evaluate. */
+    rule_name: CiscoAIDefenseRuleRuleName | (string & {});
+}
+export declare const CiscoAIDefenseRule: S.Schema<CiscoAIDefenseRule>;
+export type CiscoAIDefenseGuardrailConfigModelOptionalParamsEnabledRulesList = Array<CiscoAIDefenseRule>;
+export declare const CiscoAIDefenseGuardrailConfigModelOptionalParamsEnabledRulesList: S.Schema<CiscoAIDefenseGuardrailConfigModelOptionalParamsEnabledRulesList>;
+export type CiscoAIDefenseGuardrailConfigModelOptionalParamsFallbackOnError = "allow" | "block";
+export declare const CiscoAIDefenseGuardrailConfigModelOptionalParamsFallbackOnError: any;
+/** Which Cisco AI Defense inspection surface to use. 'chat' scans LLM model conversations via /api/v1/inspect/chat. 'mcp' scans MCP tool calls via /api/v1/inspect/mcp. Each guardrail instance targets exactly one surface; configure two guardrails to scan both chat and MCP traffic. */
+export type CiscoAIDefenseGuardrailConfigModelOptionalParamsInspectionType = "chat" | "mcp";
+export declare const CiscoAIDefenseGuardrailConfigModelOptionalParamsInspectionType: any;
+/** Optional parameters for the Cisco AI Defense guardrail. */
+export interface CiscoAIDefenseGuardrailConfigModelOptionalParams {
+    /** Explicit list of Cisco AI Defense rules to evaluate. If omitted, the policies configured for the API key in the Cisco AI Defense UI are used. */
+    enabled_rules?: CiscoAIDefenseGuardrailConfigModelOptionalParamsEnabledRulesList | null;
+    /** Behaviour when the Cisco AI Defense API is unavailable: 'allow' proceeds without scanning (high availability), 'block' rejects the request (maximum security). */
+    fallback_on_error?: CiscoAIDefenseGuardrailConfigModelOptionalParamsFallbackOnError | (string & {}) | null;
+    /** Override for the inspection endpoint path. Defaults to /api/v1/inspect/chat when inspection_type='chat' and /api/v1/inspect/mcp when inspection_type='mcp'. */
+    inspect_path?: string | null;
+    /** Which Cisco AI Defense inspection surface to use. 'chat' scans LLM model conversations via /api/v1/inspect/chat. 'mcp' scans MCP tool calls via /api/v1/inspect/mcp. Each guardrail instance targets exactly one surface; configure two guardrails to scan both chat and MCP traffic. */
+    inspection_type?: CiscoAIDefenseGuardrailConfigModelOptionalParamsInspectionType | (string & {});
+    /** Integration profile id to apply (advanced). */
+    integration_profile_id?: string | null;
+    /** Integration profile version to apply (advanced). */
+    integration_profile_version?: string | null;
+    /** Integration tenant id to apply (advanced). */
+    integration_tenant_id?: string | null;
+    /** Integration type to apply (advanced). */
+    integration_type?: string | null;
+    /** Action to take when Cisco AI Defense flags content. 'block' raises an HTTPException; 'monitor' logs the detection and lets the request continue. */
+    on_flagged_action?: string | null;
+    /** Timeout (seconds) for Cisco AI Defense API calls (1-60). */
+    timeout?: number | null;
+}
+export declare const CiscoAIDefenseGuardrailConfigModelOptionalParams: S.Schema<CiscoAIDefenseGuardrailConfigModelOptionalParams>;
+/** Type of pattern: 'prebuilt' for predefined patterns or 'regex' for custom */
+export type ContentFilterPatternPatternType = "prebuilt" | "regex";
+export declare const ContentFilterPatternPatternType: any;
+/** Represents a content filter pattern (prebuilt or custom regex) */
+export interface ContentFilterPattern {
+    /** Action to take when pattern matches (BLOCK or MASK) */
+    action: ContentFilterAction | (string & {});
+    /** Name for this pattern (used in logging and error messages) */
+    name?: string | null;
+    /** Custom regex pattern. Required if pattern_type is 'regex' */
+    pattern?: string | null;
+    /** Name of prebuilt pattern (e.g., 'us_ssn', 'credit_card'). Required if pattern_type is 'prebuilt' */
+    pattern_name?: string | null;
+    /** Type of pattern: 'prebuilt' for predefined patterns or 'regex' for custom */
+    pattern_type: ContentFilterPatternPatternType | (string & {});
+}
+export declare const ContentFilterPattern: S.Schema<ContentFilterPattern>;
+export type LitellmParamsPatternsList = Array<ContentFilterPattern>;
+export declare const LitellmParamsPatternsList: S.Schema<LitellmParamsPatternsList>;
+export type PiiAction = "BLOCK" | "MASK";
+export declare const PiiAction: any;
+export type LitellmParamsPiiEntitiesConfigMap = {
+    [key: string]: PiiAction | (string & {}) | undefined;
+};
+export declare const LitellmParamsPiiEntitiesConfigMap: S.Schema<LitellmParamsPiiEntitiesConfigMap>;
+export type LitellmParamsPolicyNamesList = Array<string>;
+export declare const LitellmParamsPolicyNamesList: S.Schema<LitellmParamsPolicyNamesList>;
+export type LitellmParamsPresidioEntitiesDenyListItem = PiiEntityType | string;
+export declare const LitellmParamsPresidioEntitiesDenyListItem: S.Schema<LitellmParamsPresidioEntitiesDenyListItem>;
+export type LitellmParamsPresidioEntitiesDenyListList = Array<LitellmParamsPresidioEntitiesDenyListItem>;
+export declare const LitellmParamsPresidioEntitiesDenyListList: S.Schema<LitellmParamsPresidioEntitiesDenyListList>;
+export type LitellmParamsPresidioFilterScope = "input" | "output" | "both";
+export declare const LitellmParamsPresidioFilterScope: any;
+export type LitellmParamsPresidioRunOn = "input" | "output" | "both";
+export declare const LitellmParamsPresidioRunOn: any;
+export type LitellmParamsPresidioScoreThresholdsMap = {
+    [key: string]: number | undefined;
+};
+export declare const LitellmParamsPresidioScoreThresholdsMap: S.Schema<LitellmParamsPresidioScoreThresholdsMap>;
+export type ToolPermissionRuleAllowedParamPatternsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ToolPermissionRuleAllowedParamPatternsMap: S.Schema<ToolPermissionRuleAllowedParamPatternsMap>;
+/** Whether to allow or deny this tool usage */
+export type ToolPermissionRuleDecision = "allow" | "deny";
+export declare const ToolPermissionRuleDecision: any;
+/** A rule defining permission for a specific tool or tool pattern */
+export interface ToolPermissionRule {
+    /** Optional regex map enforcing nested parameter values using dot/[] paths */
+    allowed_param_patterns?: ToolPermissionRuleAllowedParamPatternsMap | null;
+    /** Whether to allow or deny this tool usage */
+    decision: ToolPermissionRuleDecision | (string & {});
+    /** Unique identifier for the rule */
+    id: string;
+    /** Regex pattern applied to the tool's function name */
+    tool_name?: string | null;
+    /** Regex pattern applied to the tool type (e.g., function) */
+    tool_type?: string | null;
+}
+export declare const ToolPermissionRule: S.Schema<ToolPermissionRule>;
+export type LitellmParamsRulesList = Array<ToolPermissionRule>;
+export declare const LitellmParamsRulesList: S.Schema<LitellmParamsRulesList>;
+/** Behavior when the headroom compression service is unreachable or errors. 'fail_closed' raises an error (default). 'fail_open' logs a critical error and forwards the request uncompressed instead of blocking it. */
+export type LitellmParamsUnreachableFallback = "fail_closed" | "fail_open";
+export declare const LitellmParamsUnreachableFallback: any;
+export interface LitellmParams {
+    /** 'block' raises an error; 'mask' replaces the code block with a placeholder. */
+    action?: LitellmParamsAction | (string & {});
+    /** Additional provider-specific parameters for generic guardrail APIs */
+    additional_provider_specific_params?: LitellmParamsAdditionalProviderSpecificParamsMap | null;
+    /** Custom advisory message template used when on_flagged='inject_system_message'. Must contain a {reason} placeholder. Defaults to a generic advisory message if unset. */
+    advisory_system_message?: string | null;
+    /** Akto account ID for multi-tenant deployments. Env: AKTO_ACCOUNT_ID. Default: '1000000'. */
+    akto_account_id?: string | null;
+    /** API key for Akto. Env: AKTO_API_KEY. */
+    akto_api_key?: string | null;
+    /** Akto Guardrail API Base URL. Env: AKTO_GUARDRAIL_API_BASE. */
+    akto_base_url?: string | null;
+    /** Akto VXLAN ID. Env: AKTO_VXLAN_ID. Default: '0'. */
+    akto_vxlan_id?: string | null;
+    /** If True, replaces sensitive content with anonymized version when only PII/PCI/secrets are detected. Only applies in blocking mode. Defaults to False if not provided */
+    anonymize_input?: boolean | null;
+    /** Regional base URL for the Cisco AI Defense Inspection API. Defaults to https://us.api.inspect.aidefense.security.cisco.com. Supported regions: us (us-west-2), ap (ap-ne-1), eu (eu-central-1). The environment variable `CISCO_AI_DEFENSE_API_BASE` is consulted as a fallback. The endpoint path is derived from inspection_type (/api/v1/inspect/chat for 'chat', /api/v1/inspect/mcp for 'mcp'). */
+    api_base?: string | null;
+    /** Optional custom API endpoint for Model Armor */
+    api_endpoint?: string | null;
+    /** The Hiddenlayer API Id for the Hiddenlayer API. If not provided, the `HIDDENLAYER_CLIENT_ID` environment variable is checked or https://api.hiddenlayer.ai is used. */
+    api_id?: string | null;
+    /** API key for the Cisco AI Defense inspection endpoint. If not provided, the `CISCO_AI_DEFENSE_API_KEY` environment variable is used. Sent in the `X-Cisco-AI-Defense-API-Key` header. Both the chat and MCP endpoints use this key. */
+    api_key?: string | null;
+    /** API version for Javelin service */
+    api_version?: string | null;
+    /** Application name for Javelin service */
+    application?: string | null;
+    /** Application ID for Noma Security. Defaults to 'litellm' if not provided */
+    application_id?: string | null;
+    /** Custom assertions to validate against the output. Each assertion is a string describing a condition. */
+    assertions?: LitellmParamsAssertionsList | null;
+    /** Repello asset ID whose dashboard policies are enforced. Required; the guardrail raises at init if it is missing. */
+    asset_id?: string | null;
+    /** Set to True to request asynchronous analysis (sets `plr_async` header). Defaults to provider behaviour when omitted. */
+    async_mode?: boolean | null;
+    /** Authorization bearer token for IBM Guardrails API. Reads from IBM_GUARDRAILS_AUTH_TOKEN env var if None. */
+    auth_token?: string | null;
+    /** AWS access key ID for authentication */
+    aws_access_key_id?: string | null;
+    /** AWS Bedrock runtime endpoint URL */
+    aws_bedrock_runtime_endpoint?: string | null;
+    /** External ID required by the target role's trust policy on sts:AssumeRole */
+    aws_external_id?: string | null;
+    /** AWS profile name for credential retrieval */
+    aws_profile_name?: string | null;
+    /** AWS region where your guardrail is deployed */
+    aws_region_name?: string | null;
+    /** AWS role name for assuming roles */
+    aws_role_name?: string | null;
+    /** AWS secret access key for authentication */
+    aws_secret_access_key?: string | null;
+    /** Name of the AWS session */
+    aws_session_name?: string | null;
+    /** AWS session token for temporary credentials */
+    aws_session_token?: string | null;
+    /** AWS STS endpoint URL */
+    aws_sts_endpoint?: string | null;
+    /** Web identity token for AWS role assumption */
+    aws_web_identity_token?: string | null;
+    /** Base URL for the IBM Guardrails server */
+    base_url?: string | null;
+    /** If True, blocks requests on API failures. Defaults to True if not provided */
+    block_failures?: boolean | null;
+    /** Whether to block the request when the PromptGuard API is unreachable. Defaults to true (fail-closed). Set to false for fail-open behaviour. */
+    block_on_error?: boolean | null;
+    /** Whether to block requests when violations are detected. Defaults to True. */
+    block_on_violation?: boolean | null;
+    /** Language tags to block (e.g. python, javascript, bash). Empty or None = block all fenced code blocks. */
+    blocked_languages?: LitellmParamsBlockedLanguagesList | null;
+    /** List of blocked words with individual actions */
+    blocked_words?: LitellmParamsBlockedWordsList | null;
+    /** Path to YAML file containing blocked_words list */
+    blocked_words_file?: string | null;
+    /** Whether to include breakdown in the response */
+    breakdown?: boolean | null;
+    /** List of prebuilt categories to enable (harmful_*, bias_*) */
+    categories?: LitellmParamsCategoriesList | null;
+    /** Threshold configuration for Lakera guardrail categories */
+    category_thresholds?: LakeraCategoryThresholds | null;
+    /** Inline safeguards for the resource-less InvokeGuardrailChecks API (contentFilter / promptAttack / sensitiveInformation). When set, the guardrail calls InvokeGuardrailChecks instead of ApplyGuardrail and no guardrailIdentifier is required. Mutually exclusive with guardrailIdentifier. */
+    checks?: BedrockChecksConfigModel | null;
+    /** ApplyGuardrail: batch size, in characters, used to re-send content after AWS has rejected a request as too large. Requests AWS accepts are always sent in a single call, so this has no effect until a rejection happens. Defaults to 25,000; a batch AWS still rejects is bisected automatically, so this value only trades round trips against batch size and cannot fail a request on its own. */
+    chunk_budget_chars?: number;
+    /** Only block or mask when detection confidence >= this value; below threshold, allow or log_only. */
+    confidence_threshold?: number;
+    /** Additional configuration for the guardrail */
+    config?: LitellmParamsConfigMap | null;
+    /** InvokeGuardrailChecks: block when any contentFilter severityScore >= this value (scores are in [0,1]). Set to null to make the content filter detect-only (logged, never blocks). */
+    content_filter_threshold?: number | null;
+    /** Enable content moderation to check for harmful content (harassment, hate speech, etc.). */
+    content_moderation_check?: boolean | null;
+    /** Path to Google Cloud credentials JSON file or JSON string */
+    credentials?: string | null;
+    /** Python-like code containing the apply_guardrail function for custom guardrail logic */
+    custom_code?: string | null;
+    /** The DeepKeep Firewall ID to use for guardrail evaluation. If not provided, the `DEEPKEEP_FIREWALL_ID` environment variable is checked. */
+    deepkeep_firewall_id?: string | null;
+    /** Fallback decision when no rule matches */
+    default_action?: LitellmParamsDefaultAction | (string & {});
+    /** Whether the guardrail is enabled by default */
+    default_on?: boolean | null;
+    /** The EnkryptAI deployment name to use. Sent via X-Enkrypt-Deployment header. */
+    deployment_name?: string | null;
+    /** When True, block only when user intent is to run/execute; allow when intent is explain/refactor/don't run. Also block text-only execution requests (e.g. 'run `ls`', 'read /etc/passwd'). */
+    detect_execution_intent?: boolean;
+    /** Configuration for detect-secrets guardrail */
+    detect_secrets_config?: LitellmParamsDetectSecretsConfigMap | null;
+    /** Name of the detector inside the server (e.g., 'jailbreak-detector') */
+    detector_id?: string | null;
+    /** Dictionary of detector configurations (e.g., {'nsfw': {'enabled': True}, 'toxicity': {'enabled': True}}). */
+    detectors?: LitellmParamsDetectorsMap | null;
+    /** Whether to include developer information in the response */
+    dev_info?: boolean | null;
+    /** If True, will not raise an exception when the guardrail is blocked. Useful for OpenWebUI where exceptions can end the chat flow. */
+    disable_exception_on_block?: boolean | null;
+    /** For /v1/realtime sessions: automatically close the session after this many guardrail violations. */
+    end_session_after_n_fails?: number | null;
+    /** Pre-configured evaluation ID from Qualifire dashboard. When provided, uses invoke_evaluation() instead of evaluate(). */
+    evaluation_id?: string | null;
+    /** When True, guardrails only receive the latest message for the relevant role (e.g., newest user input pre-call, newest assistant output post-call) */
+    experimental_use_latest_role_message_only?: boolean | null;
+    /** Header names to forward from the client request to the guardrail (e.g. x-request-id). Only these headers' values are sent; others may be omitted or sent as [present]. Used by generic_guardrail_api (similar to MCP extra_headers). */
+    extra_headers?: LitellmParamsExtraHeadersList | null;
+    /** Whether to fail the request if the guardrail encounters an error. Implemented by guardrail='model_armor', 'generic_guardrail_api' and 'crowdstrike_aidr'. True (default) raises the error. False logs a critical error and lets the request proceed, so only a valid guardrail response can block or modify it. */
+    fail_on_error?: boolean | null;
+    /** Enable grounding verification to ensure output is grounded in provided context. */
+    grounding_check?: boolean | null;
+    /** Strictness level for XecGuard context-grounding validation. 'BALANCED' (default) treats INCOMPLETE answers as SAFE; 'STRICT' flags them as UNSAFE. Grounding only runs in post_call when `metadata.xecguard_grounding_documents` is provided. */
+    grounding_strictness?: LitellmParamsGroundingStrictness | (string & {}) | null;
+    /** Name of the Javelin guard to use */
+    guard_name?: string | null;
+    /** The type of guardrail integration to use */
+    guardrail: string;
+    /** The ID of your guardrail on Bedrock */
+    guardrailIdentifier?: string | null;
+    /** The version of your Bedrock guardrail (e.g., DRAFT or version number) */
+    guardrailVersion?: string | null;
+    /** HTTP timeout in seconds. Default: 5. */
+    guardrail_timeout?: number | null;
+    /** Enable hallucination detection to detect factual inaccuracies. */
+    hallucinations_check?: boolean | null;
+    /** Include detailed evidence payloads in responses (sets `plr_evidence` header). */
+    include_evidence?: boolean | null;
+    /** Include scanner category summaries in responses (sets `plr_scanners` header). */
+    include_scanners?: boolean | null;
+    /** Boolean flag to determine if calling a detector server (True) or the FMS Orchestrator (False). Defaults to True. */
+    is_detector_server?: boolean | null;
+    /** Tag to use for keyword redaction */
+    keyword_redaction_tag?: string | null;
+    /** Conversation ID for the Lasso guardrail */
+    lasso_conversation_id?: string | null;
+    /** User ID for the Lasso guardrail */
+    lasso_user_id?: string | null;
+    /** Google Cloud location/region (e.g., us-central1) */
+    location?: string | null;
+    /** Enable content masking using Lasso classifix API */
+    mask?: boolean | null;
+    /** Will mask request content if guardrail makes any changes */
+    mask_request_content?: boolean | null;
+    /** Will mask response content if guardrail makes any changes */
+    mask_response_content?: boolean | null;
+    /** Additional metadata to include in the request */
+    metadata?: LitellmParamsMetadataMap | null;
+    /** Mock redacted text for testing */
+    mock_redacted_text?: LitellmParamsMockRedactedTextMap | null;
+    /** When to apply the guardrail (pre_call, post_call, during_call, logging_only) */
+    mode: LitellmParamsMode;
+    /** Model name forwarded to the headroom /v1/compress endpoint. */
+    model?: string | null;
+    /** If True, logs violations without blocking. Defaults to False if not provided */
+    monitor_mode?: boolean | null;
+    /** Choose whether disallowed tools block the request or get rewritten out of the payload */
+    on_disallowed_action?: LitellmParamsOnDisallowedAction | (string & {});
+    /** Action to take when content is flagged: 'block' (raise exception), 'monitor' (log only), or 'inject_system_message' (append an advisory system message and let the LLM decide) */
+    on_flagged?: LitellmParamsOnFlagged | (string & {}) | null;
+    /** Action to take when content is flagged: 'block' (raise exception) or 'monitor' (log only) */
+    on_flagged_action?: string | null;
+    /** Action to take when sensitive data is detected. 'block' raises an exception (default behavior). 'route' reroutes the request to the model specified in sensitive_data_route_to_model. */
+    on_sensitive_data?: LitellmParamsOnSensitiveData | (string & {}) | null;
+    /** For /v1/realtime sessions: 'warn' speaks the violation message and continues; 'end_session' speaks the message and closes the connection. */
+    on_violation?: LitellmParamsOnViolation | (string & {}) | null;
+    /** When True, the guardrail only scans messages that have not already been scanned earlier in the same session (identified by litellm_session_id / session_id). Message content is hashed per session and cached; only the diff (new or edited messages) is sent to the guardrail provider on follow-up calls. Falls back to a full scan when the request has no session id or the cache is unavailable. Intended for blocking/detection guardrails; not applied when mask_request_content is set. */
+    only_scan_new_messages?: boolean | null;
+    /** Optional parameters for the guardrail */
+    optional_params?: CiscoAIDefenseGuardrailConfigModelOptionalParams | null;
+    /** When True, LiteLLM will replace the masked text with the original text in the response */
+    output_parse_pii?: boolean | null;
+    /** Recipe for input (LLM request) */
+    pangea_input_recipe?: string | null;
+    /** Recipe for output (LLM response) */
+    pangea_output_recipe?: string | null;
+    /** Format string for pattern redaction (use {pattern_name} placeholder) */
+    pattern_redaction_format?: string | null;
+    /** List of patterns (prebuilt or custom regex) to detect */
+    patterns?: LitellmParamsPatternsList | null;
+    /** Whether to include payload in the response */
+    payload?: boolean | null;
+    /** Controls Pillar session persistence (sets `plr_persist` header). Set to False to disable persistence. */
+    persist_session?: boolean | null;
+    /** Enable PII (Personally Identifiable Information) detection. */
+    pii_check?: boolean | null;
+    /** InvokeGuardrailChecks: block when any sensitiveInformation confidenceScore >= this value (scores are in [0,1]). Set to null to make PII detection detect-only. */
+    pii_confidence_threshold?: number | null;
+    /** Configuration for PII entity types and actions */
+    pii_entities_config?: LitellmParamsPiiEntitiesConfigMap | null;
+    /** Policy ID for Zscaler AI Guard. Can also be set via ZSCALER_AI_GUARD_POLICY_ID environment variable */
+    policy_id?: number | null;
+    /** The EnkryptAI policy name to use. Sent via x-enkrypt-policy header. */
+    policy_name?: string | null;
+    /** XecGuard policies to apply on each scan. Select one or more of the built-in default policies; if none are selected, the guardrail defaults to System Prompt Enforcement + Harmful Content Protection. */
+    policy_names?: LitellmParamsPolicyNamesList | null;
+    /** Post-checkpoint ID for the Ovalix Tracker service. */
+    post_checkpoint_id?: string | null;
+    /** Pre-checkpoint ID for the Ovalix Tracker service. */
+    pre_checkpoint_id?: string | null;
+    /** Path to a JSON file containing ad-hoc recognizers for Presidio */
+    presidio_ad_hoc_recognizers?: string | null;
+    /** Maximum UTF-8 bytes of text sent in a single Presidio /analyze call. Longer texts are split into overlapping chunks of at most this size and the merged results are remapped onto the original text. Defaults to 500000; set it below your analyzer deployment's request body limit, leaving headroom for the rest of the analyze payload. */
+    presidio_analyze_chunk_size_bytes?: number | null;
+    /** Base URL for the Presidio analyzer API */
+    presidio_analyzer_api_base?: string | null;
+    /** Base URL for the Presidio anonymizer API */
+    presidio_anonymizer_api_base?: string | null;
+    /** List of entity types to exclude from Presidio detection results. Detections of these types will be silently dropped. Useful for suppressing false positives (e.g., US_DRIVER_LICENSE on coding routes). */
+    presidio_entities_deny_list?: LitellmParamsPresidioEntitiesDenyListList | null;
+    /** Where to apply Presidio checks: 'input' (user -> model), 'output' (model -> user), or 'both' (default). */
+    presidio_filter_scope?: LitellmParamsPresidioFilterScope | (string & {}) | null;
+    /** Language code for Presidio PII analysis (e.g., 'en', 'de', 'es', 'fr') */
+    presidio_language?: string | null;
+    /** Where to apply Presidio checks: input, output, or both (default). */
+    presidio_run_on?: LitellmParamsPresidioRunOn | (string & {}) | null;
+    /** Optional per-entity minimum confidence scores for Presidio detections. Entities below the threshold are ignored. */
+    presidio_score_thresholds?: LitellmParamsPresidioScoreThresholdsMap | null;
+    /** Project ID for the Lakera AI project */
+    project_id?: string | null;
+    /** InvokeGuardrailChecks: block when any promptAttack severityScore >= this value (scores are in [0,1]). Set to null to make prompt-attack detection detect-only. */
+    prompt_attack_threshold?: number | null;
+    /** Enable prompt injection detection. Default check if no evaluation_id and no other checks are specified. */
+    prompt_injections?: boolean | null;
+    /** The message the bot speaks aloud when a /v1/realtime guardrail fires. Falls back to violation_message_template if not set. */
+    realtime_violation_message?: string | null;
+    /** Ordered allow/deny rules. Patterns use regex for tool names/types and optional regex constraints on tool arguments. */
+    rules?: LitellmParamsRulesList | null;
+    /** When True, this pre_call or post_call guardrail runs concurrently with other opted-in guardrails of the same hook, after the sequential guardrails have run. Use only for block-only guardrails that inspect and reject; do not enable it for guardrails that modify the request or response (e.g. PII masking or sensitive-data routing), since parallel runs share one snapshot and their mutations would race. */
+    run_in_parallel?: boolean | null;
+    /** For guardrail='model_armor': omit the raw Model Armor response from caller-facing errors and logs by default. Set False to restore verbose output. */
+    sanitize_error_detail?: boolean | null;
+    /** When True, unified guardrails only evaluate tool results, the untrusted data an agent feeds back into the model, and skip system, user, and assistant content. Intended for agent harnesses whose own prompt scaffolding is trusted but often trips prompt-attack detectors. */
+    scan_only_tool_results?: boolean | null;
+    /** When True, this pre_call guardrail always evaluates the request as it was before any guardrail in this hook ran, regardless of its position in the guardrails list -- so the YAML order of guardrails can never change whether this one blocks. Use only for block-only guardrails: any data this guardrail returns is discarded, same contract as run_in_parallel, since an earlier guardrail's masking must not be undone by this one. */
+    scan_raw_request?: boolean | null;
+    /** Whether to send user_API_key_alias in headers */
+    send_user_api_key_alias?: boolean | null;
+    /** Whether to send user_API_key_team_id in headers */
+    send_user_api_key_team_id?: boolean | null;
+    /** Whether to send user_API_key_user_id in headers */
+    send_user_api_key_user_id?: boolean | null;
+    /** Model to route requests to when sensitive data is detected and on_sensitive_data='route'. This is typically an on-premise model for data privacy. The routing decision persists for the entire session. */
+    sensitive_data_route_to_model?: string | null;
+    /** Minimum severity to block (high, medium, low) */
+    severity_threshold?: string | null;
+    /** The Singulr API base URL. Get base URL from Singulr Platform. */
+    singulr_api_base?: string | null;
+    /** The Singulr API key. Generate API key from Singulr Platform. */
+    singulr_api_key?: string | null;
+    /** The Singulr application ID. Get application ID from Singulr Platform. */
+    singulr_application_id?: string | null;
+    /** The Singulr Guardrail ID. Get guardrail ID from Singulr Platform. */
+    singulr_guardrail_id?: string | null;
+    /** When True, unified guardrails skip system-role messages when building evaluation inputs (texts and structured_messages). When False, system messages are included even if litellm_settings sets a global skip. When None, use the global litellm.skip_system_message_in_guardrail setting. For Anthropic /v1/messages, the flag applies only to the trusted top-level system prompt. In-sequence system entries are untrusted client input and remain in texts and structured_messages. */
+    skip_system_message_in_guardrail?: boolean | null;
+    /** When True, unified guardrails skip tool-role messages when building evaluation inputs (texts and structured_messages). When False, tool messages are included even if litellm_settings sets a global skip. When None, use the global litellm.skip_tool_message_in_guardrail setting. */
+    skip_tool_message_in_guardrail?: boolean | null;
+    /** Implemented by guardrail='model_armor'. When True, attachment references that carry no inline bytes (file_id, gs://, or http(s) URLs) pass through unscanned instead of blocking, while fail_on_error still governs real Model Armor API errors. Default False blocks them. */
+    skip_unscannable_attachments?: boolean | null;
+    /** When True (default), after sensitive data is detected and routed, all subsequent requests in the same session will continue routing to the same model. */
+    sticky_session_routing?: boolean | null;
+    /** The ID of your Model Armor template */
+    template_id?: string | null;
+    /** Per-request timeout for the guardrail provider API call (seconds). Accepts int, float, or numeric string; coerced to float on load. Each guardrail handler chooses its own default when unset. */
+    timeout?: number | null;
+    /** Enable tool selection quality check to evaluate quality of tool/function calls. */
+    tool_selection_quality_check?: boolean | null;
+    /** Base URL for the Ovalix Tracker service. */
+    tracker_api_base?: string | null;
+    /** API key for the Ovalix Tracker service. */
+    tracker_api_key?: string | null;
+    /** Behavior when the headroom compression service is unreachable or errors. 'fail_closed' raises an error (default). 'fail_open' logs a critical error and forwards the request uncompressed instead of blocking it. */
+    unreachable_fallback?: LitellmParamsUnreachableFallback | (string & {});
+    /** If True and guardrail='noma', route to the new Noma v2 implementation instead of the legacy implementation. */
+    use_v2?: boolean | null;
+    /** Whether to verify SSL certificates. Defaults to True. */
+    verify_ssl?: boolean | null;
+    /** Hiddenlayer guardrail version to use. */
+    version?: number | null;
+    /** Custom message when a guardrail blocks an action. Supports placeholders like {tool_name}, {rule_id}, and {default_message}. */
+    violation_message_template?: string | null;
+    /** XecGuard scanning model identifier. Defaults to 'xecguard_v2'. */
+    xecguard_model?: string | null;
+}
+export declare const LitellmParams: S.Schema<LitellmParams>;
+export interface Guardrail {
+    created_at?: string | null;
+    guardrail_id?: string | null;
+    guardrail_info?: GuardrailGuardrailInfoMap | null;
+    guardrail_name: string;
+    litellm_params: LitellmParams;
+    policy_template?: string | null;
+    updated_at?: string | null;
+}
+export declare const Guardrail: S.Schema<Guardrail>;
+export interface CreateGuardrailGuardrailsPostRequest {
+    guardrail: Guardrail;
+}
+export declare const CreateGuardrailGuardrailsPostRequest: S.Schema<CreateGuardrailGuardrailsPostRequest>;
+export interface CreateGuardrailGuardrailsPostResponse {
+    body: unknown;
+}
+export declare const CreateGuardrailGuardrailsPostResponse: S.Schema<CreateGuardrailGuardrailsPostResponse>;
+export interface DeleteGuardrailGuardrailsGuardrailIdDeleteRequest {
+    guardrail_id: string;
+}
+export declare const DeleteGuardrailGuardrailsGuardrailIdDeleteRequest: S.Schema<DeleteGuardrailGuardrailsGuardrailIdDeleteRequest>;
+export interface DeleteGuardrailGuardrailsGuardrailIdDeleteResponse {
+    body: unknown;
+}
+export declare const DeleteGuardrailGuardrailsGuardrailIdDeleteResponse: S.Schema<DeleteGuardrailGuardrailsGuardrailIdDeleteResponse>;
+export interface GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetRequest {
+    category_name: string;
+}
+export declare const GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetRequest: S.Schema<GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetRequest>;
+export interface GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetResponse {
+    body: unknown;
+}
+export declare const GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetResponse: S.Schema<GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetResponse>;
+export interface GetGuardrailInfoGuardrailsGuardrailIdGetRequest {
+    guardrail_id: string;
+}
+export declare const GetGuardrailInfoGuardrailsGuardrailIdGetRequest: S.Schema<GetGuardrailInfoGuardrailsGuardrailIdGetRequest>;
+export interface GetGuardrailInfoGuardrailsGuardrailIdGetResponse {
+    body: unknown;
+}
+export declare const GetGuardrailInfoGuardrailsGuardrailIdGetResponse: S.Schema<GetGuardrailInfoGuardrailsGuardrailIdGetResponse>;
+export interface GetGuardrailInfoGuardrailsGuardrailIdInfoGetRequest {
+    guardrail_id: string;
+}
+export declare const GetGuardrailInfoGuardrailsGuardrailIdInfoGetRequest: S.Schema<GetGuardrailInfoGuardrailsGuardrailIdInfoGetRequest>;
+export interface GetGuardrailInfoGuardrailsGuardrailIdInfoGetResponse {
+    body: unknown;
+}
+export declare const GetGuardrailInfoGuardrailsGuardrailIdInfoGetResponse: S.Schema<GetGuardrailInfoGuardrailsGuardrailIdInfoGetResponse>;
+export interface GetGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGetRequest {
+    guardrail_id: string;
+}
+export declare const GetGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGetRequest: S.Schema<GetGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGetRequest>;
+export type GuardrailSubmissionItemGuardrailInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GuardrailSubmissionItemGuardrailInfoMap: S.Schema<GuardrailSubmissionItemGuardrailInfoMap>;
+export type GuardrailSubmissionItemLitellmParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GuardrailSubmissionItemLitellmParamsMap: S.Schema<GuardrailSubmissionItemLitellmParamsMap>;
+export interface GuardrailSubmissionItem {
+    created_at?: string | null;
+    guardrail_id: string;
+    guardrail_info?: GuardrailSubmissionItemGuardrailInfoMap | null;
+    guardrail_name: string;
+    litellm_params?: GuardrailSubmissionItemLitellmParamsMap | null;
+    reviewed_at?: string | null;
+    status: string;
+    submitted_at?: string | null;
+    submitted_by_email?: string | null;
+    submitted_by_user_id?: string | null;
+    team_guardrail?: boolean;
+    team_id?: string | null;
+    updated_at?: string | null;
+}
+export declare const GuardrailSubmissionItem: S.Schema<GuardrailSubmissionItem>;
+export interface GetGuardrailsUsageDetailGuardrailsUsageDetailGuardrailIdRequest {
+    guardrail_id: string;
+    start_date?: string;
+    end_date?: string;
+}
+export declare const GetGuardrailsUsageDetailGuardrailsUsageDetailGuardrailIdRequest: S.Schema<GetGuardrailsUsageDetailGuardrailsUsageDetailGuardrailIdRequest>;
+export interface UsageChartPoint {
+    blocked: number;
+    date: string;
+    passed: number;
+    score?: number | null;
+}
+export declare const UsageChartPoint: S.Schema<UsageChartPoint>;
+export type UsageDetailResponseTimeSeriesList = Array<UsageChartPoint>;
+export declare const UsageDetailResponseTimeSeriesList: S.Schema<UsageDetailResponseTimeSeriesList>;
+export type UsageDetailResponseUsageUnitsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UsageDetailResponseUsageUnitsMap: S.Schema<UsageDetailResponseUsageUnitsMap>;
+export type UsageDetailResponseUsageUnitsByKeyValueMap = {
+    [key: string]: number | undefined;
+};
+export declare const UsageDetailResponseUsageUnitsByKeyValueMap: S.Schema<UsageDetailResponseUsageUnitsByKeyValueMap>;
+export type UsageDetailResponseUsageUnitsByKeyMap = {
+    [key: string]: UsageDetailResponseUsageUnitsByKeyValueMap | undefined;
+};
+export declare const UsageDetailResponseUsageUnitsByKeyMap: S.Schema<UsageDetailResponseUsageUnitsByKeyMap>;
+export type UsageDetailResponseUsageUnitsByTeamValueMap = {
+    [key: string]: number | undefined;
+};
+export declare const UsageDetailResponseUsageUnitsByTeamValueMap: S.Schema<UsageDetailResponseUsageUnitsByTeamValueMap>;
+export type UsageDetailResponseUsageUnitsByTeamMap = {
+    [key: string]: UsageDetailResponseUsageUnitsByTeamValueMap | undefined;
+};
+export declare const UsageDetailResponseUsageUnitsByTeamMap: S.Schema<UsageDetailResponseUsageUnitsByTeamMap>;
+export type UsageUnitsDailyPointUnitsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UsageUnitsDailyPointUnitsMap: S.Schema<UsageUnitsDailyPointUnitsMap>;
+export interface UsageUnitsDailyPoint {
+    date: string;
+    units: UsageUnitsDailyPointUnitsMap;
+}
+export declare const UsageUnitsDailyPoint: S.Schema<UsageUnitsDailyPoint>;
+export type UsageDetailResponseUsageUnitsDailyList = Array<UsageUnitsDailyPoint>;
+export declare const UsageDetailResponseUsageUnitsDailyList: S.Schema<UsageDetailResponseUsageUnitsDailyList>;
+export interface UsageDetailResponse {
+    avgLatency: number | null;
+    avgScore: number | null;
+    description: string | null;
+    failRate: number;
+    guardrail_id: string;
+    guardrail_name: string;
+    provider: string;
+    requestsEvaluated: number;
+    status: string;
+    time_series: UsageDetailResponseTimeSeriesList;
+    trend: string;
+    type: string;
+    usage_units: UsageDetailResponseUsageUnitsMap;
+    usage_units_by_key: UsageDetailResponseUsageUnitsByKeyMap;
+    usage_units_by_team: UsageDetailResponseUsageUnitsByTeamMap;
+    usage_units_daily: UsageDetailResponseUsageUnitsDailyList;
+}
+export declare const UsageDetailResponse: S.Schema<UsageDetailResponse>;
+export interface GetGuardrailsUsageLogsGuardrailsUsageLogRequest {
+    guardrail_id?: string;
+    policy_id?: string;
+    page?: number;
+    page_size?: number;
+    action?: string;
+    start_date?: string;
+    end_date?: string;
+}
+export declare const GetGuardrailsUsageLogsGuardrailsUsageLogRequest: S.Schema<GetGuardrailsUsageLogsGuardrailsUsageLogRequest>;
+export interface UsageLogEntry {
+    action: string;
+    id: string;
+    input_snippet: string | null;
+    latency_ms: number | null;
+    model: string | null;
+    output_snippet: string | null;
+    reason: string | null;
+    score: number | null;
+    timestamp: string;
+}
+export declare const UsageLogEntry: S.Schema<UsageLogEntry>;
+export type UsageLogsResponseLogsList = Array<UsageLogEntry>;
+export declare const UsageLogsResponseLogsList: S.Schema<UsageLogsResponseLogsList>;
+export interface UsageLogsResponse {
+    logs: UsageLogsResponseLogsList;
+    page: number;
+    page_size: number;
+    total: number;
+}
+export declare const UsageLogsResponse: S.Schema<UsageLogsResponse>;
+export interface GetGuardrailsUsageOverviewGuardrailsUsageOverviewRequest {
+    /** YYYY-MM-DD */
+    start_date?: string;
+    /** YYYY-MM-DD */
+    end_date?: string;
+}
+export declare const GetGuardrailsUsageOverviewGuardrailsUsageOverviewRequest: S.Schema<GetGuardrailsUsageOverviewGuardrailsUsageOverviewRequest>;
+export type UsageOverviewResponseChartList = Array<UsageChartPoint>;
+export declare const UsageOverviewResponseChartList: S.Schema<UsageOverviewResponseChartList>;
+export type UsageOverviewRowUsageUnitsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UsageOverviewRowUsageUnitsMap: S.Schema<UsageOverviewRowUsageUnitsMap>;
+export interface UsageOverviewRow {
+    avgLatency: number | null;
+    avgScore: number | null;
+    failRate: number;
+    id: string;
+    name: string;
+    provider: string;
+    requestsEvaluated: number;
+    status: string;
+    trend: string;
+    type: string;
+    usageUnits: UsageOverviewRowUsageUnitsMap;
+}
+export declare const UsageOverviewRow: S.Schema<UsageOverviewRow>;
+export type UsageOverviewResponseRowsList = Array<UsageOverviewRow>;
+export declare const UsageOverviewResponseRowsList: S.Schema<UsageOverviewResponseRowsList>;
+export type UsageOverviewResponseTotalUsageUnitsMap = {
+    [key: string]: number | undefined;
+};
+export declare const UsageOverviewResponseTotalUsageUnitsMap: S.Schema<UsageOverviewResponseTotalUsageUnitsMap>;
+export interface UsageOverviewResponse {
+    chart: UsageOverviewResponseChartList;
+    passRate: number;
+    rows: UsageOverviewResponseRowsList;
+    totalBlocked: number;
+    totalRequests: number;
+    totalUsageUnits: UsageOverviewResponseTotalUsageUnitsMap;
+}
+export declare const UsageOverviewResponse: S.Schema<UsageOverviewResponse>;
+export interface GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetRequest {
+}
+export declare const GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetRequest: S.Schema<GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetRequest>;
+export interface GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetResponse {
+    body: unknown;
+}
+export declare const GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetResponse: S.Schema<GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetResponse>;
+export interface GetMajorAirlinesGuardrailsUiMajorAirlinesGetRequest {
+}
+export declare const GetMajorAirlinesGuardrailsUiMajorAirlinesGetRequest: S.Schema<GetMajorAirlinesGuardrailsUiMajorAirlinesGetRequest>;
+export interface GetMajorAirlinesGuardrailsUiMajorAirlinesGetResponse {
+    body: unknown;
+}
+export declare const GetMajorAirlinesGuardrailsUiMajorAirlinesGetResponse: S.Schema<GetMajorAirlinesGuardrailsUiMajorAirlinesGetResponse>;
+export interface GetPoliciesUsageOverviewPoliciesUsageOverviewRequest {
+    /** YYYY-MM-DD */
+    start_date?: string;
+    /** YYYY-MM-DD */
+    end_date?: string;
+}
+export declare const GetPoliciesUsageOverviewPoliciesUsageOverviewRequest: S.Schema<GetPoliciesUsageOverviewPoliciesUsageOverviewRequest>;
+export interface GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetRequest {
+}
+export declare const GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetRequest: S.Schema<GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetRequest>;
+export interface GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetResponse {
+    body: unknown;
+}
+export declare const GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetResponse: S.Schema<GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetResponse>;
+export interface ListGuardrailsGuardrailsListGetRequest {
+}
+export declare const ListGuardrailsGuardrailsListGetRequest: S.Schema<ListGuardrailsGuardrailsListGetRequest>;
+export type GUARDRAILDEFINITIONLOCATION = "db" | "config";
+export declare const GUARDRAILDEFINITIONLOCATION: any;
+export type GuardrailInfoResponseGuardrailInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const GuardrailInfoResponseGuardrailInfoMap: S.Schema<GuardrailInfoResponseGuardrailInfoMap>;
+export type BaseLitellmParamsAdditionalProviderSpecificParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const BaseLitellmParamsAdditionalProviderSpecificParamsMap: S.Schema<BaseLitellmParamsAdditionalProviderSpecificParamsMap>;
+export type BaseLitellmParamsBlockedWordsList = Array<BlockedWord>;
+export declare const BaseLitellmParamsBlockedWordsList: S.Schema<BaseLitellmParamsBlockedWordsList>;
+export type BaseLitellmParamsCategoriesList = Array<ContentFilterCategoryConfig>;
+export declare const BaseLitellmParamsCategoriesList: S.Schema<BaseLitellmParamsCategoriesList>;
+export type BaseLitellmParamsDetectSecretsConfigMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const BaseLitellmParamsDetectSecretsConfigMap: S.Schema<BaseLitellmParamsDetectSecretsConfigMap>;
+export type BaseLitellmParamsExtraHeadersList = Array<string>;
+export declare const BaseLitellmParamsExtraHeadersList: S.Schema<BaseLitellmParamsExtraHeadersList>;
+export type BaseLitellmParamsOnSensitiveData = "block" | "route";
+export declare const BaseLitellmParamsOnSensitiveData: any;
+export type BaseLitellmParamsOnViolation = "warn" | "end_session";
+export declare const BaseLitellmParamsOnViolation: any;
+export type BaseLitellmParamsPatternsList = Array<ContentFilterPattern>;
+export declare const BaseLitellmParamsPatternsList: S.Schema<BaseLitellmParamsPatternsList>;
+/** Behavior when a guardrail endpoint is unreachable due to network errors. Implemented by guardrail='generic_guardrail_api', 'akto', 'vigil_guard', 'repelloai', 'headroom', and 'compresr'. 'fail_closed' raises an error (default). 'fail_open' logs a critical error and allows the request to proceed. */
+export type BaseLitellmParamsUnreachableFallback = "fail_closed" | "fail_open";
+export declare const BaseLitellmParamsUnreachableFallback: any;
+export interface BaseLitellmParams {
+    /** Additional provider-specific parameters for generic guardrail APIs */
+    additional_provider_specific_params?: BaseLitellmParamsAdditionalProviderSpecificParamsMap | null;
+    /** Base URL for the guardrail service API */
+    api_base?: string | null;
+    /** Optional custom API endpoint for Model Armor */
+    api_endpoint?: string | null;
+    /** API key for the guardrail service */
+    api_key?: string | null;
+    /** List of blocked words with individual actions */
+    blocked_words?: BaseLitellmParamsBlockedWordsList | null;
+    /** Path to YAML file containing blocked_words list */
+    blocked_words_file?: string | null;
+    /** List of prebuilt categories to enable (harmful_*, bias_*) */
+    categories?: BaseLitellmParamsCategoriesList | null;
+    /** Threshold configuration for Lakera guardrail categories */
+    category_thresholds?: LakeraCategoryThresholds | null;
+    /** Path to Google Cloud credentials JSON file or JSON string */
+    credentials?: string | null;
+    /** Python-like code containing the apply_guardrail function for custom guardrail logic */
+    custom_code?: string | null;
+    /** Whether the guardrail is enabled by default */
+    default_on?: boolean | null;
+    /** Configuration for detect-secrets guardrail */
+    detect_secrets_config?: BaseLitellmParamsDetectSecretsConfigMap | null;
+    /** For /v1/realtime sessions: automatically close the session after this many guardrail violations. */
+    end_session_after_n_fails?: number | null;
+    /** When True, guardrails only receive the latest message for the relevant role (e.g., newest user input pre-call, newest assistant output post-call) */
+    experimental_use_latest_role_message_only?: boolean | null;
+    /** Header names to forward from the client request to the guardrail (e.g. x-request-id). Only these headers' values are sent; others may be omitted or sent as [present]. Used by generic_guardrail_api (similar to MCP extra_headers). */
+    extra_headers?: BaseLitellmParamsExtraHeadersList | null;
+    /** Whether to fail the request if the guardrail encounters an error. Implemented by guardrail='model_armor', 'generic_guardrail_api' and 'crowdstrike_aidr'. True (default) raises the error. False logs a critical error and lets the request proceed, so only a valid guardrail response can block or modify it. */
+    fail_on_error?: boolean | null;
+    /** Name of the guardrail in guardrails.ai */
+    guard_name?: string | null;
+    /** Tag to use for keyword redaction */
+    keyword_redaction_tag?: string | null;
+    /** Google Cloud location/region (e.g., us-central1) */
+    location?: string | null;
+    /** Will mask request content if guardrail makes any changes */
+    mask_request_content?: boolean | null;
+    /** Will mask response content if guardrail makes any changes */
+    mask_response_content?: boolean | null;
+    /** Optional field if guardrail requires a 'model' parameter */
+    model?: string | null;
+    /** Action to take when sensitive data is detected. 'block' raises an exception (default behavior). 'route' reroutes the request to the model specified in sensitive_data_route_to_model. */
+    on_sensitive_data?: BaseLitellmParamsOnSensitiveData | (string & {}) | null;
+    /** For /v1/realtime sessions: 'warn' speaks the violation message and continues; 'end_session' speaks the message and closes the connection. */
+    on_violation?: BaseLitellmParamsOnViolation | (string & {}) | null;
+    /** When True, the guardrail only scans messages that have not already been scanned earlier in the same session (identified by litellm_session_id / session_id). Message content is hashed per session and cached; only the diff (new or edited messages) is sent to the guardrail provider on follow-up calls. Falls back to a full scan when the request has no session id or the cache is unavailable. Intended for blocking/detection guardrails; not applied when mask_request_content is set. */
+    only_scan_new_messages?: boolean | null;
+    /** Recipe for input (LLM request) */
+    pangea_input_recipe?: string | null;
+    /** Recipe for output (LLM response) */
+    pangea_output_recipe?: string | null;
+    /** Format string for pattern redaction (use {pattern_name} placeholder) */
+    pattern_redaction_format?: string | null;
+    /** List of patterns (prebuilt or custom regex) to detect */
+    patterns?: BaseLitellmParamsPatternsList | null;
+    /** The message the bot speaks aloud when a /v1/realtime guardrail fires. Falls back to violation_message_template if not set. */
+    realtime_violation_message?: string | null;
+    /** When True, this pre_call or post_call guardrail runs concurrently with other opted-in guardrails of the same hook, after the sequential guardrails have run. Use only for block-only guardrails that inspect and reject; do not enable it for guardrails that modify the request or response (e.g. PII masking or sensitive-data routing), since parallel runs share one snapshot and their mutations would race. */
+    run_in_parallel?: boolean | null;
+    /** For guardrail='model_armor': omit the raw Model Armor response from caller-facing errors and logs by default. Set False to restore verbose output. */
+    sanitize_error_detail?: boolean | null;
+    /** When True, unified guardrails only evaluate tool results, the untrusted data an agent feeds back into the model, and skip system, user, and assistant content. Intended for agent harnesses whose own prompt scaffolding is trusted but often trips prompt-attack detectors. */
+    scan_only_tool_results?: boolean | null;
+    /** When True, this pre_call guardrail always evaluates the request as it was before any guardrail in this hook ran, regardless of its position in the guardrails list -- so the YAML order of guardrails can never change whether this one blocks. Use only for block-only guardrails: any data this guardrail returns is discarded, same contract as run_in_parallel, since an earlier guardrail's masking must not be undone by this one. */
+    scan_raw_request?: boolean | null;
+    /** Model to route requests to when sensitive data is detected and on_sensitive_data='route'. This is typically an on-premise model for data privacy. The routing decision persists for the entire session. */
+    sensitive_data_route_to_model?: string | null;
+    /** Minimum severity to block (high, medium, low) */
+    severity_threshold?: string | null;
+    /** When True, unified guardrails skip system-role messages when building evaluation inputs (texts and structured_messages). When False, system messages are included even if litellm_settings sets a global skip. When None, use the global litellm.skip_system_message_in_guardrail setting. For Anthropic /v1/messages, the flag applies only to the trusted top-level system prompt. In-sequence system entries are untrusted client input and remain in texts and structured_messages. */
+    skip_system_message_in_guardrail?: boolean | null;
+    /** When True, unified guardrails skip tool-role messages when building evaluation inputs (texts and structured_messages). When False, tool messages are included even if litellm_settings sets a global skip. When None, use the global litellm.skip_tool_message_in_guardrail setting. */
+    skip_tool_message_in_guardrail?: boolean | null;
+    /** Implemented by guardrail='model_armor'. When True, attachment references that carry no inline bytes (file_id, gs://, or http(s) URLs) pass through unscanned instead of blocking, while fail_on_error still governs real Model Armor API errors. Default False blocks them. */
+    skip_unscannable_attachments?: boolean | null;
+    /** When True (default), after sensitive data is detected and routed, all subsequent requests in the same session will continue routing to the same model. */
+    sticky_session_routing?: boolean | null;
+    /** The ID of your Model Armor template */
+    template_id?: string | null;
+    /** Per-request timeout for the guardrail provider API call (seconds). Accepts int, float, or numeric string; coerced to float on load. Each guardrail handler chooses its own default when unset. */
+    timeout?: number | null;
+    /** Behavior when a guardrail endpoint is unreachable due to network errors. Implemented by guardrail='generic_guardrail_api', 'akto', 'vigil_guard', 'repelloai', 'headroom', and 'compresr'. 'fail_closed' raises an error (default). 'fail_open' logs a critical error and allows the request to proceed. */
+    unreachable_fallback?: BaseLitellmParamsUnreachableFallback | (string & {});
+    /** Custom message when a guardrail blocks an action. Supports placeholders like {tool_name}, {rule_id}, and {default_message}. */
+    violation_message_template?: string | null;
+}
+export declare const BaseLitellmParams: S.Schema<BaseLitellmParams>;
+export interface GuardrailInfoResponse {
+    created_at?: string | null;
+    guardrail_definition_location?: GUARDRAILDEFINITIONLOCATION;
+    guardrail_id?: string | null;
+    guardrail_info?: GuardrailInfoResponseGuardrailInfoMap | null;
+    guardrail_name: string;
+    litellm_params?: BaseLitellmParams | null;
+    updated_at?: string | null;
+}
+export declare const GuardrailInfoResponse: S.Schema<GuardrailInfoResponse>;
+export type ListGuardrailsResponseGuardrailsList = Array<GuardrailInfoResponse>;
+export declare const ListGuardrailsResponseGuardrailsList: S.Schema<ListGuardrailsResponseGuardrailsList>;
+export interface ListGuardrailsResponse {
+    guardrails: ListGuardrailsResponseGuardrailsList;
+}
+export declare const ListGuardrailsResponse: S.Schema<ListGuardrailsResponse>;
+export interface ListGuardrailSubmissionsGuardrailsSubmissionsGetRequest {
+    status?: string;
+    team_id?: string;
+    search?: string;
+}
+export declare const ListGuardrailSubmissionsGuardrailsSubmissionsGetRequest: S.Schema<ListGuardrailSubmissionsGuardrailsSubmissionsGetRequest>;
+export type ListGuardrailSubmissionsResponseSubmissionsList = Array<GuardrailSubmissionItem>;
+export declare const ListGuardrailSubmissionsResponseSubmissionsList: S.Schema<ListGuardrailSubmissionsResponseSubmissionsList>;
+export interface GuardrailSubmissionSummary {
+    active: number;
+    pending_review: number;
+    rejected: number;
+    total: number;
+}
+export declare const GuardrailSubmissionSummary: S.Schema<GuardrailSubmissionSummary>;
+export interface ListGuardrailSubmissionsResponse {
+    submissions: ListGuardrailSubmissionsResponseSubmissionsList;
+    summary: GuardrailSubmissionSummary;
+}
+export declare const ListGuardrailSubmissionsResponse: S.Schema<ListGuardrailSubmissionsResponse>;
+export interface ListGuardrailsV2V2GuardrailsListGetRequest {
+}
+export declare const ListGuardrailsV2V2GuardrailsListGetRequest: S.Schema<ListGuardrailsV2V2GuardrailsListGetRequest>;
+export type PatchGuardrailGuardrailsGuardrailIdPatchRequestGuardrailInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PatchGuardrailGuardrailsGuardrailIdPatchRequestGuardrailInfoMap: S.Schema<PatchGuardrailGuardrailsGuardrailIdPatchRequestGuardrailInfoMap>;
+export interface PatchGuardrailGuardrailsGuardrailIdPatchRequest {
+    guardrail_id: string;
+    guardrail_info?: PatchGuardrailGuardrailsGuardrailIdPatchRequestGuardrailInfoMap | null;
+    guardrail_name?: string | null;
+    litellm_params?: BaseLitellmParams | null;
+}
+export declare const PatchGuardrailGuardrailsGuardrailIdPatchRequest: S.Schema<PatchGuardrailGuardrailsGuardrailIdPatchRequest>;
+export interface PatchGuardrailGuardrailsGuardrailIdPatchResponse {
+    body: unknown;
+}
+export declare const PatchGuardrailGuardrailsGuardrailIdPatchResponse: S.Schema<PatchGuardrailGuardrailsGuardrailIdPatchResponse>;
+export type PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestRequestDataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestRequestDataMap: S.Schema<PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestRequestDataMap>;
+export type PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestTestInputMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestTestInputMap: S.Schema<PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestTestInputMap>;
+export interface PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequest {
+    custom_code: string;
+    input_type?: string;
+    request_data?: PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestRequestDataMap | null;
+    test_input: PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequestTestInputMap;
+}
+export declare const PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequest: S.Schema<PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequest>;
+export type TestCustomCodeGuardrailResponseResultMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const TestCustomCodeGuardrailResponseResultMap: S.Schema<TestCustomCodeGuardrailResponseResultMap>;
+/** Response model for testing custom code guardrails. */
+export interface TestCustomCodeGuardrailResponse {
+    error?: string | null;
+    error_type?: string | null;
+    result?: TestCustomCodeGuardrailResponseResultMap | null;
+    success: boolean;
+}
+export declare const TestCustomCodeGuardrailResponse: S.Schema<TestCustomCodeGuardrailResponse>;
+export type RegisterGuardrailGuardrailsRegisterPostRequestGuardrailInfoMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const RegisterGuardrailGuardrailsRegisterPostRequestGuardrailInfoMap: S.Schema<RegisterGuardrailGuardrailsRegisterPostRequestGuardrailInfoMap>;
+export type RegisterGuardrailGuardrailsRegisterPostRequestLitellmParamsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const RegisterGuardrailGuardrailsRegisterPostRequestLitellmParamsMap: S.Schema<RegisterGuardrailGuardrailsRegisterPostRequestLitellmParamsMap>;
+export interface RegisterGuardrailGuardrailsRegisterPostRequest {
+    guardrail_info?: RegisterGuardrailGuardrailsRegisterPostRequestGuardrailInfoMap | null;
+    guardrail_name: string;
+    litellm_params: RegisterGuardrailGuardrailsRegisterPostRequestLitellmParamsMap;
+    team_id?: string | null;
+}
+export declare const RegisterGuardrailGuardrailsRegisterPostRequest: S.Schema<RegisterGuardrailGuardrailsRegisterPostRequest>;
+export interface RegisterGuardrailResponse {
+    guardrail_id: string;
+    guardrail_name: string;
+    status: string;
+    submitted_at?: string | null;
+}
+export declare const RegisterGuardrailResponse: S.Schema<RegisterGuardrailResponse>;
+export interface RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostRequest {
+    guardrail_id: string;
+}
+export declare const RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostRequest: S.Schema<RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostRequest>;
+export interface RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostResponse {
+    body: unknown;
+}
+export declare const RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostResponse: S.Schema<RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostResponse>;
+export interface UpdateGuardrailGuardrailsGuardrailIdPutRequest {
+    guardrail_id: string;
+    guardrail: Guardrail;
+}
+export declare const UpdateGuardrailGuardrailsGuardrailIdPutRequest: S.Schema<UpdateGuardrailGuardrailsGuardrailIdPutRequest>;
+export interface UpdateGuardrailGuardrailsGuardrailIdPutResponse {
+    body: unknown;
+}
+export declare const UpdateGuardrailGuardrailsGuardrailIdPutResponse: S.Schema<UpdateGuardrailGuardrailsGuardrailIdPutResponse>;
+export type ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequestBodyMap = {
+    [key: string]: string | undefined;
+};
+export declare const ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequestBodyMap: S.Schema<ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequestBodyMap>;
+export interface ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequest {
+    body: ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequestBodyMap;
+}
+export declare const ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequest: S.Schema<ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequest>;
+export interface ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostResponse {
+    body: unknown;
+}
+export declare const ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostResponse: S.Schema<ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostResponse>;
+export type ApplyGuardrailApplyGuardrailPostError = UnprocessableEntity | LitellmOpError;
+/** Apply Guardrail Apply a guardrail to text input and return the processed result. This endpoint allows testing guardrails by applying them to custom text inputs. */
+export declare const applyGuardrailApplyGuardrailPost: API.OperationMethod<ApplyGuardrailApplyGuardrailPostRequest, ApplyGuardrailResponse, ApplyGuardrailApplyGuardrailPostError, LitellmOpContext>;
+export type ApplyGuardrailGuardrailsApplyGuardrailPostError = UnprocessableEntity | LitellmOpError;
+/** Apply Guardrail Apply a guardrail to text input and return the processed result. This endpoint allows testing guardrails by applying them to custom text inputs. */
+export declare const applyGuardrailGuardrailsApplyGuardrailPost: API.OperationMethod<ApplyGuardrailGuardrailsApplyGuardrailPostRequest, ApplyGuardrailResponse, ApplyGuardrailGuardrailsApplyGuardrailPostError, LitellmOpContext>;
+export type ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostError = UnprocessableEntity | LitellmOpError;
+/** Approve Guardrail Submission Approve a pending guardrail submission: set status to active and initialize in memory (admin only). */
+export declare const approveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePost: API.OperationMethod<ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostRequest, ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostResponse, ApproveGuardrailSubmissionGuardrailsSubmissionsGuardrailIdApprovePostError, LitellmOpContext>;
+export type CreateGuardrailGuardrailsPostError = UnprocessableEntity | LitellmOpError;
+/** Create Guardrail Create a new guardrail 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X POST "http://localhost:4000/guardrails" \ -H "Authorization: Bearer <your_api_key>" \ -H "Content-Type: application/json" \ -d '{ "guardrail": { "guardrail_name": "my-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "DRAFT", "default_on": true }, "guardrail_info": { "description": "Bedrock content moderation guardrail" } } }' ``` Example Response: ```json { "guardrail_id": "123e4567-e89b-12d3-a456-426614174000", "guardrail_name": "my-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "DRAFT", "default_on": true }, "guardrail_info": { "description": "Bedrock content moderation guardrail" }, "created_at": "2023-11-09T12:34:56.789Z", "updated_at": "2023-11-09T12:34:56.789Z" } ``` */
+export declare const createGuardrailGuardrailsPost: API.OperationMethod<CreateGuardrailGuardrailsPostRequest, CreateGuardrailGuardrailsPostResponse, CreateGuardrailGuardrailsPostError, LitellmOpContext>;
+export type DeleteGuardrailGuardrailsGuardrailIdDeleteError = UnprocessableEntity | LitellmOpError;
+/** Delete Guardrail Delete a guardrail 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X DELETE "http://localhost:4000/guardrails/123e4567-e89b-12d3-a456-426614174000" \ -H "Authorization: Bearer <your_api_key>" ``` Example Response: ```json { "message": "Guardrail 123e4567-e89b-12d3-a456-426614174000 deleted successfully" } ``` */
+export declare const deleteGuardrailGuardrailsGuardrailIdDelete: API.OperationMethod<DeleteGuardrailGuardrailsGuardrailIdDeleteRequest, DeleteGuardrailGuardrailsGuardrailIdDeleteResponse, DeleteGuardrailGuardrailsGuardrailIdDeleteError, LitellmOpContext>;
+export type GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetError = UnprocessableEntity | LitellmOpError;
+/** Get Category Yaml Get the YAML or JSON content for a specific content filter category. Args: category_name: The name of the category (e.g., "bias_gender", "harmful_self_harm") Returns: The raw YAML or JSON content of the category file with file type indicator */
+export declare const getCategoryYamlGuardrailsUiCategoryYamlCategoryNameGet: API.OperationMethod<GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetRequest, GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetResponse, GetCategoryYamlGuardrailsUiCategoryYamlCategoryNameGetError, LitellmOpContext>;
+export type GetGuardrailInfoGuardrailsGuardrailIdGetError = UnprocessableEntity | LitellmOpError;
+/** Get Guardrail Info Get detailed information about a specific guardrail by ID 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X GET "http://localhost:4000/guardrails/123e4567-e89b-12d3-a456-426614174000/info" \ -H "Authorization: Bearer <your_api_key>" ``` Example Response: ```json { "guardrail_id": "123e4567-e89b-12d3-a456-426614174000", "guardrail_name": "my-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "DRAFT", "default_on": true }, "guardrail_info": { "description": "Bedrock content moderation guardrail" }, "created_at": "2023-11-09T12:34:56.789Z", "updated_at": "2023-11-09T12:34:56.789Z" } ``` */
+export declare const getGuardrailInfoGuardrailsGuardrailIdGet: API.OperationMethod<GetGuardrailInfoGuardrailsGuardrailIdGetRequest, GetGuardrailInfoGuardrailsGuardrailIdGetResponse, GetGuardrailInfoGuardrailsGuardrailIdGetError, LitellmOpContext>;
+export type GetGuardrailInfoGuardrailsGuardrailIdInfoGetError = UnprocessableEntity | LitellmOpError;
+/** Get Guardrail Info Get detailed information about a specific guardrail by ID 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X GET "http://localhost:4000/guardrails/123e4567-e89b-12d3-a456-426614174000/info" \ -H "Authorization: Bearer <your_api_key>" ``` Example Response: ```json { "guardrail_id": "123e4567-e89b-12d3-a456-426614174000", "guardrail_name": "my-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "DRAFT", "default_on": true }, "guardrail_info": { "description": "Bedrock content moderation guardrail" }, "created_at": "2023-11-09T12:34:56.789Z", "updated_at": "2023-11-09T12:34:56.789Z" } ``` */
+export declare const getGuardrailInfoGuardrailsGuardrailIdInfoGet: API.OperationMethod<GetGuardrailInfoGuardrailsGuardrailIdInfoGetRequest, GetGuardrailInfoGuardrailsGuardrailIdInfoGetResponse, GetGuardrailInfoGuardrailsGuardrailIdInfoGetError, LitellmOpContext>;
+export type GetGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGetError = UnprocessableEntity | LitellmOpError;
+/** Get Guardrail Submission Get a single guardrail submission by id. Non-admins may only access submissions for teams they belong to. */
+export declare const getGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGet: API.OperationMethod<GetGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGetRequest, GuardrailSubmissionItem, GetGuardrailSubmissionGuardrailsSubmissionsGuardrailIdGetError, LitellmOpContext>;
+export type GetGuardrailsUsageDetailGuardrailsUsageDetailGuardrailIdError = UnprocessableEntity | LitellmOpError;
+/** Guardrails Usage Detail Return single guardrail usage metrics and time series. */
+export declare const getGuardrailsUsageDetailGuardrailsUsageDetailGuardrailId: API.OperationMethod<GetGuardrailsUsageDetailGuardrailsUsageDetailGuardrailIdRequest, UsageDetailResponse, GetGuardrailsUsageDetailGuardrailsUsageDetailGuardrailIdError, LitellmOpContext>;
+export type GetGuardrailsUsageLogsGuardrailsUsageLogError = UnprocessableEntity | LitellmOpError;
+/** Guardrails Usage Logs Return paginated run logs for a guardrail (or policy) from SpendLogs via index. */
+export declare const getGuardrailsUsageLogsGuardrailsUsageLog: API.OperationMethod<GetGuardrailsUsageLogsGuardrailsUsageLogRequest, UsageLogsResponse, GetGuardrailsUsageLogsGuardrailsUsageLogError, LitellmOpContext>;
+export type GetGuardrailsUsageOverviewGuardrailsUsageOverviewError = UnprocessableEntity | LitellmOpError;
+/** Guardrails Usage Overview Return guardrail performance overview for the dashboard. */
+export declare const getGuardrailsUsageOverviewGuardrailsUsageOverview: API.OperationMethod<GetGuardrailsUsageOverviewGuardrailsUsageOverviewRequest, UsageOverviewResponse, GetGuardrailsUsageOverviewGuardrailsUsageOverviewError, LitellmOpContext>;
+export type GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetError = LitellmOpError;
+/** Get Guardrail Ui Settings Get the UI settings for the guardrails Returns: - Supported entities for guardrails - Supported modes for guardrails - PII entity categories for UI organization - Content filter settings (patterns and categories) */
+export declare const getGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGet: API.OperationMethod<GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetRequest, GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetResponse, GetGuardrailUiSettingsGuardrailsUiAddGuardrailSettingsGetError, LitellmOpContext>;
+export type GetMajorAirlinesGuardrailsUiMajorAirlinesGetError = LitellmOpError;
+/** Get Major Airlines Get the major airlines list from IATA (competitor intent, airline type). Returns airline id, match variants (pipe-separated), and tags. */
+export declare const getMajorAirlinesGuardrailsUiMajorAirlinesGet: API.OperationMethod<GetMajorAirlinesGuardrailsUiMajorAirlinesGetRequest, GetMajorAirlinesGuardrailsUiMajorAirlinesGetResponse, GetMajorAirlinesGuardrailsUiMajorAirlinesGetError, LitellmOpContext>;
+export type GetPoliciesUsageOverviewPoliciesUsageOverviewError = UnprocessableEntity | LitellmOpError;
+/** Policies Usage Overview Return policy performance overview for the dashboard. */
+export declare const getPoliciesUsageOverviewPoliciesUsageOverview: API.OperationMethod<GetPoliciesUsageOverviewPoliciesUsageOverviewRequest, UsageOverviewResponse, GetPoliciesUsageOverviewPoliciesUsageOverviewError, LitellmOpContext>;
+export type GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetError = LitellmOpError;
+/** Get Provider Specific Params Get provider-specific parameters for different guardrail types. Returns a dictionary mapping guardrail providers to their specific parameters, including parameter names, descriptions, and whether they are required. Example Response: ```json { "bedrock": { "guardrailIdentifier": { "description": "The ID of your guardrail on Bedrock", "required": true, "type": null }, "guardrailVersion": { "description": "The version of your Bedrock guardrail (e.g., DRAFT or version number)", "required": true, "type": null } }, "azure_content_safety_text_moderation": { "api_key": { "description": "API key for the Azure Content Safety Text Moderation guardrail", "required": false, "type": null }, "optional_params": { "description": "Optional parameters for the Azure Content Safety Text Moderation guardrail", "required": true, "type": "nested", "fields": { "severity_threshold": { "description": "Severity threshold for the Azure Content Safety Text Moderation guardrail across all categories", "required": false, "type": null }, "categories": { "description": "Categories to scan for the Azure Content Safety Text Moderation guardrail", "required": false, "type": "multiselect", "options": ["Hate", "SelfHarm", "Sexual", "Violence"], "default_value": None } } } } } ``` */
+export declare const getProviderSpecificParamsGuardrailsUiProviderSpecificParamsGet: API.OperationMethod<GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetRequest, GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetResponse, GetProviderSpecificParamsGuardrailsUiProviderSpecificParamsGetError, LitellmOpContext>;
+export type ListGuardrailsGuardrailsListGetError = LitellmOpError;
+/** List Guardrails List the guardrails that are available on the proxy server 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X GET "http://localhost:4000/guardrails/list" -H "Authorization: Bearer <your_api_key>" ``` Example Response: ```json { "guardrails": [ { "guardrail_name": "bedrock-pre-guard", "guardrail_info": { "params": [ { "name": "toxicity_score", "type": "float", "description": "Score between 0-1 indicating content toxicity level" }, { "name": "pii_detection", "type": "boolean" } ] } } ] } ``` */
+export declare const listGuardrailsGuardrailsListGet: API.OperationMethod<ListGuardrailsGuardrailsListGetRequest, ListGuardrailsResponse, ListGuardrailsGuardrailsListGetError, LitellmOpContext>;
+export type ListGuardrailSubmissionsGuardrailsSubmissionsGetError = UnprocessableEntity | LitellmOpError;
+/** List Guardrail Submissions List team guardrail submissions. Returns only guardrails with a team_id. Admins see all submissions. Non-admin users see submissions for teams they are a member of. Status values: pending_review (team-registered, awaiting approval), active (approved), rejected. Optional filters: - status: pending_review | active | rejected - team_id: filter by specific team (non-admins must be a member of that team) - search: name/description */
+export declare const listGuardrailSubmissionsGuardrailsSubmissionsGet: API.OperationMethod<ListGuardrailSubmissionsGuardrailsSubmissionsGetRequest, ListGuardrailSubmissionsResponse, ListGuardrailSubmissionsGuardrailsSubmissionsGetError, LitellmOpContext>;
+export type ListGuardrailsV2V2GuardrailsListGetError = LitellmOpError;
+/** List Guardrails V2 List the guardrails that are available in the database using GuardrailRegistry 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X GET "http://localhost:4000/v2/guardrails/list" -H "Authorization: Bearer <your_api_key>" ``` Example Response: ```json { "guardrails": [ { "guardrail_id": "123e4567-e89b-12d3-a456-426614174000", "guardrail_name": "my-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "DRAFT", "default_on": true }, "guardrail_info": { "description": "Bedrock content moderation guardrail" } } ] } ``` */
+export declare const listGuardrailsV2V2GuardrailsListGet: API.OperationMethod<ListGuardrailsV2V2GuardrailsListGetRequest, ListGuardrailsResponse, ListGuardrailsV2V2GuardrailsListGetError, LitellmOpContext>;
+export type PatchGuardrailGuardrailsGuardrailIdPatchError = UnprocessableEntity | LitellmOpError;
+/** Patch Guardrail Partially update an existing guardrail 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) This endpoint allows updating specific fields of a guardrail without sending the entire object. Only the following fields can be updated: - guardrail_name: The name of the guardrail - default_on: Whether the guardrail is enabled by default - guardrail_info: Additional information about the guardrail Example Request: ```bash curl -X PATCH "http://localhost:4000/guardrails/123e4567-e89b-12d3-a456-426614174000" \ -H "Authorization: Bearer <your_api_key>" \ -H "Content-Type: application/json" \ -d '{ "guardrail_name": "updated-name", "default_on": true, "guardrail_info": { "description": "Updated description" } }' ``` Example Response: ```json { "guardrail_id": "123e4567-e89b-12d3-a456-426614174000", "guardrail_name": "updated-name", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "DRAFT", "default_on": true }, "guardrail_info": { "description": "Updated description" }, "created_at": "2023-11-09T12:34:56.789Z", "updated_at": "2023-11-09T14:22:33.456Z" } ``` */
+export declare const patchGuardrailGuardrailsGuardrailIdPatch: API.OperationMethod<PatchGuardrailGuardrailsGuardrailIdPatchRequest, PatchGuardrailGuardrailsGuardrailIdPatchResponse, PatchGuardrailGuardrailsGuardrailIdPatchError, LitellmOpContext>;
+export type PostTestCustomCodeGuardrailGuardrailsTestCustomCodeError = UnprocessableEntity | LitellmOpError;
+/** Test Custom Code Guardrail Test custom code guardrail logic without creating a guardrail. This endpoint allows admins to experiment with custom code guardrails by: 1. Compiling the provided code in a sandbox 2. Executing the apply_guardrail function with test input 3. Returning the result (allow/block/modify) 👉 [Custom Code Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/custom_code_guardrail) Example Request: ```bash curl -X POST "http://localhost:4000/guardrails/test_custom_code" \ -H "Authorization: Bearer <your_api_key>" \ -H "Content-Type: application/json" \ -d '{ "custom_code": "def apply_guardrail(inputs, request_data, input_type):\n for text in inputs[\"texts\"]:\n if regex_match(text, r\"\\d{3}-\\d{2}-\\d{4}\"):\n return block(\"SSN detected\")\n return allow()", "test_input": { "texts": ["My SSN is 123-45-6789"] }, "input_type": "request" }' ``` Example Success Response (blocked): ```json { "success": true, "result": { "action": "block", "reason": "SSN detected" }, "error": null, "error_type": null } ``` Example Success Response (allowed): ```json { "success": true, "result": { "action": "allow" }, "error": null, "error_type": null } ``` Example Success Response (modified): ```json { "success": true, "result": { "action": "modify", "texts": ["My SSN is [REDACTED]"] }, "error": null, "error_type": null } ``` Example Error Response (compilation error): ```json { "success": false, "result": null, "error": "Syntax error in custom code: invalid syntax (<guardrail>, line 1)", "error_type": "compilation" } ``` */
+export declare const postTestCustomCodeGuardrailGuardrailsTestCustomCode: API.OperationMethod<PostTestCustomCodeGuardrailGuardrailsTestCustomCodeRequest, TestCustomCodeGuardrailResponse, PostTestCustomCodeGuardrailGuardrailsTestCustomCodeError, LitellmOpContext>;
+export type RegisterGuardrailGuardrailsRegisterPostError = UnprocessableEntity | LitellmOpError;
+/** Register Guardrail Register a guardrail for onboarding (team submission). Accepts a guardrail config in the [Generic Guardrail API](https://docs.litellm.ai/docs/adding_provider/generic_guardrail_api) format. The submission is stored with status `pending_review` until an admin approves it. */
+export declare const registerGuardrailGuardrailsRegisterPost: API.OperationMethod<RegisterGuardrailGuardrailsRegisterPostRequest, RegisterGuardrailResponse, RegisterGuardrailGuardrailsRegisterPostError, LitellmOpContext>;
+export type RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostError = UnprocessableEntity | LitellmOpError;
+/** Reject Guardrail Submission Reject a guardrail submission (admin only). */
+export declare const rejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPost: API.OperationMethod<RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostRequest, RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostResponse, RejectGuardrailSubmissionGuardrailsSubmissionsGuardrailIdRejectPostError, LitellmOpContext>;
+export type UpdateGuardrailGuardrailsGuardrailIdPutError = UnprocessableEntity | LitellmOpError;
+/** Update Guardrail Update an existing guardrail 👉 [Guardrail docs](https://docs.litellm.ai/docs/proxy/guardrails/quick_start) Example Request: ```bash curl -X PUT "http://localhost:4000/guardrails/123e4567-e89b-12d3-a456-426614174000" \ -H "Authorization: Bearer <your_api_key>" \ -H "Content-Type: application/json" \ -d '{ "guardrail": { "guardrail_name": "updated-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "1.0", "default_on": true }, "guardrail_info": { "description": "Updated Bedrock content moderation guardrail" } } }' ``` Example Response: ```json { "guardrail_id": "123e4567-e89b-12d3-a456-426614174000", "guardrail_name": "updated-bedrock-guard", "litellm_params": { "guardrail": "bedrock", "mode": "pre_call", "guardrailIdentifier": "ff6ujrregl1q", "guardrailVersion": "1.0", "default_on": true }, "guardrail_info": { "description": "Updated Bedrock content moderation guardrail" }, "created_at": "2023-11-09T12:34:56.789Z", "updated_at": "2023-11-09T13:45:12.345Z" } ``` */
+export declare const updateGuardrailGuardrailsGuardrailIdPut: API.OperationMethod<UpdateGuardrailGuardrailsGuardrailIdPutRequest, UpdateGuardrailGuardrailsGuardrailIdPutResponse, UpdateGuardrailGuardrailsGuardrailIdPutError, LitellmOpContext>;
+export type ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostError = UnprocessableEntity | LitellmOpError;
+/** Validate Blocked Words File Validate a blocked_words YAML file content. Args: request: Dictionary with 'file_content' key containing the YAML string Returns: Dictionary with 'valid' boolean and either 'message'/'errors' depending on result Example Request: ```json { "file_content": "blocked_words:\n - keyword: \"test\"\n action: \"BLOCK\"" } ``` Example Success Response: ```json { "valid": true, "message": "Valid YAML file with 2 blocked words" } ``` Example Error Response: ```json { "valid": false, "errors": ["Entry 0: missing 'action' field"] } ``` */
+export declare const validateBlockedWordsFileGuardrailsValidateBlockedWordsFilePost: API.OperationMethod<ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostRequest, ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostResponse, ValidateBlockedWordsFileGuardrailsValidateBlockedWordsFilePostError, LitellmOpContext>;
+//# sourceMappingURL=guardrails.d.ts.map