0
# Data Models and Types
1

2
Comprehensive data structures for representing extracted document content, model metadata, and operation results across both legacy Form Recognizer API and modern Document Intelligence API.
3

4
## Core Types and Utilities
5

6
Fundamental types for representing spatial information, document layout, and SDK utilities.
7

8
```python { .api }
9
class Point:
10
    """Coordinate point in document space."""
11
    x: float  # X-coordinate
12
    y: float  # Y-coordinate
13

14
class BoundingRegion:
15
    """Bounding region with page reference."""
16
    page_number: int  # Page number (1-based)
17
    polygon: List[float]  # Polygon coordinates [x1, y1, x2, y2, ...]
18

19
# Long-running operation support
20
class LROPoller:
21
    """Long-running operation poller for tracking async operations."""
22
    def result(self, timeout: Optional[int] = None) -> Any: ...
23
    def status(self) -> str: ...
24
    def done(self) -> bool: ...
25
    def wait(self, timeout: Optional[int] = None) -> None: ...
26
    def cancel(self) -> None: ...
27

28
class DocumentModelAdministrationLROPoller(LROPoller):
29
    """Specialized LRO poller for model administration operations."""
30
    
31
# Paging support for list operations
32
class ItemPaged:
33
    """Paged collection for list operations."""
34
    def __iter__(self): ...
35
    def by_page(self): ...
36

37
class AsyncItemPaged:
38
    """Async paged collection for list operations."""
39
    def __aiter__(self): ...
40
    def by_page(self): ...
41

42
# Async LRO Pollers
43
class AsyncLROPoller:
44
    """Async long-running operation poller."""
45
    async def result(self, timeout: Optional[int] = None) -> Any: ...
46
    def status(self) -> str: ...
47
    def done(self) -> bool: ...
48
    async def wait(self, timeout: Optional[int] = None) -> None: ...
49
    async def cancel(self) -> None: ...
50

51
class AsyncDocumentModelAdministrationLROPoller(AsyncLROPoller):
52
    """Specialized async LRO poller for model administration operations."""
53

54
# Authentication types (from azure.core.credentials and azure.identity)
55
class TokenCredential:
56
    """Token-based credential for Azure Active Directory authentication."""
57
    
58
class AsyncTokenCredential:
59
    """Async token-based credential for Azure Active Directory authentication."""
60

61
class AzureKeyCredential:
62
    """API key-based credential for authentication."""
63
    def __init__(self, key: str): ...
64
    def update(self, key: str) -> None: ...
65
```
66

67
## Legacy Form Recognition Models
68

69
Data structures used by Form Recognizer API v2.1 and below for representing form analysis results.
70

71
### Form Analysis Results
72

73
```python { .api }
74
class RecognizedForm:
75
    """Result of form recognition operation."""
76
    form_type: str  # Type of form recognized
77
    form_type_confidence: Optional[float]  # Confidence in form type prediction
78
    fields: Dict[str, FormField]  # Extracted fields by name
79
    pages: List[FormPage]  # Page-level information
80
    page_range: FormPageRange  # Range of pages analyzed
81

82
class FormField:
83
    """Extracted field from form."""
84
    value: Any  # Extracted value (text, number, date, etc.)
85
    value_type: FieldValueType  # Type of extracted value
86
    label_data: Optional[FieldData]  # Information about field label
87
    value_data: Optional[FieldData]  # Information about field value
88
    confidence: Optional[float]  # Confidence score (0-1)
89

90
class FieldData:
91
    """Spatial and content information for form elements."""
92
    page_number: int  # Page number (1-based)
93
    text: str  # Text content
94
    bounding_box: List[Point]  # Bounding box coordinates
95
    field_elements: Optional[List[FormElement]]  # Constituent elements
96
```
97

98
### Page Structure
99

