Reports

from confident_ai import ConfidentAI
from confident_ai.reports import ReportStatus

client = ConfidentAI()

result = client.reports.list(
    report_template_id="<REPORT-TEMPLATE-ID>",
    status=ReportStatus.IN_PROGRESS,
    start_date="2025-01-01T00:00:00+00:00",
    end_date="2025-01-31T23:59:59+00:00",
    page=1,
    page_size=25,
)

result = await client.reports.a_list(...)

import { ConfidentAI } from "confident-ai";
import { ReportStatus } from "confident-ai/reports";

const client = new ConfidentAI();

const result = await client.reports.list(
  {
    reportTemplateId: "<REPORT-TEMPLATE-ID>",
    status: ReportStatus.IN_PROGRESS,
    startDate: "2025-01-01T00:00:00+00:00",
    endDate: "2025-01-31T23:59:59+00:00",
    page: 1,
    pageSize: 25
  },
);

from confident_ai import ConfidentAI
from confident_ai.reports import ReportContentSectionInput
from confident_ai.reports import ReportDateRange
from confident_ai.reports import ReportMetadataInput
from confident_ai.reports import ReportNarrativeContent
from confident_ai.reports import ReportStatus

client = ConfidentAI()

result = client.reports.create(
    report_template_id="<REPORT-TEMPLATE-ID>",
    sections=[
        ReportContentSectionInput(
            type="CONTENT",
            heading="Overview",
            start_on_new_page=False,
            content=ReportNarrativeContent(
                kind="narrative",
                narrative="Traffic held steady while the error rate fell by a third, and spend stayed inside budget.",
                sources=["Traces, 1-8 Jan 2025"]
            )
        )
    ],
    status=ReportStatus.IN_PROGRESS,
    error="<ERROR>",
    metadata=ReportMetadataInput(
        report_title="Weekly Health Check",
        description="Production health for the last week.",
        date_range=ReportDateRange(
            start_date="2025-01-01T00:00:00+00:00",
            end_date="2025-01-08T00:00:00+00:00"
        )
    ),
)

result = await client.reports.a_create(...)

import { ConfidentAI } from "confident-ai";
import { ReportStatus } from "confident-ai/reports";

const client = new ConfidentAI();

