Versions

from confident_ai import ConfidentAI

client = ConfidentAI()

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

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

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

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

from confident_ai import ConfidentAI
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 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_version(
    control_id="<GOVERNANCE-CONTROL-ID>",
    control_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
    ),
)

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

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

const client = new ConfidentAI();

const result = await client.organization.createGovernanceControlVersion(
  "<GOVERNANCE-CONTROL-ID>",
  {
    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
  },
);

from confident_ai import ConfidentAI
from confident_ai.common import FilterSet
from confident_ai.organization import GovernanceControlPreDeploymentConfig
from confident_ai.organization import GovernanceControlPreDeploymentWindow
from confident_ai.organization import GovernanceControlSeverity

client = ConfidentAI()

result = client.organization.create_governance_control_version(
    control_id="<GOVERNANCE-CONTROL-ID>",
    control_config=GovernanceControlPreDeploymentConfig(
        identifier="pre-release",
        window=GovernanceControlPreDeploymentWindow(
            days=30
        ),
        official_only=False,
        filters=FilterSet(
            operator="AND",
            groups=[]
        ),
        severity=GovernanceControlSeverity.CRITICAL
    ),
)

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

import { ConfidentAI } from "confident-ai";
import { GovernanceControlSeverity } from "confident-ai/organization";

const client = new ConfidentAI();

const result = await client.organization.createGovernanceControlVersion(
  "<GOVERNANCE-CONTROL-ID>",
  {
    identifier: "pre-release",
    window: {
        days: 30
      },
    officialOnly: false,
    filters: {
        operator: "AND",
        groups: []
      },
    severity: GovernanceControlSeverity.CRITICAL
  },
);

CreateGovernanceControlVersionRequest = Union[
    GovernanceControlRuntimeConfig,
    GovernanceControlPreDeploymentConfig,
]

type CreateGovernanceControlVersionRequest =
  | GovernanceControlRuntimeConfig
  | GovernanceControlPreDeploymentConfig;

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

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

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 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 GovernanceControlMetricDataCategory(Enum):
    TRACE = "TRACE"
    SPAN = "SPAN"
    THREAD = "THREAD"

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

class GovernanceControlPreDeploymentSettings:
    identifier: Optional[str] = None
    window: Optional[GovernanceControlPreDeploymentWindow] = None
    official_only: Optional[bool] = Field(default=None, alias="officialOnly")

interface GovernanceControlPreDeploymentSettings {
  identifier?: string;
  window?: GovernanceControlPreDeploymentWindow;
  officialOnly?: boolean;
}

class GovernanceControlPreDeploymentWindow:
    days: int

interface GovernanceControlPreDeploymentWindow {
  days: number;
}

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

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

class GovernanceControlStoredThresholdSettings:
    value: Optional[float] = None
    direction: Optional[GovernanceControlThresholdDirection] = None

interface GovernanceControlStoredThresholdSettings {
  value?: number;
  direction?: GovernanceControlThresholdDirection;
}

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 GovernanceControlVersion:
    id: str
    version: str
    sequence: int
    data_model: Optional[GovernanceControlDataModel] = Field(alias="dataModel")
    aggregation: Optional[str]
    threshold_settings: Optional[GovernanceControlStoredThresholdSettings] = Field(alias="thresholdSettings")
    extra_query_params: Optional[GovernanceControlExtraQueryParams] = Field(alias="extraQueryParams")
    pre_deployment_settings: Optional[GovernanceControlPreDeploymentSettings] = Field(alias="preDeploymentSettings")
    filters: Optional[FilterSet]
    severity: Optional[GovernanceControlSeverity]
    assessments_count: int = Field(alias="assessmentsCount")
    created_at: str = Field(alias="createdAt")

interface GovernanceControlVersion {
  id: string;
  version: string;
  sequence: number;
  dataModel: GovernanceControlDataModel | null;
  aggregation: string | null;
  thresholdSettings: GovernanceControlStoredThresholdSettings | null;
  extraQueryParams: GovernanceControlExtraQueryParams | null;
  preDeploymentSettings: GovernanceControlPreDeploymentSettings | null;
  filters: FilterSet | null;
  severity: GovernanceControlSeverity | null;
  assessmentsCount: number;
  createdAt: string;
}

class GovernanceControlVersionList:
    versions: List[GovernanceControlVersion]
    total_governance_control_versions: int = Field(alias="totalGovernanceControlVersions")
    page: int
    page_size: int = Field(alias="pageSize")

interface GovernanceControlVersionList {
  versions: GovernanceControlVersion[];
  totalGovernanceControlVersions: number;
  page: number;
  pageSize: number;
}