100
```python { .api }
101
class FormPage:
102
    """Page-level information from form analysis."""
103
    page_number: int  # Page number (1-based)
104
    text_angle: Optional[float]  # Text angle in radians
105
    width: float  # Page width
106
    height: float  # Page height
107
    unit: LengthUnit  # Unit of measurement (pixel, inch)
108
    tables: Optional[List[FormTable]]  # Tables found on page
109
    lines: Optional[List[FormLine]]  # Text lines on page
110
    words: Optional[List[FormWord]]  # Individual words on page
111
    selection_marks: Optional[List[FormSelectionMark]]  # Selection marks on page
112

113
class FormLine:
114
    """Text line in document."""
115
    text: str  # Line text content
116
    bounding_box: List[Point]  # Line bounding box
117
    words: List[FormWord]  # Words in the line
118
    appearance: Optional[TextAppearance]  # Text styling information
119

120
class FormWord:
121
    """Individual word in document."""
122
    text: str  # Word text
123
    bounding_box: List[Point]  # Word bounding box
124
    confidence: Optional[float]  # Recognition confidence
125
    page_number: Optional[int]  # Page number
126

127
class FormSelectionMark:
128
    """Selection mark (checkbox, radio button) in document."""
129
    state: str  # "selected", "unselected"
130
    bounding_box: List[Point]  # Mark bounding box
131
    confidence: Optional[float]  # Recognition confidence
132
    page_number: Optional[int]  # Page number
133
```
134

135
### Table Structures
136

137
```python { .api }
138
class FormTable:
139
    """Table structure in form."""
140
    row_count: int  # Number of rows
141
    column_count: int  # Number of columns
142
    cells: List[FormTableCell]  # Table cells
143
    bounding_box: Optional[List[Point]]  # Table bounding box
144
    page_number: Optional[int]  # Page number
145

146
class FormTableCell:
147
    """Cell within a form table."""
148
    text: str  # Cell text content
149
    row_index: int  # Row index (0-based)
150
    column_index: int  # Column index (0-based)
151
    row_span: Optional[int]  # Number of rows spanned
152
    column_span: Optional[int]  # Number of columns spanned
153
    bounding_box: List[Point]  # Cell bounding box
154
    confidence: Optional[float]  # Recognition confidence
155
    field_elements: Optional[List[FormElement]]  # Constituent elements
156
    is_header: Optional[bool]  # Whether cell is a header
157
    is_footer: Optional[bool]  # Whether cell is a footer
158
    page_number: Optional[int]  # Page number
159
```
160

161
### Model Information
162

163
```python { .api }
164
class CustomFormModel:
165
    """Information about a custom trained model."""
166
    model_id: str  # Unique model identifier
167
    status: CustomFormModelStatus  # Model status (Creating, Ready, Invalid)
168
    training_started_on: datetime  # Training start time
169
    training_completed_on: Optional[datetime]  # Training completion time
170
    submodels: List[CustomFormSubmodel]  # Model subcomponents
171
    errors: Optional[List[FormRecognizerError]]  # Training errors
172
    training_documents: Optional[List[TrainingDocumentInfo]]  # Training data info
173
    properties: Optional[CustomFormModelProperties]  # Additional properties
174
    model_name: Optional[str]  # User-assigned model name
175

176
class CustomFormSubmodel:
177
    """Submodel within a custom form model."""
178
    form_type: str  # Form type identifier
179
    accuracy: Optional[float]  # Model accuracy
180
    fields: Optional[Dict[str, CustomFormModelField]]  # Field definitions
181
    model_id: Optional[str]  # Associated model ID
182

183
class CustomFormModelField:
184
    """Field definition in custom model."""
185
    field_name: str  # Field name
186
    label: Optional[str]  # Field label
187
    accuracy: Optional[float]  # Field extraction accuracy
188

189
class CustomFormModelInfo:
190
    """Summary information about custom model."""
191
    model_id: str  # Model identifier
192
    status: CustomFormModelStatus  # Current model status
193
    training_started_on: datetime  # Training start time
194
    training_completed_on: Optional[datetime]  # Training completion time
195
    properties: Optional[CustomFormModelProperties]  # Model properties
196
    model_name: Optional[str]  # User-assigned name
197

198
class TrainingDocumentInfo:
199
    """Information about training document."""
200
    name: str  # Document name
201
    status: TrainingStatus  # Training status for this document
202
    page_count: int  # Number of pages
203
    errors: Optional[List[FormRecognizerError]]  # Document-specific errors
204
    model_id: Optional[str]  # Associated model ID
205

206
class AccountProperties:
207
    """Form Recognizer account information."""
208
    custom_model_count: int  # Current number of custom models
209
    custom_model_limit: int  # Maximum allowed custom models
210
```
211

