@azure/ai-content-understanding 1.0.0

package/dist/browser/models/models.d.ts

@@ -0,0 +1,846 @@
+import type { ErrorModel } from "@azure-rest/core-client";
+/**
+ * This file contains only generated model types and their (de)serializers.
+ * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
+ */
+/** Additional input to analyze. */
+export interface AnalysisInput {
+    /** The URL of the input to analyze.  Only one of url or data should be specified. */
+    url?: string;
+    /** Raw image bytes. Provide bytes-like object; do not base64-encode. Only one of url or data should be specified. */
+    data?: Uint8Array;
+    /** Name of the input. */
+    name?: string;
+    /** The MIME type of the input content.  Ex. application/pdf, image/jpeg, etc. */
+    mimeType?: string;
+    /** Range of the input to analyze (ex. `1-3,5,9-`).  Document content uses 1-based page numbers, while audio visual content uses integer milliseconds. */
+    contentRange?: string;
+}
+export declare function analysisInputSerializer(item: AnalysisInput): any;
+export declare function analysisInputArraySerializer(result: Array<AnalysisInput>): any[];
+/** Provides status details for analyze operations. */
+export interface ContentAnalyzerAnalyzeOperationStatus {
+    /** The unique ID of the operation. */
+    id: string;
+    /** The status of the operation */
+    status: OperationState;
+    /** Error object that describes the error when status is "Failed". */
+    error?: ErrorModel;
+    /** The result of the operation. */
+    result?: AnalysisResult;
+    /** Usage details of the analyze operation. */
+    usage?: UsageDetails;
+}
+export declare function contentAnalyzerAnalyzeOperationStatusDeserializer(item: any): ContentAnalyzerAnalyzeOperationStatus;
+/** Enum describing allowed operation states. */
+export type OperationState = "NotStarted" | "Running" | "Succeeded" | "Failed" | "Canceled";
+/** Analyze operation result. */
+export interface AnalysisResult {
+    /** The unique identifier of the analyzer. */
+    analyzerId?: string;
+    /** The version of the API used to analyze the document. */
+    apiVersion?: string;
+    /** The date and time when the result was created. */
+    createdAt?: Date;
+    /** Warnings encountered while analyzing the document. */
+    warnings?: ErrorModel[];
+    /**
+     *   The string encoding format for content spans in the response.
+     *   Possible values are 'codePoint', 'utf16', and `utf8`.  Default is `codePoint`.")
+     */
+    stringEncoding?: string;
+    /** The extracted content. */
+    contents: AnalysisContentUnion[];
+}
+export declare function analysisResultDeserializer(item: any): AnalysisResult;
+export declare function analysisContentUnionArrayDeserializer(result: Array<AnalysisContentUnion>): any[];
+/** Media content base class. */
+export interface AnalysisContent {
+    /** Content kind. */
+    /** The discriminator possible values: document, audioVisual */
+    kind: AnalysisContentKind;
+    /** Detected MIME type of the content.  Ex. application/pdf, image/jpeg, etc. */
+    mimeType: string;
+    /** The analyzer that generated this content. */
+    analyzerId?: string;
+    /** Classified content category. */
+    category?: string;
+    /** The path of the content in the input. */
+    path?: string;
+    /** Markdown representation of the content. */
+    markdown?: string;
+    /** Extracted fields from the content. */
+    fields?: Record<string, ContentFieldUnion>;
+}
+export declare function analysisContentDeserializer(item: any): AnalysisContent;
+/** Alias for AnalysisContentUnion */
+export type AnalysisContentUnion = DocumentContent | AudioVisualContent | AnalysisContent;
+export declare function analysisContentUnionDeserializer(item: any): AnalysisContentUnion;
+/** Kind of media content. */
+export type AnalysisContentKind = "document" | "audioVisual";
+export declare function contentFieldUnionRecordDeserializer(item: Record<string, any>): Record<string, ContentField>;
+/** Field extracted from the content. */
+export interface ContentField {
+    /** Semantic data type of the field value. */
+    /** The discriminator possible values: string, date, time, number, integer, boolean, array, object, json */
+    type: ContentFieldType;
+    /** Span(s) associated with the field value in the markdown content. */
+    spans?: ContentSpan[];
+    /** Confidence of predicting the field value. */
+    confidence?: number;
+    /** Encoded source that identifies the position of the field value in the content. */
+    source?: string;
+    /** The value of the field. */
+    value?: unknown;
+}
+export declare function contentFieldDeserializer(item: any): ContentField;
+/** Alias for ContentFieldUnion */
+export type ContentFieldUnion = StringField | DateField | TimeField | NumberField | IntegerField | BooleanField | ArrayField | ObjectField | JsonField | ContentField;
+export declare function contentFieldUnionDeserializer(item: any): ContentFieldUnion;
+/** Semantic data type of the field value. */
+export type ContentFieldType = "string" | "date" | "time" | "number" | "integer" | "boolean" | "array" | "object" | "json";
+export declare function contentSpanArrayDeserializer(result: Array<ContentSpan>): any[];
+/** Position of the element in markdown, specified as a character offset and length. */
+export interface ContentSpan {
+    /** Starting position (0-indexed) of the element in markdown, specified in characters. */
+    offset: number;
+    /** Length of the element in markdown, specified in characters. */
+    length: number;
+}
+export declare function contentSpanDeserializer(item: any): ContentSpan;
+/** String field extracted from the content. */
+export interface StringField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "string";
+    /** The value of the field. */
+    value?: string;
+}
+export declare function stringFieldDeserializer(item: any): StringField;
+/** Date field extracted from the content. */
+export interface DateField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "date";
+    /** The value of the field. */
+    value?: Date;
+}
+export declare function dateFieldDeserializer(item: any): DateField;
+/** Time field extracted from the content. */
+export interface TimeField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "time";
+    /** The value of the field. */
+    value?: string;
+}
+export declare function timeFieldDeserializer(item: any): TimeField;
+/** Number field extracted from the content. */
+export interface NumberField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "number";
+    /** The value of the field. */
+    value?: number;
+}
+export declare function numberFieldDeserializer(item: any): NumberField;
+/** Integer field extracted from the content. */
+export interface IntegerField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "integer";
+    /** The value of the field. */
+    value?: number;
+}
+export declare function integerFieldDeserializer(item: any): IntegerField;
+/** Boolean field extracted from the content. */
+export interface BooleanField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "boolean";
+    /** The value of the field. */
+    value?: boolean;
+}
+export declare function booleanFieldDeserializer(item: any): BooleanField;
+/** Array field extracted from the content. */
+export interface ArrayField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "array";
+    /** The value of the field. */
+    value?: ContentFieldUnion[];
+}
+export declare function arrayFieldDeserializer(item: any): ArrayField;
+export declare function contentFieldUnionArrayDeserializer(result: Array<ContentFieldUnion>): any[];
+/** Object field extracted from the content. */
+export interface ObjectField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "object";
+    /** The value of the field. */
+    value?: Record<string, ContentFieldUnion>;
+}
+export declare function objectFieldDeserializer(item: any): ObjectField;
+/** JSON field extracted from the content. */
+export interface JsonField extends ContentField {
+    /** Semantic data type of the field value. */
+    fieldType: "json";
+    /** The value of the field. */
+    value?: unknown;
+}
+export declare function jsonFieldDeserializer(item: any): JsonField;
+/** Document content.  Ex. text/plain, application/pdf, image/jpeg. */
+export interface DocumentContent extends AnalysisContent {
+    /** Content kind. */
+    kind: "document";
+    /** Start page number (1-indexed) of the content. */
+    startPageNumber: number;
+    /** End page number (1-indexed) of the content. */
+    endPageNumber: number;
+    /**
+     * Length unit used by the width, height, and source properties.
+     * For images/tiff, the default unit is pixel.  For PDF, the default unit is inch.
+     */
+    unit?: LengthUnit;
+    /** List of pages in the document. */
+    pages?: DocumentPage[];
+    /** List of paragraphs in the document.  Only if enableOcr and returnDetails are true. */
+    paragraphs?: DocumentParagraph[];
+    /** List of sections in the document.  Only if enableLayout and returnDetails are true. */
+    sections?: DocumentSection[];
+    /** List of tables in the document.  Only if enableLayout and returnDetails are true. */
+    tables?: DocumentTable[];
+    /** List of figures in the document.  Only if enableLayout and returnDetails are true. */
+    figures?: DocumentFigureUnion[];
+    /** List of annotations in the document.  Only if enableAnnotations and returnDetails are true. */
+    annotations?: DocumentAnnotation[];
+    /** List of hyperlinks in the document.  Only if returnDetails are true. */
+    hyperlinks?: DocumentHyperlink[];
+    /** List of detected content segments.  Only if enableSegment is true. */
+    segments?: DocumentContentSegment[];
+}
+export declare function documentContentDeserializer(item: any): DocumentContent;
+/** Length unit used by the width, height, and source properties. */
+export type LengthUnit = "pixel" | "inch";
+export declare function documentPageArrayDeserializer(result: Array<DocumentPage>): any[];
+/** Content from a document page. */
+export interface DocumentPage {
+    /** Page number (1-based). */
+    pageNumber: number;
+    /** Width of the page. */
+    width?: number;
+    /** Height of the page. */
+    height?: number;
+    /** Span(s) associated with the page in the markdown content. */
+    spans?: ContentSpan[];
+    /**
+     * The general orientation of the content in clockwise direction,
+     * measured in degrees between (-180, 180].
+     * Only if enableOcr is true.
+     */
+    angle?: number;
+    /** List of words in the page.  Only if enableOcr and returnDetails are true. */
+    words?: DocumentWord[];
+    /** List of lines in the page.  Only if enableOcr and returnDetails are true. */
+    lines?: DocumentLine[];
+    /** List of barcodes in the page.  Only if enableBarcode and returnDetails are true. */
+    barcodes?: DocumentBarcode[];
+    /** List of mathematical formulas in the page.  Only if enableFormula and returnDetails are true. */
+    formulas?: DocumentFormula[];
+}
+export declare function documentPageDeserializer(item: any): DocumentPage;
+export declare function documentWordArrayDeserializer(result: Array<DocumentWord>): any[];
+/**
+ * Word in a document, consisting of a contiguous sequence of characters.
+ * For non-space delimited languages, such as Chinese, Japanese, and Korean,
+ * each character is represented as its own word.
+ */
+export interface DocumentWord {
+    /** Word text. */
+    content: string;
+    /** Encoded source that identifies the position of the word in the content. */
+    source?: string;
+    /** Span of the word in the markdown content. */
+    span?: ContentSpan;
+    /** Confidence of predicting the word. */
+    confidence?: number;
+}
+export declare function documentWordDeserializer(item: any): DocumentWord;
+export declare function documentLineArrayDeserializer(result: Array<DocumentLine>): any[];
+/** Line in a document, consisting of an contiguous sequence of words. */
+export interface DocumentLine {
+    /** Line text. */
+    content: string;
+    /** Encoded source that identifies the position of the line in the content. */
+    source?: string;
+    /** Span of the line in the markdown content. */
+    span?: ContentSpan;
+}
+export declare function documentLineDeserializer(item: any): DocumentLine;
+export declare function documentBarcodeArrayDeserializer(result: Array<DocumentBarcode>): any[];
+/** Barcode in a document. */
+export interface DocumentBarcode {
+    /** Barcode kind. */
+    kind: DocumentBarcodeKind;
+    /** Barcode value. */
+    value: string;
+    /** Encoded source that identifies the position of the barcode in the content. */
+    source?: string;
+    /** Span of the barcode in the markdown content. */
+    span?: ContentSpan;
+    /** Confidence of predicting the barcode. */
+    confidence?: number;
+}
+export declare function documentBarcodeDeserializer(item: any): DocumentBarcode;
+/** Barcode kind. */
+export type DocumentBarcodeKind = "QRCode" | "PDF417" | "UPCA" | "UPCE" | "Code39" | "Code128" | "EAN8" | "EAN13" | "DataBar" | "Code93" | "Codabar" | "DataBarExpanded" | "ITF" | "MicroQRCode" | "Aztec" | "DataMatrix" | "MaxiCode";
+export declare function documentFormulaArrayDeserializer(result: Array<DocumentFormula>): any[];
+/** Mathematical formula in a document. */
+export interface DocumentFormula {
+    /** Formula kind. */
+    kind: DocumentFormulaKind;
+    /** LaTex expression describing the formula. */
+    value: string;
+    /** Encoded source that identifies the position of the formula in the content. */
+    source?: string;
+    /** Span of the formula in the markdown content. */
+    span?: ContentSpan;
+    /** Confidence of predicting the formula. */
+    confidence?: number;
+}
+export declare function documentFormulaDeserializer(item: any): DocumentFormula;
+/** Formula kind. */
+export type DocumentFormulaKind = "inline" | "display";
+export declare function documentParagraphArrayDeserializer(result: Array<DocumentParagraph>): any[];
+/**
+ * Paragraph in a document, generally consisting of an contiguous sequence of lines
+ * with common alignment and spacing.
+ */
+export interface DocumentParagraph {
+    /** Semantic role of the paragraph. */
+    role?: SemanticRole;
+    /** Paragraph text. */
+    content: string;
+    /** Encoded source that identifies the position of the paragraph in the content. */
+    source?: string;
+    /** Span of the paragraph in the markdown content. */
+    span?: ContentSpan;
+}
+export declare function documentParagraphDeserializer(item: any): DocumentParagraph;
+/** Semantic role of the paragraph. */
+export type SemanticRole = "pageHeader" | "pageFooter" | "pageNumber" | "title" | "sectionHeading" | "footnote" | "formulaBlock";
+export declare function documentSectionArrayDeserializer(result: Array<DocumentSection>): any[];
+/** Section in a document. */
+export interface DocumentSection {
+    /** Span of the section in the markdown content. */
+    span?: ContentSpan;
+    /** Child elements of the section. */
+    elements?: string[];
+}
+export declare function documentSectionDeserializer(item: any): DocumentSection;
+export declare function documentTableArrayDeserializer(result: Array<DocumentTable>): any[];
+/** Table in a document, consisting table cells arranged in a rectangular layout. */
+export interface DocumentTable {
+    /** Number of rows in the table. */
+    rowCount: number;
+    /** Number of columns in the table. */
+    columnCount: number;
+    /** Cells contained within the table. */
+    cells: DocumentTableCell[];
+    /** Encoded source that identifies the position of the table in the content. */
+    source?: string;
+    /** Span of the table in the markdown content. */
+    span?: ContentSpan;
+    /** Table caption. */
+    caption?: DocumentCaption;
+    /** List of table footnotes. */
+    footnotes?: DocumentFootnote[];
+    /** Semantic role of the table. */
+    role?: SemanticRole;
+}
+export declare function documentTableDeserializer(item: any): DocumentTable;
+export declare function documentTableCellArrayDeserializer(result: Array<DocumentTableCell>): any[];
+/** Table cell in a document table. */
+export interface DocumentTableCell {
+    /** Table cell kind. */
+    kind?: DocumentTableCellKind;
+    /** Row index of the cell. */
+    rowIndex: number;
+    /** Column index of the cell. */
+    columnIndex: number;
+    /** Number of rows spanned by this cell. */
+    rowSpan?: number;
+    /** Number of columns spanned by this cell. */
+    columnSpan?: number;
+    /** Content of the table cell. */
+    content: string;
+    /** Encoded source that identifies the position of the table cell in the content. */
+    source?: string;
+    /** Span of the table cell in the markdown content. */
+    span?: ContentSpan;
+    /** Child elements of the table cell. */
+    elements?: string[];
+}
+export declare function documentTableCellDeserializer(item: any): DocumentTableCell;
+/** Table cell kind. */
+export type DocumentTableCellKind = "content" | "rowHeader" | "columnHeader" | "stubHead" | "description";
+/** Caption of a table or figure. */
+export interface DocumentCaption {
+    /** Content of the caption. */
+    content: string;
+    /** Encoded source that identifies the position of the caption in the content. */
+    source?: string;
+    /** Span of the caption in the markdown content. */
+    span?: ContentSpan;
+    /** Child elements of the caption. */
+    elements?: string[];
+}
+export declare function documentCaptionDeserializer(item: any): DocumentCaption;
+export declare function documentFootnoteArrayDeserializer(result: Array<DocumentFootnote>): any[];
+/** Footnote of a table or figure. */
+export interface DocumentFootnote {
+    /** Content of the footnote. */
+    content: string;
+    /** Encoded source that identifies the position of the footnote in the content. */
+    source?: string;
+    /** Span of the footnote in the markdown content. */
+    span?: ContentSpan;
+    /** Child elements of the footnote. */
+    elements?: string[];
+}
+export declare function documentFootnoteDeserializer(item: any): DocumentFootnote;
+export declare function documentFigureUnionArrayDeserializer(result: Array<DocumentFigureUnion>): any[];
+/** Figure in a document. */
+export interface DocumentFigure {
+    /** Figure kind. */
+    /** The discriminator possible values: chart, mermaid */
+    kind: DocumentFigureKind;
+    /** Figure identifier. */
+    id: string;
+    /** Encoded source that identifies the position of the figure in the content. */
+    source?: string;
+    /** Span of the figure in the markdown content. */
+    span?: ContentSpan;
+    /** Child elements of the figure, excluding any caption or footnotes. */
+    elements?: string[];
+    /** Figure caption. */
+    caption?: DocumentCaption;
+    /** List of figure footnotes. */
+    footnotes?: DocumentFootnote[];
+    /** Description of the figure. */
+    description?: string;
+    /** Semantic role of the figure. */
+    role?: SemanticRole;
+}
+export declare function documentFigureDeserializer(item: any): DocumentFigure;
+/** Alias for DocumentFigureUnion */
+export type DocumentFigureUnion = DocumentChartFigure | DocumentMermaidFigure | DocumentFigure;
+export declare function documentFigureUnionDeserializer(item: any): DocumentFigureUnion;
+/** Figure kind. */
+export type DocumentFigureKind = "unknown" | "chart" | "mermaid";
+/** Figure containing a chart, such as a bar chart, line chart, or pie chart. */
+export interface DocumentChartFigure extends DocumentFigure {
+    /** Figure kind. */
+    kind: "chart";
+    /** Chart content represented using [Chart.js config](https://www.chartjs.org/docs/latest/configuration/). */
+    content: Record<string, any>;
+}
+export declare function documentChartFigureDeserializer(item: any): DocumentChartFigure;
+/** Figure containing a diagram, such as a flowchart or network diagram. */
+export interface DocumentMermaidFigure extends DocumentFigure {
+    /** Figure kind. */
+    kind: "mermaid";
+    /** Diagram content represented using [Mermaid syntax](https://mermaid.js.org/intro/). */
+    content: string;
+}
+export declare function documentMermaidFigureDeserializer(item: any): DocumentMermaidFigure;
+export declare function documentAnnotationArrayDeserializer(result: Array<DocumentAnnotation>): any[];
+/** Annotation in a document, such as a strikethrough or a comment. */
+export interface DocumentAnnotation {
+    /** Annotation identifier. */
+    id: string;
+    /** Annotation kind. */
+    kind: DocumentAnnotationKind;
+    /** Spans of the content associated with the annotation. */
+    spans?: ContentSpan[];
+    /** Position of the annotation. */
+    source?: string;
+    /** Comments associated with the annotation. */
+    comments?: DocumentAnnotationComment[];
+    /** Annotation author. */
+    author?: string;
+    /** Date and time when the annotation was created. */
+    createdAt?: Date;
+    /** Date and time when the annotation was last modified. */
+    lastModifiedAt?: Date;
+    /** Tags associated with the annotation. */
+    tags?: string[];
+}
+export declare function documentAnnotationDeserializer(item: any): DocumentAnnotation;
+/** Document annotation kind. */
+export type DocumentAnnotationKind = "highlight" | "strikethrough" | "underline" | "italic" | "bold" | "circle" | "note";
+export declare function documentAnnotationCommentArrayDeserializer(result: Array<DocumentAnnotationComment>): any[];
+/** Comment associated with a document annotation. */
+export interface DocumentAnnotationComment {
+    /** Comment message in Markdown. */
+    message: string;
+    /** Author of the comment. */
+    author?: string;
+    /** Date and time when the comment was created. */
+    createdAt?: Date;
+    /** Date and time when the comment was last modified. */
+    lastModifiedAt?: Date;
+    /** Tags associated with the comment. */
+    tags?: string[];
+}
+export declare function documentAnnotationCommentDeserializer(item: any): DocumentAnnotationComment;
+export declare function documentHyperlinkArrayDeserializer(result: Array<DocumentHyperlink>): any[];
+/** Hyperlink in a document, such as a link to a web page or an email address. */
+export interface DocumentHyperlink {
+    /** Hyperlinked content. */
+    content: string;
+    /** URL of the hyperlink. */
+    url: string;
+    /** Span of the hyperlink in the markdown content. */
+    span?: ContentSpan;
+    /** Position of the hyperlink. */
+    source?: string;
+}
+export declare function documentHyperlinkDeserializer(item: any): DocumentHyperlink;
+export declare function documentContentSegmentArrayDeserializer(result: Array<DocumentContentSegment>): any[];
+/** Detected document content segment. */
+export interface DocumentContentSegment {
+    /** Segment identifier. */
+    segmentId: string;
+    /** Classified content category. */
+    category: string;
+    /** Span of the segment in the markdown content. */
+    span: ContentSpan;
+    /** Start page number (1-indexed) of the segment. */
+    startPageNumber: number;
+    /** End page number (1-indexed) of the segment. */
+    endPageNumber: number;
+}
+export declare function documentContentSegmentDeserializer(item: any): DocumentContentSegment;
+/** Audio visual content.  Ex. audio/wav, video/mp4. */
+export interface AudioVisualContent extends AnalysisContent {
+    /** Content kind. */
+    kind: "audioVisual";
+    /** Start time of the content in milliseconds. */
+    startTimeMs: number;
+    /** End time of the content in milliseconds. */
+    endTimeMs: number;
+    /** Width of each video frame in pixels, if applicable. */
+    width?: number;
+    /** Height of each video frame in pixels, if applicable. */
+    height?: number;
+    /** List of camera shot changes in the video, represented by its timestamp in milliseconds.  Only if returnDetails is true. */
+    cameraShotTimesMs?: number[];
+    /** List of key frames in the video, represented by its timestamp in milliseconds.  Only if returnDetails is true. */
+    keyFrameTimesMs?: number[];
+    /** List of transcript phrases.  Only if returnDetails is true. */
+    transcriptPhrases?: TranscriptPhrase[];
+    /** List of detected content segments.  Only if enableSegment is true. */
+    segments?: AudioVisualContentSegment[];
+}
+export declare function audioVisualContentDeserializer(item: any): AudioVisualContent;
+export declare function transcriptPhraseArrayDeserializer(result: Array<TranscriptPhrase>): any[];
+/** Transcript phrase. */
+export interface TranscriptPhrase {
+    /** Speaker index or name. */
+    speaker?: string;
+    /** Start time of the phrase in milliseconds. */
+    startTimeMs: number;
+    /** End time of the phrase in milliseconds. */
+    endTimeMs: number;
+    /** Detected locale of the phrase.  Ex. en-US. */
+    locale?: string;
+    /** Transcript text. */
+    text: string;
+    /** Confidence of predicting the phrase. */
+    confidence?: number;
+    /** Span of the phrase in the markdown content. */
+    span?: ContentSpan;
+    /** List of words in the phrase. */
+    words: TranscriptWord[];
+}
+export declare function transcriptPhraseDeserializer(item: any): TranscriptPhrase;
+export declare function transcriptWordArrayDeserializer(result: Array<TranscriptWord>): any[];
+/** Transcript word. */
+export interface TranscriptWord {
+    /** Start time of the word in milliseconds. */
+    startTimeMs: number;
+    /** End time of the word in milliseconds. */
+    endTimeMs: number;
+    /** Transcript text. */
+    text: string;
+    /** Span of the word in the markdown content. */
+    span?: ContentSpan;
+}
+export declare function transcriptWordDeserializer(item: any): TranscriptWord;
+export declare function audioVisualContentSegmentArrayDeserializer(result: Array<AudioVisualContentSegment>): any[];
+/** Detected audio/visual content segment. */
+export interface AudioVisualContentSegment {
+    /** Segment identifier. */
+    segmentId: string;
+    /** Classified content category. */
+    category: string;
+    /** Span of the segment in the markdown content. */
+    span: ContentSpan;
+    /** Start time of the segment in milliseconds. */
+    startTimeMs: number;
+    /** End time of the segment in milliseconds. */
+    endTimeMs: number;
+}
+export declare function audioVisualContentSegmentDeserializer(item: any): AudioVisualContentSegment;
+/** Usage details. */
+export interface UsageDetails {
+    /**
+     * The number of document pages processed at the minimal level.
+     * For documents without explicit pages (ex. txt, html), every 3000 UTF-16 characters is counted as one page.
+     */
+    documentPagesMinimal?: number;
+    /**
+     * The number of document pages processed at the basic level.
+     * For documents without explicit pages (ex. txt, html), every 3000 UTF-16 characters is counted as one page.
+     */
+    documentPagesBasic?: number;
+    /**
+     * The number of document pages processed at the standard level.
+     * For documents without explicit pages (ex. txt, html), every 3000 UTF-16 characters is counted as one page.
+     */
+    documentPagesStandard?: number;
+    /** The hours of audio processed. */
+    audioHours?: number;
+    /** The hours of video processed. */
+    videoHours?: number;
+    /** The number of contextualization tokens consumed for preparing context, generating confidence scores, source grounding, and output formatting. */
+    contextualizationTokens?: number;
+    /** The number of LLM and embedding tokens consumed, grouped by model (ex. GTP 4.1) and type (ex. input, cached input, output). */
+    tokens?: Record<string, number>;
+}
+export declare function usageDetailsDeserializer(item: any): UsageDetails;
+/** Analyzer that extracts content and fields from multimodal documents. */
+export interface ContentAnalyzer {
+    /** The unique identifier of the analyzer. */
+    readonly analyzerId: string;
+    /** A description of the analyzer. */
+    description?: string;
+    /** Tags associated with the analyzer. */
+    tags?: Record<string, string>;
+    /** The status of the analyzer. */
+    readonly status: ContentAnalyzerStatus;
+    /** The date and time when the analyzer was created. */
+    readonly createdAt: Date;
+    /** The date and time when the analyzer was last modified. */
+    readonly lastModifiedAt: Date;
+    /** Warnings encountered while creating the analyzer. */
+    readonly warnings?: ErrorModel[];
+    /** The analyzer to incrementally train from. */
+    baseAnalyzerId?: string;
+    /** Analyzer configuration settings. */
+    config?: ContentAnalyzerConfig;
+    /** The schema of fields to extracted. */
+    fieldSchema?: ContentFieldSchema;
+    /** Indicates whether the result may contain additional fields outside of the defined schema. */
+    dynamicFieldSchema?: boolean;
+    /** The location where the data may be processed.  Defaults to global. */
+    processingLocation?: ProcessingLocation;
+    /** Additional knowledge sources used to enhance the analyzer. */
+    knowledgeSources?: KnowledgeSourceUnion[];
+    /**
+     * Mapping of model roles to specific model names.
+     * Ex. { "completion": "gpt-4.1", "embedding": "text-embedding-3-large" }.
+     */
+    models?: Record<string, string>;
+    /** Chat completion and embedding models supported by the analyzer. */
+    readonly supportedModels?: SupportedModels;
+}
+export declare function contentAnalyzerSerializer(item: ContentAnalyzer): any;
+export declare function contentAnalyzerDeserializer(item: any): ContentAnalyzer;
+/** Status of a resource. */
+export type ContentAnalyzerStatus = "creating" | "ready" | "deleting" | "failed";
+/** Configuration settings for an analyzer. */
+export interface ContentAnalyzerConfig {
+    /** Return all content details. */
+    returnDetails?: boolean;
+    /** List of locale hints for speech transcription. */
+    locales?: string[];
+    /** Enable optical character recognition (OCR). */
+    enableOcr?: boolean;
+    /** Enable layout analysis. */
+    enableLayout?: boolean;
+    /** Enable generation of figure description. */
+    enableFigureDescription?: boolean;
+    /** Enable analysis of figures, such as charts and diagrams. */
+    enableFigureAnalysis?: boolean;
+    /** Enable mathematical formula detection. */
+    enableFormula?: boolean;
+    /** Representation format of tables in analyze result markdown. */
+    tableFormat?: TableFormat;
+    /** Representation format of charts in analyze result markdown. */
+    chartFormat?: ChartFormat;
+    /** Representation format of annotations in analyze result markdown. */
+    annotationFormat?: AnnotationFormat;
+    /** Disable the default blurring of faces for privacy while processing the content. */
+    disableFaceBlurring?: boolean;
+    /** Return field grounding source and confidence. */
+    estimateFieldSourceAndConfidence?: boolean;
+    /** Map of categories to classify the input content(s) against. */
+    contentCategories?: Record<string, ContentCategoryDefinition>;
+    /** Enable segmentation of the input by contentCategories. */
+    enableSegment?: boolean;
+    /** Force segmentation of document content by page. */
+    segmentPerPage?: boolean;
+    /**
+     * Omit the content for this analyzer from analyze result.
+     * Only return content(s) from additional analyzers specified in contentCategories, if any.
+     */
+    omitContent?: boolean;
+}
+export declare function contentAnalyzerConfigSerializer(item: ContentAnalyzerConfig): any;
+export declare function contentAnalyzerConfigDeserializer(item: any): ContentAnalyzerConfig;
+/** Representation format of tables in analyze result markdown. */
+export type TableFormat = "html" | "markdown";
+/** Representation format of charts in analyze result markdown. */
+export type ChartFormat = "chartJs" | "markdown";
+/** Representation format of annotations in analyze result markdown. */
+export type AnnotationFormat = "none" | "markdown";
+export declare function contentCategoryDefinitionRecordSerializer(item: Record<string, ContentCategoryDefinition>): Record<string, any>;
+export declare function contentCategoryDefinitionRecordDeserializer(item: Record<string, any>): Record<string, ContentCategoryDefinition>;
+/** Content category definition. */
+export interface ContentCategoryDefinition {
+    /** The description of the category. */
+    description?: string;
+    /** Optional analyzer used to process the content. */
+    analyzerId?: string;
+    /** Optional inline definition of analyzer used to process the content. */
+    analyzer?: ContentAnalyzer;
+}
+export declare function contentCategoryDefinitionSerializer(item: ContentCategoryDefinition): any;
+export declare function contentCategoryDefinitionDeserializer(item: any): ContentCategoryDefinition;
+/** Schema of fields to be extracted from documents. */
+export interface ContentFieldSchema {
+    /** The name of the field schema. */
+    name?: string;
+    /** A description of the field schema. */
+    description?: string;
+    /** The fields defined in the schema. */
+    fields: Record<string, ContentFieldDefinition>;
+    /** Additional definitions referenced by the fields in the schema. */
+    definitions?: Record<string, ContentFieldDefinition>;
+}
+export declare function contentFieldSchemaSerializer(item: ContentFieldSchema): any;
+export declare function contentFieldSchemaDeserializer(item: any): ContentFieldSchema;
+export declare function contentFieldDefinitionRecordSerializer(item: Record<string, ContentFieldDefinition>): Record<string, any>;
+export declare function contentFieldDefinitionRecordDeserializer(item: Record<string, any>): Record<string, ContentFieldDefinition>;
+/** Definition of the field using a JSON Schema like syntax. */
+export interface ContentFieldDefinition {
+    /** Generation method. */
+    method?: GenerationMethod;
+    /** Semantic data type of the field value. */
+    type?: ContentFieldType;
+    /** Field description. */
+    description?: string;
+    /** Field type schema of each array element, if type is array. */
+    itemDefinition?: ContentFieldDefinition;
+    /** Named sub-fields, if type is object. */
+    properties?: Record<string, ContentFieldDefinition>;
+    /** Examples of field values. */
+    examples?: string[];
+    /** Enumeration of possible field values. */
+    enum?: string[];
+    /** Descriptions for each enumeration value. */
+    enumDescriptions?: Record<string, string>;
+    /** Reference to another field definition. */
+    ref?: string;
+    /** Return grounding source and confidence. */
+    estimateSourceAndConfidence?: boolean;
+}
+export declare function contentFieldDefinitionSerializer(item: ContentFieldDefinition): any;
+export declare function contentFieldDefinitionDeserializer(item: any): ContentFieldDefinition;
+/** Generation method. */
+export type GenerationMethod = "generate" | "extract" | "classify";
+/** The location where the data may be processed. */
+export type ProcessingLocation = "geography" | "dataZone" | "global";
+export declare function knowledgeSourceUnionArraySerializer(result: Array<KnowledgeSourceUnion>): any[];
+export declare function knowledgeSourceUnionArrayDeserializer(result: Array<KnowledgeSourceUnion>): any[];
+/** Knowledge source. */
+export interface KnowledgeSource {
+    /** The kind of knowledge source. */
+    /** The discriminator possible values: labeledData */
+    kind: KnowledgeSourceKind;
+}
+export declare function knowledgeSourceSerializer(item: KnowledgeSource): any;
+export declare function knowledgeSourceDeserializer(item: any): KnowledgeSource;
+/** Alias for KnowledgeSourceUnion */
+export type KnowledgeSourceUnion = LabeledDataKnowledgeSource | KnowledgeSource;
+export declare function knowledgeSourceUnionSerializer(item: KnowledgeSourceUnion): any;
+export declare function knowledgeSourceUnionDeserializer(item: any): KnowledgeSourceUnion;
+/** Knowledge source kind. */
+export type KnowledgeSourceKind = "labeledData";
+/** Labeled data knowledge source. */
+export interface LabeledDataKnowledgeSource extends KnowledgeSource {
+    /** A blob container containing labeled data. */
+    kind: "labeledData";
+    /** The URL of the blob container containing labeled data. */
+    containerUrl: string;
+    /** An optional prefix to filter blobs within the container. */
+    prefix?: string;
+    /** An optional path to a file listing specific blobs to include. */
+    fileListPath: string;
+}
+export declare function labeledDataKnowledgeSourceSerializer(item: LabeledDataKnowledgeSource): any;
+export declare function labeledDataKnowledgeSourceDeserializer(item: any): LabeledDataKnowledgeSource;
+/** Chat completion and embedding models supported by the analyzer. */
+export interface SupportedModels {
+    /** Chat completion models supported by the analyzer. */
+    completion?: string[];
+    /** Embedding models supported by the analyzer. */
+    embedding?: string[];
+}
+export declare function supportedModelsDeserializer(item: any): SupportedModels;
+/** Provides status details for analyzer creation operations. */
+export interface ContentAnalyzerOperationStatus {
+    /** The unique ID of the operation. */
+    id: string;
+    /** The status of the operation */
+    status: OperationState;
+    /** Error object that describes the error when status is "Failed". */
+    error?: ErrorModel;
+    /** The result of the operation. */
+    result?: ContentAnalyzer;
+    /** Usage details of the analyzer creation operation. */
+    usage?: UsageDetails;
+}
+export declare function contentAnalyzerOperationStatusDeserializer(item: any): ContentAnalyzerOperationStatus;
+/** Default settings for this Content Understanding resource. */
+export interface ContentUnderstandingDefaults {
+    /** Specify the default mapping of model names to LLM/embedding deployments in Microsoft Foundry. For details and current semantics, see https://aka.ms/cudoc-quickstart-rest. */
+    modelDeployments: Record<string, string>;
+}
+export declare function contentUnderstandingDefaultsDeserializer(item: any): ContentUnderstandingDefaults;
+/** Copy authorization details for cross-resource copy. */
+export interface CopyAuthorization {
+    /** Full path of the source analyzer. */
+    source: string;
+    /** Azure resource ID of the target location to copy to. */
+    targetAzureResourceId: string;
+    /** Date/time when the copy authorization expires. */
+    expiresAt: Date;
+}
+export declare function copyAuthorizationDeserializer(item: any): CopyAuthorization;
+/** Paged collection of ContentAnalyzer items */
+export interface _PagedContentAnalyzer {
+    /** The ContentAnalyzer items on this page */
+    value: ContentAnalyzer[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _pagedContentAnalyzerDeserializer(item: any): _PagedContentAnalyzer;
+export declare function contentAnalyzerArraySerializer(result: Array<ContentAnalyzer>): any[];
+export declare function contentAnalyzerArrayDeserializer(result: Array<ContentAnalyzer>): any[];
+/** model interface RecordMergePatchUpdate */
+export interface RecordMergePatchUpdate {
+    /** Additional properties */
+    additionalProperties?: Record<string, string>;
+}
+export declare function recordMergePatchUpdateSerializer(item: RecordMergePatchUpdate): any;
+/** Service API versions. */
+export declare enum KnownVersions {
+    /** The 2025-11-01 version of the Content Understanding service. */
+    V20251101 = "2025-11-01"
+}
+//# sourceMappingURL=models.d.ts.map