Governance Controls

from confident_ai import ConfidentAI
from confident_ai.organization import GovernanceControlActivity
from confident_ai.organization import GovernanceControlType

client = ConfidentAI()

result = client.organization.list_governance_controls(
    type=GovernanceControlType.RUNTIME,
    activity=GovernanceControlActivity.ACTIVE,
    page=1,
    page_size=25,
)

result = await client.organization.a_list_governance_controls(...)

import { ConfidentAI } from "confident-ai";
import {
  GovernanceControlActivity,
  GovernanceControlType,
} from "confident-ai/organization";

const client = new ConfidentAI();

const result = await client.organization.listGovernanceControls(
  {
    type: GovernanceControlType.RUNTIME,
    activity: GovernanceControlActivity.ACTIVE,
    page: 1,
    pageSize: 25
  },
);

from confident_ai import ConfidentAI
from confident_ai.organization import CreatableGovernanceControlType
from confident_ai.common import FilterSet
from confident_ai.organization import GovernanceControlAggregation
from confident_ai.organization import GovernanceControlDataModel
from confident_ai.organization import GovernanceControlExtraQueryParams
from confident_ai.organization import GovernanceControlMetricDataCategory
from confident_ai.organization import GovernanceControlPreDeploymentConfig
from confident_ai.organization import GovernanceControlPreDeploymentWindow
from confident_ai.organization import GovernanceControlRuntimeConfig
from confident_ai.organization import GovernanceControlSeverity
from confident_ai.organization import GovernanceControlThresholdDirection
from confident_ai.organization import GovernanceControlThresholdSettings

client = ConfidentAI()

result = client.organization.create_governance_control(
    name="Production error rate under 2%",
    type=CreatableGovernanceControlType.RUNTIME,
    description="Traces must error on fewer than 2% of production requests over the last day.",
    runtime_config=GovernanceControlRuntimeConfig(
        data_model=GovernanceControlDataModel.TRACE,
        aggregation=GovernanceControlAggregation.AVG_COST,
        threshold_settings=GovernanceControlThresholdSettings(
            value=0.02,
            direction=GovernanceControlThresholdDirection.ABOVE
        ),
        extra_query_params=GovernanceControlExtraQueryParams(
            category=GovernanceControlMetricDataCategory.TRACE
        ),
        filters=FilterSet(
            operator="AND",
            groups=[]
        ),
        severity=GovernanceControlSeverity.CRITICAL
    ),
    pre_deployment_config=GovernanceControlPreDeploymentConfig(
        identifier="pre-release",
        window=GovernanceControlPreDeploymentWindow(
            days=30
        ),
        official_only=False,
        filters=FilterSet(
            operator="AND",
            groups=[]
        ),
        severity=GovernanceControlSeverity.CRITICAL
    ),
    governance_policy_id="<GOVERNANCE-POLICY-ID>",
)

result = await client.organization.a_create_governance_control(...)

import { ConfidentAI } from "confident-ai";
import {
  CreatableGovernanceControlType,
  GovernanceControlAggregation,
  GovernanceControlDataModel,
  GovernanceControlMetricDataCategory,
  GovernanceControlSeverity,
  GovernanceControlThresholdDirection,
} from "confident-ai/organization";

const client = new ConfidentAI();