212
## Modern Document Analysis Models
213

214
Data structures used by Document Intelligence API 2022-08-31 and later for advanced document analysis.
215

216
### Analysis Results
217

218
```python { .api }
219
class AnalyzeResult:
220
    """Complete document analysis result."""
221
    api_version: str  # API version used
222
    model_id: str  # Model used for analysis
223
    content: str  # Extracted text content
224
    pages: Optional[List[DocumentPage]]  # Page-level information
225
    paragraphs: Optional[List[DocumentParagraph]]  # Paragraph information
226
    tables: Optional[List[DocumentTable]]  # Table structures
227
    key_value_pairs: Optional[List[DocumentKeyValuePair]]  # Key-value pairs
228
    entities: Optional[List[Any]]  # Named entities (not fully typed)
229
    styles: Optional[List[DocumentStyle]]  # Text styling information
230
    languages: Optional[List[DocumentLanguage]]  # Language information
231
    documents: Optional[List[AnalyzedDocument]]  # Structured documents
232
    warnings: Optional[List[Any]]  # Analysis warnings
233

234
class AnalyzedDocument:
235
    """Structured document within analysis result."""
236
    doc_type: str  # Document type
237
    bounding_regions: Optional[List[BoundingRegion]]  # Document boundaries
238
    spans: Optional[List[DocumentSpan]]  # Text spans
239
    fields: Optional[Dict[str, DocumentField]]  # Extracted fields
240
    confidence: Optional[float]  # Document type confidence
241
```
242

243
### Document Structure
244

245
```python { .api }
246
class DocumentPage:
247
    """Page-level document information."""
248
    page_number: int  # Page number (1-based)
249
    angle: Optional[float]  # Page rotation angle
250
    width: Optional[float]  # Page width
251
    height: Optional[float]  # Page height
252
    unit: Optional[str]  # Unit of measurement
253
    spans: Optional[List[DocumentSpan]]  # Text spans on page
254
    words: Optional[List[DocumentWord]]  # Words on page
255
    selection_marks: Optional[List[DocumentSelectionMark]]  # Selection marks
256
    lines: Optional[List[DocumentLine]]  # Text lines
257
    barcodes: Optional[List[DocumentBarcode]]  # Barcodes (API v2023-07-31)
258
    formulas: Optional[List[DocumentFormula]]  # Formulas (API v2023-07-31)
259

260
class DocumentWord:
261
    """Individual word in document."""
262
    content: str  # Word text
263
    polygon: Optional[List[float]]  # Word boundary polygon
264
    span: DocumentSpan  # Text span reference
265
    confidence: Optional[float]  # Recognition confidence
266

267
class DocumentLine:
268
    """Text line in document."""
269
    content: str  # Line text
270
    polygon: Optional[List[float]]  # Line boundary polygon
271
    spans: Optional[List[DocumentSpan]]  # Text spans
272

273
class DocumentParagraph:
274
    """Paragraph in document."""
275
    role: Optional[str]  # Paragraph role (title, sectionHeading, etc.)
276
    content: str  # Paragraph text
277
    bounding_regions: Optional[List[BoundingRegion]]  # Paragraph boundaries
278
    spans: List[DocumentSpan]  # Text spans
279

280
class DocumentSpan:
281
    """Text span reference."""
282
    offset: int  # Character offset in content
283
    length: int  # Span length in characters
284
```
285