const result = await client.reports.create(
  "<REPORT-TEMPLATE-ID>",
  [
    {
      type: "CONTENT",
      heading: "Overview",
      startOnNewPage: false,
      content: {
          kind: "narrative",
          narrative: "Traffic held steady while the error rate fell by a third, and spend stayed inside budget.",
          sources: ["Traces, 1-8 Jan 2025"]
        }
    }
  ],
  {
    status: ReportStatus.IN_PROGRESS,
    error: "<ERROR>",
    metadata: {
      reportTitle: "Weekly Health Check",
      description: "Production health for the last week.",
      dateRange: {
          startDate: "2025-01-01T00:00:00+00:00",
          endDate: "2025-01-08T00:00:00+00:00"
        }
    }
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.reports.get(report_id="<REPORT-ID>")

result = await client.reports.a_get(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.reports.get("<REPORT-ID>");

from confident_ai import ConfidentAI
from confident_ai.reports import ReportContentSectionInput
from confident_ai.reports import ReportDateRange
from confident_ai.reports import ReportMetadataInput
from confident_ai.reports import ReportNarrativeContent
from confident_ai.reports import ReportStatus

client = ConfidentAI()

result = client.reports.update(
    report_id="<REPORT-ID>",
    status=ReportStatus.IN_PROGRESS,
    error="<ERROR>",
    metadata=ReportMetadataInput(
        report_title="Weekly Health Check",
        description="Production health for the last week.",
        date_range=ReportDateRange(
            start_date="2025-01-01T00:00:00+00:00",
            end_date="2025-01-08T00:00:00+00:00"
        )
    ),
    sections=[
        ReportContentSectionInput(
            type="CONTENT",
            heading="Overview",
            start_on_new_page=False,
            content=ReportNarrativeContent(
                kind="narrative",
                narrative="Traffic held steady while the error rate fell by a third, and spend stayed inside budget.",
                sources=["Traces, 1-8 Jan 2025"]
            )
        )
    ],
)

result = await client.reports.a_update(...)

import { ConfidentAI } from "confident-ai";
import { ReportStatus } from "confident-ai/reports";

const client = new ConfidentAI();

const result = await client.reports.update(
  "<REPORT-ID>",
  {
    status: ReportStatus.IN_PROGRESS,
    error: "<ERROR>",
    metadata: {
      reportTitle: "Weekly Health Check",
      description: "Production health for the last week.",
      dateRange: {
          startDate: "2025-01-01T00:00:00+00:00",
          endDate: "2025-01-08T00:00:00+00:00"
        }
    },
    sections: [
      {
        type: "CONTENT",
        heading: "Overview",
        startOnNewPage: false,
        content: {
            kind: "narrative",
            narrative: "Traffic held steady while the error rate fell by a third, and spend stayed inside budget.",
            sources: ["Traces, 1-8 Jan 2025"]
          }
      }
    ]
  },
);

from confident_ai import ConfidentAI

client = ConfidentAI()

result = client.reports.delete(report_id="<REPORT-ID>")

result = await client.reports.a_delete(...)

import { ConfidentAI } from "confident-ai";

const client = new ConfidentAI();

const result = await client.reports.delete("<REPORT-ID>");

class Report:
    id: str
    report_template_id: Optional[str] = Field(alias="reportTemplateId")
    status: ReportStatus
    error: Optional[str]
    metadata: Optional[ReportMetadata]
    created_at: str = Field(alias="createdAt")
    updated_at: str = Field(alias="updatedAt")
    sections: List[ReportSection]

interface Report {
  id: string;
  reportTemplateId: string | null;
  status: ReportStatus;
  error: string | null;
  metadata: ReportMetadata | null;
  createdAt: string;
  updatedAt: string;
  sections: ReportSection[];
}

class ReportAdmonitionContent:
    severity: ReportAdmonitionSeverity
    text: str
    sources: Optional[List[str]] = None

interface ReportAdmonitionContent {
  severity: ReportAdmonitionSeverity;
  text: string;
  sources?: string[] | null;
}

class ReportAdmonitionSeverity(Enum):
    INFO = "INFO"
    SUCCESS = "SUCCESS"
    WARNING = "WARNING"
    DANGER = "DANGER"

enum ReportAdmonitionSeverity {
  INFO = "INFO",
  SUCCESS = "SUCCESS",
  WARNING = "WARNING",
  DANGER = "DANGER",
}

class ReportDateRange:
    start_date: str = Field(alias="startDate")
    end_date: str = Field(alias="endDate")

interface ReportDateRange {
  startDate: string;
  endDate: string;
}

class ReportGraphConfigContent:
    type: Literal["config"]
    source: Optional[str] = None
    title: str
    data_model: str = Field(alias="dataModel")
    metric: str
    dimension: Optional[str] = None
    granularity: Optional[str] = None
    span_type: Optional[str] = Field(default=None, alias="spanType")
    start_date: Optional[str] = Field(default=None, alias="startDate")
    end_date: Optional[str] = Field(default=None, alias="endDate")
    sources: Optional[List[str]] = None

interface ReportGraphConfigContent {
  type: "config";
  source?: string | null;
  title: string;
  dataModel: string;
  metric: string;
  dimension?: string | null;
  granularity?: string | null;
  spanType?: string | null;
  startDate?: string | null;
  endDate?: string | null;
  sources?: string[] | null;
}

class ReportGraphContent:
    type: Literal["snapshot"]
    graph_type: ReportGraphType = Field(alias="graphType")
    categories: List[str]
    series: List[ReportGraphSeries]
    x_axis_label: Optional[str] = Field(default=None, alias="xAxisLabel")
    y_axis_label: Optional[str] = Field(default=None, alias="yAxisLabel")
    sources: Optional[List[str]] = None

interface ReportGraphContent {
  type: "snapshot";
  graphType: ReportGraphType;
  categories: string[];
  series: ReportGraphSeries[];
  xAxisLabel?: string | null;
  yAxisLabel?: string | null;
  sources?: string[] | null;
}

class ReportGraphSeries:
    name: str
    values: List[float]
    color: Optional[str] = None

interface ReportGraphSeries {
  name: string;
  values: number[];
  color?: string | null;
}

class ReportGraphType(Enum):
    LINE = "LINE"
    AREA = "AREA"
    BAR = "BAR"
    STACKED_BAR = "STACKED_BAR"

enum ReportGraphType {
  LINE = "LINE",
  AREA = "AREA",
  BAR = "BAR",
  STACKED_BAR = "STACKED_BAR",
}

class ReportList:
    reports: List[ReportSummary]
    total_reports: int = Field(alias="totalReports")
    page: int
    page_size: int = Field(alias="pageSize")

interface ReportList {
  reports: ReportSummary[];
  totalReports: number;
  page: number;
  pageSize: number;
}

class ReportMetadata:
    report_title: Optional[str] = Field(alias="reportTitle")
    description: Optional[str]
    date_range: Optional[ReportDateRange] = Field(alias="dateRange")
    generated_at: Optional[str] = Field(alias="generatedAt")

interface ReportMetadata {
  reportTitle: string | null;
  description: string | null;
  dateRange: ReportDateRange | null;
  generatedAt: string | null;
}

class ReportMetadataInput:
    report_title: Optional[str] = Field(default=None, alias="reportTitle")
    description: Optional[str] = None
    date_range: Optional[ReportDateRange] = Field(default=None, alias="dateRange")

interface ReportMetadataInput {
  reportTitle?: string;
  description?: string;
  dateRange?: ReportDateRange;
}

class ReportNarrativeContent:
    kind: Literal["narrative"]
    narrative: str
    sources: Optional[List[str]] = None

interface ReportNarrativeContent {
  kind: "narrative";
  narrative: string;
  sources?: string[] | null;
}

class ReportRef:
    id: str

interface ReportRef {
  id: string;
}

class ReportSection:
    id: str
    type: ReportSectionType
    heading: Optional[str]
    order: int
    content: Optional[Union[ReportNarrativeContent, ReportAdmonitionContent, ReportStatCardsContent, ReportTableContent, ReportGraphContent, ReportGraphConfigContent]]
    error: Optional[str]
    start_on_new_page: Optional[bool] = Field(alias="startOnNewPage")

interface ReportSection {
  id: string;
  type: ReportSectionType;
  heading: string | null;
  order: number;
  content: ReportNarrativeContent | ReportAdmonitionContent | ReportStatCardsContent | ReportTableContent | ReportGraphContent | ReportGraphConfigContent | null;
  error: string | null;
  startOnNewPage: boolean | null;
}

ReportSectionInput = Union[
    ReportContentSectionInput,
    ReportAdmonitionSectionInput,
    ReportStatCardsSectionInput,
    ReportTableSectionInput,
    ReportGraphSectionInput,
]

type ReportSectionInput =
  | ReportContentSectionInput
  | ReportAdmonitionSectionInput
  | ReportStatCardsSectionInput
  | ReportTableSectionInput
  | ReportGraphSectionInput;

class ReportSectionType(Enum):
    CONTENT = "CONTENT"
    STAT_CARDS = "STAT_CARDS"
    TABLE = "TABLE"
    GRAPH = "GRAPH"
    ADMONITION = "ADMONITION"

enum ReportSectionType {
  CONTENT = "CONTENT",
  STAT_CARDS = "STAT_CARDS",
  TABLE = "TABLE",
  GRAPH = "GRAPH",
  ADMONITION = "ADMONITION",
}

class ReportStatCard:
    label: str
    value: str
    caption: Optional[str] = None

interface ReportStatCard {
  label: string;
  value: string;
  caption?: string | null;
}

class ReportStatCardsContent:
    cards: List[ReportStatCard]
    highlights: Optional[List[ReportStatHighlight]] = None
    sources: Optional[List[str]] = None

interface ReportStatCardsContent {
  cards: ReportStatCard[];
  highlights?: ReportStatHighlight[] | null;
  sources?: string[] | null;
}

class ReportStatHighlight:
    label: str
    value: str

interface ReportStatHighlight {
  label: string;
  value: string;
}

class ReportStatus(Enum):
    IN_PROGRESS = "IN_PROGRESS"
    COMPLETED = "COMPLETED"
    ERRORED = "ERRORED"

enum ReportStatus {
  IN_PROGRESS = "IN_PROGRESS",
  COMPLETED = "COMPLETED",
  ERRORED = "ERRORED",
}

class ReportSummary:
    id: str
    report_template_id: Optional[str] = Field(alias="reportTemplateId")
    status: ReportStatus
    error: Optional[str]
    metadata: Optional[ReportMetadata]
    created_at: str = Field(alias="createdAt")
    updated_at: str = Field(alias="updatedAt")

interface ReportSummary {
  id: string;
  reportTemplateId: string | null;
  status: ReportStatus;
  error: string | null;
  metadata: ReportMetadata | null;
  createdAt: string;
  updatedAt: string;
}

class ReportTableContent:
    headers: List[str]
    rows: List[List[str]]
    sources: Optional[List[str]] = None

interface ReportTableContent {
  headers: string[];
  rows: string[][];
  sources?: string[] | null;
}