const result = await client.organization.createGovernanceControl(
  "Production error rate under 2%",
  CreatableGovernanceControlType.RUNTIME,
  {
    description: "Traces must error on fewer than 2% of production requests over the last day.",
    runtimeConfig: {
      dataModel: GovernanceControlDataModel.TRACE,
      aggregation: GovernanceControlAggregation.AVG_COST,
      thresholdSettings: {
          value: 0.02,
          direction: GovernanceControlThresholdDirection.ABOVE
        },
      extraQueryParams: {
          category: GovernanceControlMetricDataCategory.TRACE
        },
      filters: {
          operator: "AND",
          groups: []
        },
      severity: GovernanceControlSeverity.CRITICAL
    },
    preDeploymentConfig: {
      identifier: "pre-release",
      window: {
          days: 30
        },
      officialOnly: false,
      filters: {
          operator: "AND",
          groups: []
        },
      severity: GovernanceControlSeverity.CRITICAL
    },
    governancePolicyId: "<GOVERNANCE-POLICY-ID>"
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.organization.get_governance_control(
    control_id="<GOVERNANCE-CONTROL-ID>",
)

result = await client.organization.a_get_governance_control(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.organization.getGovernanceControl(
  "<GOVERNANCE-CONTROL-ID>",
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.organization.update_governance_control(
    control_id="<GOVERNANCE-CONTROL-ID>",
    name="Production error rate under 1%",
    description="Traces must error on fewer than 1% of production requests over the last day.",
)

result = await client.organization.a_update_governance_control(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.organization.updateGovernanceControl(
  "<GOVERNANCE-CONTROL-ID>",
  {
    name: "Production error rate under 1%",
    description: "Traces must error on fewer than 1% of production requests over the last day."
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.organization.delete_governance_control(
    control_id="<GOVERNANCE-CONTROL-ID>",
)

result = await client.organization.a_delete_governance_control(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.organization.deleteGovernanceControl(
  "<GOVERNANCE-CONTROL-ID>",
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.organization.assess_governance_control(
    control_id="<GOVERNANCE-CONTROL-ID>",
)

result = await client.organization.a_assess_governance_control(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.organization.assessGovernanceControl(
  "<GOVERNANCE-CONTROL-ID>",
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.organization.list_governance_control_assessments(
    control_id="<GOVERNANCE-CONTROL-ID>",
    version="00.00.02",
    page=1,
    page_size=25,
)

result = await client.organization.a_list_governance_control_assessments(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.organization.listGovernanceControlAssessments(
  "<GOVERNANCE-CONTROL-ID>",
  { version: "00.00.02", page: 1, pageSize: 25 },
);

class AssessGovernanceControlResult:
    projects_assessed: int = Field(alias="projectsAssessed")
    assessments: int
    status_counts: Dict[str, int] = Field(alias="statusCounts")

interface AssessGovernanceControlResult {
  projectsAssessed: number;
  assessments: number;
  statusCounts: Record<string, number>;
}

class CreatableGovernanceControlType(Enum):
    RUNTIME = "RUNTIME"
    PRE_DEPLOYMENT_EVALS = "PRE_DEPLOYMENT_EVALS"
    PRE_DEPLOYMENT_RED_TEAMING = "PRE_DEPLOYMENT_RED_TEAMING"

enum CreatableGovernanceControlType {
  RUNTIME = "RUNTIME",
  PRE_DEPLOYMENT_EVALS = "PRE_DEPLOYMENT_EVALS",
  PRE_DEPLOYMENT_RED_TEAMING = "PRE_DEPLOYMENT_RED_TEAMING",
}

class FilterSet:
    operator: Literal["AND", "OR"]
    groups: List[FilterSetGroup]

interface FilterSet {
  operator: "AND" | "OR";
  groups: FilterSetGroup[];
}

class GovernanceControl:
    id: str
    name: str
    description: Optional[str]
    type: GovernanceControlType
    operational_key: Optional[str] = Field(alias="operationalKey")
    recommended: bool
    configured: bool
    policies_count: int = Field(alias="policiesCount")
    severity: Optional[GovernanceControlSeverity]
    assessments_count: int = Field(alias="assessmentsCount")
    created_at: str = Field(alias="createdAt")
    health: GovernanceControlHealth
    last_assessed_at: Optional[str] = Field(alias="lastAssessedAt")

interface GovernanceControl {
  id: string;
  name: string;
  description: string | null;
  type: GovernanceControlType;
  operationalKey: string | null;
  recommended: boolean;
  configured: boolean;
  policiesCount: number;
  severity: GovernanceControlSeverity | null;
  assessmentsCount: number;
  createdAt: string;
  health: GovernanceControlHealth;
  lastAssessedAt: string | null;
}

class GovernanceControlActivity(Enum):
    ACTIVE = "active"
    INACTIVE = "inactive"

enum GovernanceControlActivity {
  ACTIVE = "active",
  INACTIVE = "inactive",
}

class GovernanceControlAggregation(Enum):
    AVG_COST = "Avg cost"
    AVG_LATENCY = "Avg latency"
    AVG_RATING = "Avg rating"
    AVG_SCORE = "Avg score"
    AVG_VALUE = "Avg value"
    COUNT = "Count"
    ERROR_COUNT = "Error count"
    ERROR_RATE = "Error rate"
    FAILURE_RATE = "Failure rate"
    INPUT_COST = "Input cost"
    INPUT_TOKENS = "Input tokens"
    MEDIAN_SCORE = "Median score"
    OUTPUT_COST = "Output cost"
    OUTPUT_TOKENS = "Output tokens"
    P50_LATENCY = "P50 latency"
    P90_LATENCY = "P90 latency"
    P99_LATENCY = "P99 latency"
    PASS_RATE = "Pass rate"
    TOTAL_COST = "Total cost"
    TOTAL_TOKENS = "Total tokens"
    UNIQUE_END_USERS = "Unique end users"
    UNIQUE_METADATA_VALUES = "Unique metadata values"
    UNIQUE_THREADS = "Unique threads"

enum GovernanceControlAggregation {
  AVG_COST = "Avg cost",
  AVG_LATENCY = "Avg latency",
  AVG_RATING = "Avg rating",
  AVG_SCORE = "Avg score",
  AVG_VALUE = "Avg value",
  COUNT = "Count",
  ERROR_COUNT = "Error count",
  ERROR_RATE = "Error rate",
  FAILURE_RATE = "Failure rate",
  INPUT_COST = "Input cost",
  INPUT_TOKENS = "Input tokens",
  MEDIAN_SCORE = "Median score",
  OUTPUT_COST = "Output cost",
  OUTPUT_TOKENS = "Output tokens",
  P50_LATENCY = "P50 latency",
  P90_LATENCY = "P90 latency",
  P99_LATENCY = "P99 latency",
  PASS_RATE = "Pass rate",
  TOTAL_COST = "Total cost",
  TOTAL_TOKENS = "Total tokens",
  UNIQUE_END_USERS = "Unique end users",
  UNIQUE_METADATA_VALUES = "Unique metadata values",
  UNIQUE_THREADS = "Unique threads",
}

class GovernanceControlAssessment:
    id: str
    governance_control_id: str = Field(alias="governanceControlId")
    governance_control_version: GovernanceControlVersionReference = Field(alias="governanceControlVersion")
    project_id: str = Field(alias="projectId")
    project_name: str = Field(alias="projectName")
    status: GovernanceControlStatus
    evidence: Optional[Dict[str, Any]]
    error: Optional[str]
    created_at: str = Field(alias="createdAt")

interface GovernanceControlAssessment {
  id: string;
  governanceControlId: string;
  governanceControlVersion: GovernanceControlVersionReference;
  projectId: string;
  projectName: string;
  status: GovernanceControlStatus;
  evidence: Record<string, unknown> | null;
  error: string | null;
  createdAt: string;
}

class GovernanceControlAssessmentList:
    governance_assessments: List[GovernanceControlAssessment] = Field(alias="governanceAssessments")
    total_governance_control_assessments: int = Field(alias="totalGovernanceControlAssessments")
    version: str
    page: int
    page_size: int = Field(alias="pageSize")

interface GovernanceControlAssessmentList {
  governanceAssessments: GovernanceControlAssessment[];
  totalGovernanceControlAssessments: number;
  version: string;
  page: number;
  pageSize: number;
}

class GovernanceControlDataModel(Enum):
    TRACE = "TRACE"
    SPAN = "SPAN"
    THREAD = "THREAD"
    METRIC_DATA = "METRIC_DATA"
    ANNOTATION = "ANNOTATION"

enum GovernanceControlDataModel {
  TRACE = "TRACE",
  SPAN = "SPAN",
  THREAD = "THREAD",
  METRIC_DATA = "METRIC_DATA",
  ANNOTATION = "ANNOTATION",
}

class GovernanceControlExtraQueryParams:
    category: Optional[GovernanceControlMetricDataCategory] = None

interface GovernanceControlExtraQueryParams {
  category?: GovernanceControlMetricDataCategory;
}

class GovernanceControlHealth:
    pass_rate: Optional[float] = Field(alias="passRate")
    projects_assessed: int = Field(alias="projectsAssessed")
    projects_failing: int = Field(alias="projectsFailing")
    projects_total: int = Field(alias="projectsTotal")
    projects: Optional[List[GovernanceControlProjectStatus]] = None

interface GovernanceControlHealth {
  passRate: number | null;
  projectsAssessed: number;
  projectsFailing: number;
  projectsTotal: number;
  projects?: GovernanceControlProjectStatus[];
}

class GovernanceControlList:
    governance_controls: List[GovernanceControlSummary] = Field(alias="governanceControls")
    total_governance_controls: int = Field(alias="totalGovernanceControls")
    page: int
    page_size: int = Field(alias="pageSize")

interface GovernanceControlList {
  governanceControls: GovernanceControlSummary[];
  totalGovernanceControls: number;
  page: number;
  pageSize: number;
}

class GovernanceControlMetricDataCategory(Enum):
    TRACE = "TRACE"
    SPAN = "SPAN"
    THREAD = "THREAD"

enum GovernanceControlMetricDataCategory {
  TRACE = "TRACE",
  SPAN = "SPAN",
  THREAD = "THREAD",
}

class GovernanceControlPreDeploymentConfig:
    identifier: str
    window: GovernanceControlPreDeploymentWindow
    official_only: Optional[bool] = Field(default=None, alias="officialOnly")
    filters: Optional[FilterSet]
    severity: Optional[GovernanceControlSeverity]

interface GovernanceControlPreDeploymentConfig {
  identifier: string;
  window: GovernanceControlPreDeploymentWindow;
  officialOnly?: boolean;
  filters: FilterSet | null;
  severity: GovernanceControlSeverity | null;
}

class GovernanceControlPreDeploymentWindow:
    days: int

interface GovernanceControlPreDeploymentWindow {
  days: number;
}

class GovernanceControlProjectStatus:
    project_id: str = Field(alias="projectId")
    project_name: str = Field(alias="projectName")
    status: Optional[GovernanceControlStatus]

interface GovernanceControlProjectStatus {
  projectId: string;
  projectName: string;
  status: GovernanceControlStatus | null;
}

class GovernanceControlRef:
    id: str

interface GovernanceControlRef {
  id: string;
}

class GovernanceControlRuntimeConfig:
    data_model: Optional[GovernanceControlDataModel] = Field(alias="dataModel")
    aggregation: Optional[GovernanceControlAggregation]
    threshold_settings: Optional[GovernanceControlThresholdSettings] = Field(alias="thresholdSettings")
    extra_query_params: Optional[GovernanceControlExtraQueryParams] = Field(default=None, alias="extraQueryParams")
    filters: Optional[FilterSet]
    severity: Optional[GovernanceControlSeverity]

interface GovernanceControlRuntimeConfig {
  dataModel: GovernanceControlDataModel | null;
  aggregation: GovernanceControlAggregation | null;
  thresholdSettings: GovernanceControlThresholdSettings | null;
  extraQueryParams?: GovernanceControlExtraQueryParams | null;
  filters: FilterSet | null;
  severity: GovernanceControlSeverity | null;
}

class GovernanceControlSeverity(Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

enum GovernanceControlSeverity {
  CRITICAL = "CRITICAL",
  HIGH = "HIGH",
  MEDIUM = "MEDIUM",
  LOW = "LOW",
}

class GovernanceControlStatus(Enum):
    PASS = "PASS"
    FAIL = "FAIL"
    ERROR = "ERROR"
    NO_DATA = "NO_DATA"

enum GovernanceControlStatus {
  PASS = "PASS",
  FAIL = "FAIL",
  ERROR = "ERROR",
  NO_DATA = "NO_DATA",
}

class GovernanceControlSummary:
    id: str
    name: str
    description: Optional[str]
    type: GovernanceControlType
    operational_key: Optional[str] = Field(alias="operationalKey")
    recommended: bool
    configured: bool
    policies_count: int = Field(alias="policiesCount")
    severity: Optional[GovernanceControlSeverity]
    assessments_count: int = Field(alias="assessmentsCount")
    created_at: str = Field(alias="createdAt")
    health: GovernanceControlHealth

interface GovernanceControlSummary {
  id: string;
  name: string;
  description: string | null;
  type: GovernanceControlType;
  operationalKey: string | null;
  recommended: boolean;
  configured: boolean;
  policiesCount: number;
  severity: GovernanceControlSeverity | null;
  assessmentsCount: number;
  createdAt: string;
  health: GovernanceControlHealth;
}

class GovernanceControlThresholdDirection(Enum):
    ABOVE = "above"
    BELOW = "below"

enum GovernanceControlThresholdDirection {
  ABOVE = "above",
  BELOW = "below",
}

class GovernanceControlThresholdSettings:
    value: float
    direction: GovernanceControlThresholdDirection

interface GovernanceControlThresholdSettings {
  value: number;
  direction: GovernanceControlThresholdDirection;
}

class GovernanceControlType(Enum):
    RUNTIME = "RUNTIME"
    PRE_DEPLOYMENT_EVALS = "PRE_DEPLOYMENT_EVALS"
    PRE_DEPLOYMENT_RED_TEAMING = "PRE_DEPLOYMENT_RED_TEAMING"
    OPERATIONAL = "OPERATIONAL"

enum GovernanceControlType {
  RUNTIME = "RUNTIME",
  PRE_DEPLOYMENT_EVALS = "PRE_DEPLOYMENT_EVALS",
  PRE_DEPLOYMENT_RED_TEAMING = "PRE_DEPLOYMENT_RED_TEAMING",
  OPERATIONAL = "OPERATIONAL",
}

class GovernanceControlVersionReference:
    id: str
    version: str

interface GovernanceControlVersionReference {
  id: string;
  version: string;
}