286
### Enhanced Content (API v2023-07-31)
287

288
```python { .api }
289
class DocumentBarcode:
290
    """Barcode information extracted from document."""
291
    kind: str  # Barcode type (QRCode, PDF417, UPCA, etc.)
292
    value: str  # Decoded barcode value
293
    polygon: Optional[List[float]]  # Barcode boundary
294
    span: DocumentSpan  # Text span reference
295
    confidence: Optional[float]  # Detection confidence
296
    page_number: int  # Page number
297

298
class DocumentFormula:
299
    """Mathematical formula in document."""
300
    kind: str  # Formula type (inline, display)
301
    value: str  # Formula expression (LaTeX format)
302
    polygon: Optional[List[float]]  # Formula boundary
303
    span: DocumentSpan  # Text span reference
304
    confidence: Optional[float]  # Detection confidence
305
    page_number: int  # Page number
306
```
307

308
### Field Types and Values
309

310
```python { .api }
311
class DocumentField:
312
    """Extracted field from document."""
313
    value_type: str  # Field value type
314
    value: Any  # Extracted value (varies by type)
315
    content: Optional[str]  # Raw text content
316
    bounding_regions: Optional[List[BoundingRegion]]  # Field boundaries
317
    spans: Optional[List[DocumentSpan]]  # Text spans
318
    confidence: Optional[float]  # Extraction confidence
319

320
class AddressValue:
321
    """Structured address value."""
322
    house_number: Optional[str]  # House number
323
    po_box: Optional[str]  # PO Box
324
    road: Optional[str]  # Street name
325
    city: Optional[str]  # City name
326
    state: Optional[str]  # State/province
327
    postal_code: Optional[str]  # Postal/ZIP code
328
    country_region: Optional[str]  # Country
329
    street_address: Optional[str]  # Full street address
330
    unit: Optional[str]  # Unit/apartment number
331
    city_district: Optional[str]  # City district
332
    state_district: Optional[str]  # State district
333
    suburb: Optional[str]  # Suburb
334
    house: Optional[str]  # House name
335
    level: Optional[str]  # Floor level
336

337
class CurrencyValue:
338
    """Currency amount value."""
339
    amount: float  # Numeric amount
340
    symbol: Optional[str]  # Currency symbol ($, €, etc.)
341
    code: Optional[str]  # Currency code (USD, EUR, etc.)
342
```
343

344
### Table Structures
345

346
```python { .api }
347
class DocumentTable:
348
    """Table structure in document."""
349
    row_count: int  # Number of rows
350
    column_count: int  # Number of columns
351
    cells: List[DocumentTableCell]  # Table cells
352
    bounding_regions: Optional[List[BoundingRegion]]  # Table boundaries
353
    spans: Optional[List[DocumentSpan]]  # Text spans
354
    caption: Optional[str]  # Table caption
355

356
class DocumentTableCell:
357
    """Cell within document table."""
358
    kind: Optional[str]  # Cell kind (content, rowHeader, columnHeader, etc.)
359
    row_index: int  # Row index (0-based)
360
    column_index: int  # Column index (0-based)
361
    row_span: Optional[int]  # Rows spanned
362
    column_span: Optional[int]  # Columns spanned
363
    content: str  # Cell text content
364
    bounding_regions: Optional[List[BoundingRegion]]  # Cell boundaries
365
    spans: Optional[List[DocumentSpan]]  # Text spans
366
    elements: Optional[List[str]]  # References to constituent elements
367
```
368

369
### Key-Value Pairs
370

371
```python { .api }
372
class DocumentKeyValuePair:
373
    """Key-value pair extracted from document."""
374
    key: DocumentKeyValueElement  # Key element
375
    value: Optional[DocumentKeyValueElement]  # Value element
376
    confidence: Optional[float]  # Extraction confidence
377

378
class DocumentKeyValueElement:
379
    """Element of key-value pair."""
380
    content: str  # Text content
381
    bounding_regions: Optional[List[BoundingRegion]]  # Element boundaries
382
    spans: Optional[List[DocumentSpan]]  # Text spans
383
```
384

385
### Language and Styling
386

387
```python { .api }
388
class DocumentLanguage:
389
    """Language information for document content."""
390
    locale: str  # Language locale (e.g., "en-US")
391
    spans: List[DocumentSpan]  # Text spans in this language
392
    confidence: Optional[float]  # Language detection confidence
393

394
class DocumentStyle:
395
    """Text styling information."""
396
    is_handwritten: Optional[bool]  # Whether text is handwritten
397
    similar_font_family: Optional[str]  # Similar font family name
398
    font_style: Optional[str]  # Font style (normal, italic)
399
    font_weight: Optional[str]  # Font weight (normal, bold)
400
    color: Optional[str]  # Text color (hex format)
401
    background_color: Optional[str]  # Background color (hex format)
402
    spans: List[DocumentSpan]  # Text spans with this style
403
    confidence: Optional[float]  # Style detection confidence
404

405
class DocumentSelectionMark:
406
    """Selection mark in document."""
407
    state: str  # Selection state ("selected", "unselected")
408
    polygon: Optional[List[float]]  # Mark boundary
409
    span: DocumentSpan  # Text span reference
410
    confidence: Optional[float]  # Detection confidence
411
```
412

413
## Model Administration Models
414

415
Data structures for model lifecycle management and operation monitoring.
416

417
### Model Information
418

419
```python { .api }
420
class DocumentModelDetails:
421
    """Detailed information about document model."""
422
    model_id: str  # Model identifier
423
    description: Optional[str]  # Model description
424
    created_date_time: datetime  # Creation timestamp
425
    api_version: str  # API version used to create model
426
    tags: Optional[Dict[str, str]]  # Custom tags
427
    doc_types: Optional[Dict[str, DocumentTypeDetails]]  # Supported document types
428
    expires_date_time: Optional[datetime]  # Model expiration time
429

430
class DocumentModelSummary:
431
    """Summary information about document model."""
432
    model_id: str  # Model identifier
433
    description: Optional[str]  # Model description
434
    created_date_time: datetime  # Creation timestamp
435
    api_version: str  # API version
436
    tags: Optional[Dict[str, str]]  # Custom tags
437
    expires_date_time: Optional[datetime]  # Expiration time
438

439
class DocumentTypeDetails:
440
    """Details about document type supported by model."""
441
    description: Optional[str]  # Document type description
442
    build_mode: Optional[str]  # Build mode used (template, neural)
443
    field_schema: Optional[Dict[str, Any]]  # Field schema definition
444
    field_confidence: Optional[Dict[str, float]]  # Field confidence scores
445
```
446

447
### Classifier Information
448

449
```python { .api }
450
class DocumentClassifierDetails:
451
    """Information about document classifier."""
452
    classifier_id: str  # Classifier identifier
453
    description: Optional[str]  # Classifier description
454
    created_date_time: datetime  # Creation timestamp
455
    api_version: str  # API version
456
    doc_types: Dict[str, ClassifierDocumentTypeDetails]  # Document types
457
    expires_date_time: Optional[datetime]  # Expiration time
458

459
class ClassifierDocumentTypeDetails:
460
    """Document type details for classifier."""
461
    source_kind: Optional[str]  # Training data source type
462
    azure_blob_source: Optional[BlobSource]  # Blob storage source
463
    azure_blob_file_list_source: Optional[BlobFileListSource]  # File list source
464

465
class BlobSource:
466
    """Azure Blob Storage source configuration."""
467
    container_url: str  # Container URL with SAS token
468
    prefix: Optional[str]  # File prefix filter
469

470
class BlobFileListSource:
471
    """Azure Blob Storage file list source."""
472
    container_url: str  # Container URL with SAS token
473
    file_list: str  # JSON file with file list
474

475
class DocumentModelBuildOperationDetails:
476
    """Details for document model build operations."""
477
    operation_id: str  # Operation identifier
478
    status: str  # Current status
479
    percent_completed: Optional[int]  # Completion percentage
480
    created_date_time: datetime  # Creation time
481
    last_updated_date_time: datetime  # Last update time
482
    kind: str  # Operation type
483
    resource_location: Optional[str]  # Resource location
484
    api_version: Optional[str]  # API version
485
    tags: Optional[Dict[str, str]]  # Operation tags
486
    error: Optional[DocumentAnalysisError]  # Error information if failed
487
    result: Optional[DocumentModelDetails]  # Operation result if succeeded
488
```
489

490
### Operations and Resources
491

492
```python { .api }
493
class OperationSummary:
494
    """Summary of long-running operation."""
495
    operation_id: str  # Operation identifier
496
    status: str  # Operation status (notStarted, running, succeeded, failed)
497
    percent_completed: Optional[int]  # Completion percentage
498
    created_date_time: datetime  # Operation start time
499
    last_updated_date_time: datetime  # Last update time
500
    kind: str  # Operation kind (documentModelBuild, documentModelCompose, etc.)
501
    resource_location: Optional[str]  # Location of created resource
502

503
class OperationDetails:
504
    """Detailed information about operation."""
505
    operation_id: str  # Operation identifier
506
    status: str  # Current status
507
    percent_completed: Optional[int]  # Completion percentage
508
    created_date_time: datetime  # Creation time
509
    last_updated_date_time: datetime  # Last update time
510
    kind: str  # Operation type
511
    resource_location: Optional[str]  # Resource location
512
    api_version: Optional[str]  # API version
513
    tags: Optional[Dict[str, str]]  # Operation tags
514
    error: Optional[DocumentAnalysisError]  # Error information if failed
515
    result: Optional[Any]  # Operation result if succeeded
516

517
class ResourceDetails:
518
    """Information about Form Recognizer resource."""
519
    custom_document_models: CustomDocumentModelsDetails  # Custom model info
520
    neural_document_model_quota: QuotaDetails  # Neural model quota
521

522
class CustomDocumentModelsDetails:
523
    """Custom document model quota information."""
524
    count: int  # Current number of custom models
525
    limit: int  # Maximum allowed custom models
526

527
class QuotaDetails:
528
    """Quota information for specific resource type."""
529
    used: int  # Currently used quota
530
    quota: int  # Total available quota
531
    quota_resets_on: Optional[datetime]  # Quota reset time
532

533
class TargetAuthorization:
534
    """Authorization for model copying."""
535
    target_resource_id: str  # Target resource identifier
536
    target_resource_region: str  # Target resource region
537
    target_model_id: str  # Target model identifier
538
    target_model_location: str  # Target model location URL
539
    access_token: str  # Access token for copying
540
    expiration_date_time: datetime  # Token expiration time
541
```
542

543
## Enums and Constants
544

545
```python { .api }
546
class FieldValueType(str, Enum):
547
    """Types of field values that can be extracted."""
548
    STRING = "string"
549
    DATE = "date"
550
    TIME = "time"
551
    PHONE_NUMBER = "phoneNumber"
552
    NUMBER = "number"  # Legacy - use FLOAT for new code
553
    FLOAT = "float"
554
    INTEGER = "integer"
555
    SELECTION_MARK = "selectionMark"
556
    COUNTRY_REGION = "countryRegion"
557
    SIGNATURE = "signature"
558
    ARRAY = "array"  # Legacy - use LIST for new code
559
    LIST = "list"
560
    OBJECT = "object"  # Legacy - use DICTIONARY for new code
561
    DICTIONARY = "dictionary"
562
    CURRENCY = "currency"
563
    ADDRESS = "address"
564

565
class LengthUnit(str, Enum):
566
    """Units of measurement for dimensions."""
567
    PIXEL = "pixel"
568
    INCH = "inch"
569

570
class TrainingStatus(str, Enum):
571
    """Status of training operations."""
572
    SUCCEEDED = "succeeded"
573
    PARTIALLY_SUCCEEDED = "partiallySucceeded"
574
    FAILED = "failed"
575

576
class CustomFormModelStatus(str, Enum):
577
    """Status of custom form models."""
578
    CREATING = "creating"
579
    READY = "ready"
580
    INVALID = "invalid"
581

582
class ModelBuildMode(str, Enum):
583
    """Model building approaches."""
584
    TEMPLATE = "template"  # Fast, structured documents
585
    NEURAL = "neural"     # Slower, better for varied layouts
586

587
class AnalysisFeature(str, Enum):
588
    """Enhanced analysis features."""
589
    OCR_HIGH_RESOLUTION = "ocrHighResolution"
590
    LANGUAGES = "languages"
591
    BARCODES = "barcodes"
592
    FORMULAS = "formulas"
593
    KEY_VALUE_PAIRS = "keyValuePairs"
594
    STYLE_FONT = "styleFont"
595
```
596

597
## Error Models
598

599
```python { .api }
600
class FormRecognizerError:
601
    """Error information from Form Recognizer API."""
602
    error_code: str  # Error code
603
    message: str  # Error message
604

605
class DocumentAnalysisError:
606
    """Error information from Document Intelligence API."""
607
    code: str  # Error code
608
    message: str  # Error message
609
    target: Optional[str]  # Error target
610
    details: Optional[List['DocumentAnalysisError']]  # Nested errors
611
    innererror: Optional['DocumentAnalysisInnerError']  # Inner error details
612

613
class DocumentAnalysisInnerError:
614
    """Inner error details."""
615
    code: str  # Inner error code
616
    message: str  # Inner error message
617
    innererror: Optional['DocumentAnalysisInnerError']  # Nested inner error
618
```
619

620
## Usage Examples
621

622
### Accessing Extracted Data
623

624
```python
625
# Legacy API - access form fields
626
for form in recognized_forms:
627
    vendor_name = form.fields.get("VendorName")
628
    if vendor_name and vendor_name.value:
629
        print(f"Vendor: {vendor_name.value}")
630
        print(f"Confidence: {vendor_name.confidence}")
631
        
632
        # Access spatial information
633
        if vendor_name.value_data:
634
            print(f"Location: Page {vendor_name.value_data.page_number}")
635
            bbox = vendor_name.value_data.bounding_box
636
            print(f"Bounding box: {[(p.x, p.y) for p in bbox]}")
637

638
# Modern API - access document fields
639
for document in analyze_result.documents:
640
    vendor_name = document.fields.get("VendorName")
641
    if vendor_name and vendor_name.value:
642
        print(f"Vendor: {vendor_name.value}")
643
        print(f"Confidence: {vendor_name.confidence}")
644
        
645
        # Access spatial information
646
        if vendor_name.bounding_regions:
647
            for region in vendor_name.bounding_regions:
648
                print(f"Page {region.page_number}: {region.polygon}")
649
```
650

651
### Working with Tables
652

653
```python
654
# Legacy API tables
655
for table in form_page.tables:
656
    print(f"Table: {table.row_count}x{table.column_count}")
657
    for cell in table.cells:
658
        print(f"Cell [{cell.row_index}, {cell.column_index}]: {cell.text}")
659

660
# Modern API tables  
661
for table in analyze_result.tables:
662
    print(f"Table: {table.row_count}x{table.column_count}")
663
    if table.caption:
664
        print(f"Caption: {table.caption}")
665
    
666
    for cell in table.cells:
667
        kind = cell.kind or "content"
668
        print(f"{kind.title()} [{cell.row_index}, {cell.column_index}]: {cell.content}")
669
```