# Auto-generated by packages/sdk/codegen/src/generate-python.mjs

from __future__ import annotations

from typing import Any, Literal, TypedDict

from ..runtime import SuperDocSyncRuntime, SuperDocAsyncRuntime

DocFindResultContextItemAddressVariant1 = TypedDict(
    "DocFindResultContextItemAddressVariant1",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"],
    },
    total=False,
)

DocFindResultContextItemAddressVariant2AnchorEnd = TypedDict(
    "DocFindResultContextItemAddressVariant2AnchorEnd",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindResultContextItemAddressVariant2AnchorStart = TypedDict(
    "DocFindResultContextItemAddressVariant2AnchorStart",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindResultContextItemAddressVariant2Anchor = TypedDict(
    "DocFindResultContextItemAddressVariant2Anchor",
    {
        "end": DocFindResultContextItemAddressVariant2AnchorEnd,
        "start": DocFindResultContextItemAddressVariant2AnchorStart,
    },
    total=False,
)

DocFindResultContextItemAddressVariant2 = TypedDict(
    "DocFindResultContextItemAddressVariant2",
    {
        "anchor": DocFindResultContextItemAddressVariant2Anchor,
        "kind": Literal["inline"],
        "nodeType": Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["sdt"] | Literal["image"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
    },
    total=False,
)

DocFindResultContextItemHighlightRange = TypedDict(
    "DocFindResultContextItemHighlightRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFindResultContextItemTextRangesItemRange = TypedDict(
    "DocFindResultContextItemTextRangesItemRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFindResultContextItemTextRangesItem = TypedDict(
    "DocFindResultContextItemTextRangesItem",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFindResultContextItemTextRangesItemRange,
    },
    total=False,
)

DocFindResultContextItem = TypedDict(
    "DocFindResultContextItem",
    {
        "address": DocFindResultContextItemAddressVariant1 | DocFindResultContextItemAddressVariant2,
        "highlightRange": DocFindResultContextItemHighlightRange,
        "snippet": str,
        "textRanges": list[DocFindResultContextItemTextRangesItem],
    },
    total=False,
)

DocFindResultDiagnosticsItemAddressVariant1 = TypedDict(
    "DocFindResultDiagnosticsItemAddressVariant1",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"],
    },
    total=False,
)

DocFindResultDiagnosticsItemAddressVariant2AnchorEnd = TypedDict(
    "DocFindResultDiagnosticsItemAddressVariant2AnchorEnd",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindResultDiagnosticsItemAddressVariant2AnchorStart = TypedDict(
    "DocFindResultDiagnosticsItemAddressVariant2AnchorStart",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindResultDiagnosticsItemAddressVariant2Anchor = TypedDict(
    "DocFindResultDiagnosticsItemAddressVariant2Anchor",
    {
        "end": DocFindResultDiagnosticsItemAddressVariant2AnchorEnd,
        "start": DocFindResultDiagnosticsItemAddressVariant2AnchorStart,
    },
    total=False,
)

DocFindResultDiagnosticsItemAddressVariant2 = TypedDict(
    "DocFindResultDiagnosticsItemAddressVariant2",
    {
        "anchor": DocFindResultDiagnosticsItemAddressVariant2Anchor,
        "kind": Literal["inline"],
        "nodeType": Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["sdt"] | Literal["image"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
    },
    total=False,
)

DocFindResultDiagnosticsItem = TypedDict(
    "DocFindResultDiagnosticsItem",
    {
        "address": DocFindResultDiagnosticsItemAddressVariant1 | DocFindResultDiagnosticsItemAddressVariant2,
        "hint": str,
        "message": str,
    },
    total=False,
)

DocFindResultMatchesItemVariant1 = TypedDict(
    "DocFindResultMatchesItemVariant1",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"],
    },
    total=False,
)

DocFindResultMatchesItemVariant2AnchorEnd = TypedDict(
    "DocFindResultMatchesItemVariant2AnchorEnd",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindResultMatchesItemVariant2AnchorStart = TypedDict(
    "DocFindResultMatchesItemVariant2AnchorStart",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindResultMatchesItemVariant2Anchor = TypedDict(
    "DocFindResultMatchesItemVariant2Anchor",
    {
        "end": DocFindResultMatchesItemVariant2AnchorEnd,
        "start": DocFindResultMatchesItemVariant2AnchorStart,
    },
    total=False,
)

DocFindResultMatchesItemVariant2 = TypedDict(
    "DocFindResultMatchesItemVariant2",
    {
        "anchor": DocFindResultMatchesItemVariant2Anchor,
        "kind": Literal["inline"],
        "nodeType": Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["sdt"] | Literal["image"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
    },
    total=False,
)

DocFindResultNodesItemBodyNodesItem = TypedDict(
    "DocFindResultNodesItemBodyNodesItem",
    {
    },
    total=False,
)

DocFindResultNodesItemNodesItem = TypedDict(
    "DocFindResultNodesItemNodesItem",
    {
    },
    total=False,
)

DocFindResultNodesItemProperties = TypedDict(
    "DocFindResultNodesItemProperties",
    {
    },
    total=False,
)

DocFindResultNodesItemSummary = TypedDict(
    "DocFindResultNodesItemSummary",
    {
        "label": str,
        "text": str,
    },
    total=False,
)

DocFindResultNodesItem = TypedDict(
    "DocFindResultNodesItem",
    {
        "bodyNodes": list[DocFindResultNodesItemBodyNodesItem],
        "bodyText": str,
        "kind": Literal["block"] | Literal["inline"],
        "nodes": list[DocFindResultNodesItemNodesItem],
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"] | Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
        "properties": DocFindResultNodesItemProperties,
        "summary": DocFindResultNodesItemSummary,
        "text": str,
    },
    total=False,
)

DocFindResult = TypedDict(
    "DocFindResult",
    {
        "context": list[DocFindResultContextItem],
        "diagnostics": list[DocFindResultDiagnosticsItem],
        "matches": list[DocFindResultMatchesItemVariant1 | DocFindResultMatchesItemVariant2],
        "nodes": list[DocFindResultNodesItem],
        "total": int | float,
    },
    total=False,
)

DocGetNodeResultBodyNodesItem = TypedDict(
    "DocGetNodeResultBodyNodesItem",
    {
    },
    total=False,
)

DocGetNodeResultNodesItem = TypedDict(
    "DocGetNodeResultNodesItem",
    {
    },
    total=False,
)

DocGetNodeResultProperties = TypedDict(
    "DocGetNodeResultProperties",
    {
    },
    total=False,
)

DocGetNodeResultSummary = TypedDict(
    "DocGetNodeResultSummary",
    {
        "label": str,
        "text": str,
    },
    total=False,
)

DocGetNodeResult = TypedDict(
    "DocGetNodeResult",
    {
        "bodyNodes": list[DocGetNodeResultBodyNodesItem],
        "bodyText": str,
        "kind": Literal["block"] | Literal["inline"],
        "nodes": list[DocGetNodeResultNodesItem],
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"] | Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
        "properties": DocGetNodeResultProperties,
        "summary": DocGetNodeResultSummary,
        "text": str,
    },
    total=False,
)

DocGetNodeByIdResultBodyNodesItem = TypedDict(
    "DocGetNodeByIdResultBodyNodesItem",
    {
    },
    total=False,
)

DocGetNodeByIdResultNodesItem = TypedDict(
    "DocGetNodeByIdResultNodesItem",
    {
    },
    total=False,
)

DocGetNodeByIdResultProperties = TypedDict(
    "DocGetNodeByIdResultProperties",
    {
    },
    total=False,
)

DocGetNodeByIdResultSummary = TypedDict(
    "DocGetNodeByIdResultSummary",
    {
        "label": str,
        "text": str,
    },
    total=False,
)

DocGetNodeByIdResult = TypedDict(
    "DocGetNodeByIdResult",
    {
        "bodyNodes": list[DocGetNodeByIdResultBodyNodesItem],
        "bodyText": str,
        "kind": Literal["block"] | Literal["inline"],
        "nodes": list[DocGetNodeByIdResultNodesItem],
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"] | Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
        "properties": DocGetNodeByIdResultProperties,
        "summary": DocGetNodeByIdResultSummary,
        "text": str,
    },
    total=False,
)

DocInfoResultCapabilities = TypedDict(
    "DocInfoResultCapabilities",
    {
        "canComment": bool,
        "canFind": bool,
        "canGetNode": bool,
        "canReplace": bool,
    },
    total=False,
)

DocInfoResultCounts = TypedDict(
    "DocInfoResultCounts",
    {
        "comments": int | float,
        "headings": int | float,
        "images": int | float,
        "paragraphs": int | float,
        "tables": int | float,
        "words": int | float,
    },
    total=False,
)

DocInfoResultOutlineItem = TypedDict(
    "DocInfoResultOutlineItem",
    {
        "level": int | float,
        "nodeId": str,
        "text": str,
    },
    total=False,
)

DocInfoResult = TypedDict(
    "DocInfoResult",
    {
        "capabilities": DocInfoResultCapabilities,
        "counts": DocInfoResultCounts,
        "outline": list[DocInfoResultOutlineItem],
    },
    total=False,
)

DocInsertResultInsertedItemVariant1 = TypedDict(
    "DocInsertResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocInsertResultInsertedItemVariant2 = TypedDict(
    "DocInsertResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocInsertResultRemovedItemVariant1 = TypedDict(
    "DocInsertResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocInsertResultRemovedItemVariant2 = TypedDict(
    "DocInsertResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocInsertResultResolutionRange = TypedDict(
    "DocInsertResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocInsertResultResolutionRequestedTargetRange = TypedDict(
    "DocInsertResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocInsertResultResolutionRequestedTarget = TypedDict(
    "DocInsertResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocInsertResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocInsertResultResolutionTargetRange = TypedDict(
    "DocInsertResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocInsertResultResolutionTarget = TypedDict(
    "DocInsertResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocInsertResultResolutionTargetRange,
    },
    total=False,
)

DocInsertResultResolution = TypedDict(
    "DocInsertResultResolution",
    {
        "range": DocInsertResultResolutionRange,
        "requestedTarget": DocInsertResultResolutionRequestedTarget,
        "target": DocInsertResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocInsertResultUpdatedItemVariant1 = TypedDict(
    "DocInsertResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocInsertResultUpdatedItemVariant2 = TypedDict(
    "DocInsertResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocInsertResult = TypedDict(
    "DocInsertResult",
    {
        "inserted": list[DocInsertResultInsertedItemVariant1 | DocInsertResultInsertedItemVariant2],
        "removed": list[DocInsertResultRemovedItemVariant1 | DocInsertResultRemovedItemVariant2],
        "resolution": DocInsertResultResolution,
        "success": Literal[True],
        "updated": list[DocInsertResultUpdatedItemVariant1 | DocInsertResultUpdatedItemVariant2],
    },
    total=False,
)

DocReplaceResultInsertedItemVariant1 = TypedDict(
    "DocReplaceResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocReplaceResultInsertedItemVariant2 = TypedDict(
    "DocReplaceResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocReplaceResultRemovedItemVariant1 = TypedDict(
    "DocReplaceResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocReplaceResultRemovedItemVariant2 = TypedDict(
    "DocReplaceResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocReplaceResultResolutionRange = TypedDict(
    "DocReplaceResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocReplaceResultResolutionRequestedTargetRange = TypedDict(
    "DocReplaceResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocReplaceResultResolutionRequestedTarget = TypedDict(
    "DocReplaceResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocReplaceResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocReplaceResultResolutionTargetRange = TypedDict(
    "DocReplaceResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocReplaceResultResolutionTarget = TypedDict(
    "DocReplaceResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocReplaceResultResolutionTargetRange,
    },
    total=False,
)

DocReplaceResultResolution = TypedDict(
    "DocReplaceResultResolution",
    {
        "range": DocReplaceResultResolutionRange,
        "requestedTarget": DocReplaceResultResolutionRequestedTarget,
        "target": DocReplaceResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocReplaceResultUpdatedItemVariant1 = TypedDict(
    "DocReplaceResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocReplaceResultUpdatedItemVariant2 = TypedDict(
    "DocReplaceResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocReplaceResult = TypedDict(
    "DocReplaceResult",
    {
        "inserted": list[DocReplaceResultInsertedItemVariant1 | DocReplaceResultInsertedItemVariant2],
        "removed": list[DocReplaceResultRemovedItemVariant1 | DocReplaceResultRemovedItemVariant2],
        "resolution": DocReplaceResultResolution,
        "success": Literal[True],
        "updated": list[DocReplaceResultUpdatedItemVariant1 | DocReplaceResultUpdatedItemVariant2],
    },
    total=False,
)

DocDeleteResultInsertedItemVariant1 = TypedDict(
    "DocDeleteResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocDeleteResultInsertedItemVariant2 = TypedDict(
    "DocDeleteResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocDeleteResultRemovedItemVariant1 = TypedDict(
    "DocDeleteResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocDeleteResultRemovedItemVariant2 = TypedDict(
    "DocDeleteResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocDeleteResultResolutionRange = TypedDict(
    "DocDeleteResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocDeleteResultResolutionRequestedTargetRange = TypedDict(
    "DocDeleteResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocDeleteResultResolutionRequestedTarget = TypedDict(
    "DocDeleteResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocDeleteResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocDeleteResultResolutionTargetRange = TypedDict(
    "DocDeleteResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocDeleteResultResolutionTarget = TypedDict(
    "DocDeleteResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocDeleteResultResolutionTargetRange,
    },
    total=False,
)

DocDeleteResultResolution = TypedDict(
    "DocDeleteResultResolution",
    {
        "range": DocDeleteResultResolutionRange,
        "requestedTarget": DocDeleteResultResolutionRequestedTarget,
        "target": DocDeleteResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocDeleteResultUpdatedItemVariant1 = TypedDict(
    "DocDeleteResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocDeleteResultUpdatedItemVariant2 = TypedDict(
    "DocDeleteResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocDeleteResult = TypedDict(
    "DocDeleteResult",
    {
        "inserted": list[DocDeleteResultInsertedItemVariant1 | DocDeleteResultInsertedItemVariant2],
        "removed": list[DocDeleteResultRemovedItemVariant1 | DocDeleteResultRemovedItemVariant2],
        "resolution": DocDeleteResultResolution,
        "success": Literal[True],
        "updated": list[DocDeleteResultUpdatedItemVariant1 | DocDeleteResultUpdatedItemVariant2],
    },
    total=False,
)

DocFormatBoldResultInsertedItemVariant1 = TypedDict(
    "DocFormatBoldResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatBoldResultInsertedItemVariant2 = TypedDict(
    "DocFormatBoldResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatBoldResultRemovedItemVariant1 = TypedDict(
    "DocFormatBoldResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatBoldResultRemovedItemVariant2 = TypedDict(
    "DocFormatBoldResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatBoldResultResolutionRange = TypedDict(
    "DocFormatBoldResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocFormatBoldResultResolutionRequestedTargetRange = TypedDict(
    "DocFormatBoldResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatBoldResultResolutionRequestedTarget = TypedDict(
    "DocFormatBoldResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatBoldResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocFormatBoldResultResolutionTargetRange = TypedDict(
    "DocFormatBoldResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatBoldResultResolutionTarget = TypedDict(
    "DocFormatBoldResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatBoldResultResolutionTargetRange,
    },
    total=False,
)

DocFormatBoldResultResolution = TypedDict(
    "DocFormatBoldResultResolution",
    {
        "range": DocFormatBoldResultResolutionRange,
        "requestedTarget": DocFormatBoldResultResolutionRequestedTarget,
        "target": DocFormatBoldResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocFormatBoldResultUpdatedItemVariant1 = TypedDict(
    "DocFormatBoldResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatBoldResultUpdatedItemVariant2 = TypedDict(
    "DocFormatBoldResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatBoldResult = TypedDict(
    "DocFormatBoldResult",
    {
        "inserted": list[DocFormatBoldResultInsertedItemVariant1 | DocFormatBoldResultInsertedItemVariant2],
        "removed": list[DocFormatBoldResultRemovedItemVariant1 | DocFormatBoldResultRemovedItemVariant2],
        "resolution": DocFormatBoldResultResolution,
        "success": Literal[True],
        "updated": list[DocFormatBoldResultUpdatedItemVariant1 | DocFormatBoldResultUpdatedItemVariant2],
    },
    total=False,
)

DocFormatItalicResultInsertedItemVariant1 = TypedDict(
    "DocFormatItalicResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatItalicResultInsertedItemVariant2 = TypedDict(
    "DocFormatItalicResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatItalicResultRemovedItemVariant1 = TypedDict(
    "DocFormatItalicResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatItalicResultRemovedItemVariant2 = TypedDict(
    "DocFormatItalicResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatItalicResultResolutionRange = TypedDict(
    "DocFormatItalicResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocFormatItalicResultResolutionRequestedTargetRange = TypedDict(
    "DocFormatItalicResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatItalicResultResolutionRequestedTarget = TypedDict(
    "DocFormatItalicResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatItalicResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocFormatItalicResultResolutionTargetRange = TypedDict(
    "DocFormatItalicResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatItalicResultResolutionTarget = TypedDict(
    "DocFormatItalicResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatItalicResultResolutionTargetRange,
    },
    total=False,
)

DocFormatItalicResultResolution = TypedDict(
    "DocFormatItalicResultResolution",
    {
        "range": DocFormatItalicResultResolutionRange,
        "requestedTarget": DocFormatItalicResultResolutionRequestedTarget,
        "target": DocFormatItalicResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocFormatItalicResultUpdatedItemVariant1 = TypedDict(
    "DocFormatItalicResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatItalicResultUpdatedItemVariant2 = TypedDict(
    "DocFormatItalicResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatItalicResult = TypedDict(
    "DocFormatItalicResult",
    {
        "inserted": list[DocFormatItalicResultInsertedItemVariant1 | DocFormatItalicResultInsertedItemVariant2],
        "removed": list[DocFormatItalicResultRemovedItemVariant1 | DocFormatItalicResultRemovedItemVariant2],
        "resolution": DocFormatItalicResultResolution,
        "success": Literal[True],
        "updated": list[DocFormatItalicResultUpdatedItemVariant1 | DocFormatItalicResultUpdatedItemVariant2],
    },
    total=False,
)

DocFormatUnderlineResultInsertedItemVariant1 = TypedDict(
    "DocFormatUnderlineResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatUnderlineResultInsertedItemVariant2 = TypedDict(
    "DocFormatUnderlineResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatUnderlineResultRemovedItemVariant1 = TypedDict(
    "DocFormatUnderlineResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatUnderlineResultRemovedItemVariant2 = TypedDict(
    "DocFormatUnderlineResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatUnderlineResultResolutionRange = TypedDict(
    "DocFormatUnderlineResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocFormatUnderlineResultResolutionRequestedTargetRange = TypedDict(
    "DocFormatUnderlineResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatUnderlineResultResolutionRequestedTarget = TypedDict(
    "DocFormatUnderlineResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatUnderlineResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocFormatUnderlineResultResolutionTargetRange = TypedDict(
    "DocFormatUnderlineResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatUnderlineResultResolutionTarget = TypedDict(
    "DocFormatUnderlineResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatUnderlineResultResolutionTargetRange,
    },
    total=False,
)

DocFormatUnderlineResultResolution = TypedDict(
    "DocFormatUnderlineResultResolution",
    {
        "range": DocFormatUnderlineResultResolutionRange,
        "requestedTarget": DocFormatUnderlineResultResolutionRequestedTarget,
        "target": DocFormatUnderlineResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocFormatUnderlineResultUpdatedItemVariant1 = TypedDict(
    "DocFormatUnderlineResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatUnderlineResultUpdatedItemVariant2 = TypedDict(
    "DocFormatUnderlineResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatUnderlineResult = TypedDict(
    "DocFormatUnderlineResult",
    {
        "inserted": list[DocFormatUnderlineResultInsertedItemVariant1 | DocFormatUnderlineResultInsertedItemVariant2],
        "removed": list[DocFormatUnderlineResultRemovedItemVariant1 | DocFormatUnderlineResultRemovedItemVariant2],
        "resolution": DocFormatUnderlineResultResolution,
        "success": Literal[True],
        "updated": list[DocFormatUnderlineResultUpdatedItemVariant1 | DocFormatUnderlineResultUpdatedItemVariant2],
    },
    total=False,
)

DocFormatStrikethroughResultInsertedItemVariant1 = TypedDict(
    "DocFormatStrikethroughResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatStrikethroughResultInsertedItemVariant2 = TypedDict(
    "DocFormatStrikethroughResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatStrikethroughResultRemovedItemVariant1 = TypedDict(
    "DocFormatStrikethroughResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatStrikethroughResultRemovedItemVariant2 = TypedDict(
    "DocFormatStrikethroughResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatStrikethroughResultResolutionRange = TypedDict(
    "DocFormatStrikethroughResultResolutionRange",
    {
        "from": int | float,
        "to": int | float,
    },
    total=False,
)

DocFormatStrikethroughResultResolutionRequestedTargetRange = TypedDict(
    "DocFormatStrikethroughResultResolutionRequestedTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatStrikethroughResultResolutionRequestedTarget = TypedDict(
    "DocFormatStrikethroughResultResolutionRequestedTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatStrikethroughResultResolutionRequestedTargetRange,
    },
    total=False,
)

DocFormatStrikethroughResultResolutionTargetRange = TypedDict(
    "DocFormatStrikethroughResultResolutionTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocFormatStrikethroughResultResolutionTarget = TypedDict(
    "DocFormatStrikethroughResultResolutionTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocFormatStrikethroughResultResolutionTargetRange,
    },
    total=False,
)

DocFormatStrikethroughResultResolution = TypedDict(
    "DocFormatStrikethroughResultResolution",
    {
        "range": DocFormatStrikethroughResultResolutionRange,
        "requestedTarget": DocFormatStrikethroughResultResolutionRequestedTarget,
        "target": DocFormatStrikethroughResultResolutionTarget,
        "text": str,
    },
    total=False,
)

DocFormatStrikethroughResultUpdatedItemVariant1 = TypedDict(
    "DocFormatStrikethroughResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatStrikethroughResultUpdatedItemVariant2 = TypedDict(
    "DocFormatStrikethroughResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocFormatStrikethroughResult = TypedDict(
    "DocFormatStrikethroughResult",
    {
        "inserted": list[DocFormatStrikethroughResultInsertedItemVariant1 | DocFormatStrikethroughResultInsertedItemVariant2],
        "removed": list[DocFormatStrikethroughResultRemovedItemVariant1 | DocFormatStrikethroughResultRemovedItemVariant2],
        "resolution": DocFormatStrikethroughResultResolution,
        "success": Literal[True],
        "updated": list[DocFormatStrikethroughResultUpdatedItemVariant1 | DocFormatStrikethroughResultUpdatedItemVariant2],
    },
    total=False,
)

DocCreateParagraphResultInsertionPointRange = TypedDict(
    "DocCreateParagraphResultInsertionPointRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocCreateParagraphResultInsertionPoint = TypedDict(
    "DocCreateParagraphResultInsertionPoint",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocCreateParagraphResultInsertionPointRange,
    },
    total=False,
)

DocCreateParagraphResultParagraph = TypedDict(
    "DocCreateParagraphResultParagraph",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["paragraph"],
    },
    total=False,
)

DocCreateParagraphResultTrackedChangeRefsItem = TypedDict(
    "DocCreateParagraphResultTrackedChangeRefsItem",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCreateParagraphResult = TypedDict(
    "DocCreateParagraphResult",
    {
        "insertionPoint": DocCreateParagraphResultInsertionPoint,
        "paragraph": DocCreateParagraphResultParagraph,
        "success": Literal[True],
        "trackedChangeRefs": list[DocCreateParagraphResultTrackedChangeRefsItem],
    },
    total=False,
)

DocListsListResultItemsItemAddress = TypedDict(
    "DocListsListResultItemsItemAddress",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsListResultItemsItem = TypedDict(
    "DocListsListResultItemsItem",
    {
        "address": DocListsListResultItemsItemAddress,
        "kind": Literal["ordered"] | Literal["bullet"],
        "level": int | float,
        "marker": str,
        "ordinal": int | float,
        "path": list[int | float],
        "text": str,
    },
    total=False,
)

DocListsListResultMatchesItem = TypedDict(
    "DocListsListResultMatchesItem",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsListResult = TypedDict(
    "DocListsListResult",
    {
        "items": list[DocListsListResultItemsItem],
        "matches": list[DocListsListResultMatchesItem],
        "total": int | float,
    },
    total=False,
)

DocListsGetResultAddress = TypedDict(
    "DocListsGetResultAddress",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsGetResult = TypedDict(
    "DocListsGetResult",
    {
        "address": DocListsGetResultAddress,
        "kind": Literal["ordered"] | Literal["bullet"],
        "level": int | float,
        "marker": str,
        "ordinal": int | float,
        "path": list[int | float],
        "text": str,
    },
    total=False,
)

DocListsInsertResultInsertionPointRange = TypedDict(
    "DocListsInsertResultInsertionPointRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocListsInsertResultInsertionPoint = TypedDict(
    "DocListsInsertResultInsertionPoint",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocListsInsertResultInsertionPointRange,
    },
    total=False,
)

DocListsInsertResultItem = TypedDict(
    "DocListsInsertResultItem",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsInsertResultTrackedChangeRefsItem = TypedDict(
    "DocListsInsertResultTrackedChangeRefsItem",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocListsInsertResult = TypedDict(
    "DocListsInsertResult",
    {
        "insertionPoint": DocListsInsertResultInsertionPoint,
        "item": DocListsInsertResultItem,
        "success": Literal[True],
        "trackedChangeRefs": list[DocListsInsertResultTrackedChangeRefsItem],
    },
    total=False,
)

DocListsSetTypeResultItem = TypedDict(
    "DocListsSetTypeResultItem",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsSetTypeResult = TypedDict(
    "DocListsSetTypeResult",
    {
        "item": DocListsSetTypeResultItem,
        "success": Literal[True],
    },
    total=False,
)

DocListsIndentResultItem = TypedDict(
    "DocListsIndentResultItem",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsIndentResult = TypedDict(
    "DocListsIndentResult",
    {
        "item": DocListsIndentResultItem,
        "success": Literal[True],
    },
    total=False,
)

DocListsOutdentResultItem = TypedDict(
    "DocListsOutdentResultItem",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsOutdentResult = TypedDict(
    "DocListsOutdentResult",
    {
        "item": DocListsOutdentResultItem,
        "success": Literal[True],
    },
    total=False,
)

DocListsRestartResultItem = TypedDict(
    "DocListsRestartResultItem",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["listItem"],
    },
    total=False,
)

DocListsRestartResult = TypedDict(
    "DocListsRestartResult",
    {
        "item": DocListsRestartResultItem,
        "success": Literal[True],
    },
    total=False,
)

DocListsExitResultParagraph = TypedDict(
    "DocListsExitResultParagraph",
    {
        "kind": Literal["block"],
        "nodeId": str,
        "nodeType": Literal["paragraph"],
    },
    total=False,
)

DocListsExitResult = TypedDict(
    "DocListsExitResult",
    {
        "paragraph": DocListsExitResultParagraph,
        "success": Literal[True],
    },
    total=False,
)

DocCommentsAddResultInsertedItemVariant1 = TypedDict(
    "DocCommentsAddResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsAddResultInsertedItemVariant2 = TypedDict(
    "DocCommentsAddResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsAddResultRemovedItemVariant1 = TypedDict(
    "DocCommentsAddResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsAddResultRemovedItemVariant2 = TypedDict(
    "DocCommentsAddResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsAddResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsAddResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsAddResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsAddResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsAddResult = TypedDict(
    "DocCommentsAddResult",
    {
        "inserted": list[DocCommentsAddResultInsertedItemVariant1 | DocCommentsAddResultInsertedItemVariant2],
        "removed": list[DocCommentsAddResultRemovedItemVariant1 | DocCommentsAddResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsAddResultUpdatedItemVariant1 | DocCommentsAddResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsEditResultInsertedItemVariant1 = TypedDict(
    "DocCommentsEditResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsEditResultInsertedItemVariant2 = TypedDict(
    "DocCommentsEditResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsEditResultRemovedItemVariant1 = TypedDict(
    "DocCommentsEditResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsEditResultRemovedItemVariant2 = TypedDict(
    "DocCommentsEditResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsEditResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsEditResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsEditResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsEditResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsEditResult = TypedDict(
    "DocCommentsEditResult",
    {
        "inserted": list[DocCommentsEditResultInsertedItemVariant1 | DocCommentsEditResultInsertedItemVariant2],
        "removed": list[DocCommentsEditResultRemovedItemVariant1 | DocCommentsEditResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsEditResultUpdatedItemVariant1 | DocCommentsEditResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsReplyResultInsertedItemVariant1 = TypedDict(
    "DocCommentsReplyResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsReplyResultInsertedItemVariant2 = TypedDict(
    "DocCommentsReplyResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsReplyResultRemovedItemVariant1 = TypedDict(
    "DocCommentsReplyResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsReplyResultRemovedItemVariant2 = TypedDict(
    "DocCommentsReplyResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsReplyResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsReplyResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsReplyResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsReplyResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsReplyResult = TypedDict(
    "DocCommentsReplyResult",
    {
        "inserted": list[DocCommentsReplyResultInsertedItemVariant1 | DocCommentsReplyResultInsertedItemVariant2],
        "removed": list[DocCommentsReplyResultRemovedItemVariant1 | DocCommentsReplyResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsReplyResultUpdatedItemVariant1 | DocCommentsReplyResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsMoveResultInsertedItemVariant1 = TypedDict(
    "DocCommentsMoveResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsMoveResultInsertedItemVariant2 = TypedDict(
    "DocCommentsMoveResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsMoveResultRemovedItemVariant1 = TypedDict(
    "DocCommentsMoveResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsMoveResultRemovedItemVariant2 = TypedDict(
    "DocCommentsMoveResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsMoveResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsMoveResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsMoveResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsMoveResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsMoveResult = TypedDict(
    "DocCommentsMoveResult",
    {
        "inserted": list[DocCommentsMoveResultInsertedItemVariant1 | DocCommentsMoveResultInsertedItemVariant2],
        "removed": list[DocCommentsMoveResultRemovedItemVariant1 | DocCommentsMoveResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsMoveResultUpdatedItemVariant1 | DocCommentsMoveResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsResolveResultInsertedItemVariant1 = TypedDict(
    "DocCommentsResolveResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsResolveResultInsertedItemVariant2 = TypedDict(
    "DocCommentsResolveResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsResolveResultRemovedItemVariant1 = TypedDict(
    "DocCommentsResolveResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsResolveResultRemovedItemVariant2 = TypedDict(
    "DocCommentsResolveResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsResolveResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsResolveResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsResolveResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsResolveResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsResolveResult = TypedDict(
    "DocCommentsResolveResult",
    {
        "inserted": list[DocCommentsResolveResultInsertedItemVariant1 | DocCommentsResolveResultInsertedItemVariant2],
        "removed": list[DocCommentsResolveResultRemovedItemVariant1 | DocCommentsResolveResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsResolveResultUpdatedItemVariant1 | DocCommentsResolveResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsRemoveResultInsertedItemVariant1 = TypedDict(
    "DocCommentsRemoveResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsRemoveResultInsertedItemVariant2 = TypedDict(
    "DocCommentsRemoveResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsRemoveResultRemovedItemVariant1 = TypedDict(
    "DocCommentsRemoveResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsRemoveResultRemovedItemVariant2 = TypedDict(
    "DocCommentsRemoveResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsRemoveResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsRemoveResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsRemoveResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsRemoveResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsRemoveResult = TypedDict(
    "DocCommentsRemoveResult",
    {
        "inserted": list[DocCommentsRemoveResultInsertedItemVariant1 | DocCommentsRemoveResultInsertedItemVariant2],
        "removed": list[DocCommentsRemoveResultRemovedItemVariant1 | DocCommentsRemoveResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsRemoveResultUpdatedItemVariant1 | DocCommentsRemoveResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsSetInternalResultInsertedItemVariant1 = TypedDict(
    "DocCommentsSetInternalResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetInternalResultInsertedItemVariant2 = TypedDict(
    "DocCommentsSetInternalResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetInternalResultRemovedItemVariant1 = TypedDict(
    "DocCommentsSetInternalResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetInternalResultRemovedItemVariant2 = TypedDict(
    "DocCommentsSetInternalResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetInternalResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsSetInternalResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetInternalResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsSetInternalResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetInternalResult = TypedDict(
    "DocCommentsSetInternalResult",
    {
        "inserted": list[DocCommentsSetInternalResultInsertedItemVariant1 | DocCommentsSetInternalResultInsertedItemVariant2],
        "removed": list[DocCommentsSetInternalResultRemovedItemVariant1 | DocCommentsSetInternalResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsSetInternalResultUpdatedItemVariant1 | DocCommentsSetInternalResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsSetActiveResultInsertedItemVariant1 = TypedDict(
    "DocCommentsSetActiveResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetActiveResultInsertedItemVariant2 = TypedDict(
    "DocCommentsSetActiveResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetActiveResultRemovedItemVariant1 = TypedDict(
    "DocCommentsSetActiveResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetActiveResultRemovedItemVariant2 = TypedDict(
    "DocCommentsSetActiveResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetActiveResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsSetActiveResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetActiveResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsSetActiveResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsSetActiveResult = TypedDict(
    "DocCommentsSetActiveResult",
    {
        "inserted": list[DocCommentsSetActiveResultInsertedItemVariant1 | DocCommentsSetActiveResultInsertedItemVariant2],
        "removed": list[DocCommentsSetActiveResultRemovedItemVariant1 | DocCommentsSetActiveResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsSetActiveResultUpdatedItemVariant1 | DocCommentsSetActiveResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsGoToResultInsertedItemVariant1 = TypedDict(
    "DocCommentsGoToResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGoToResultInsertedItemVariant2 = TypedDict(
    "DocCommentsGoToResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGoToResultRemovedItemVariant1 = TypedDict(
    "DocCommentsGoToResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGoToResultRemovedItemVariant2 = TypedDict(
    "DocCommentsGoToResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGoToResultUpdatedItemVariant1 = TypedDict(
    "DocCommentsGoToResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGoToResultUpdatedItemVariant2 = TypedDict(
    "DocCommentsGoToResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGoToResult = TypedDict(
    "DocCommentsGoToResult",
    {
        "inserted": list[DocCommentsGoToResultInsertedItemVariant1 | DocCommentsGoToResultInsertedItemVariant2],
        "removed": list[DocCommentsGoToResultRemovedItemVariant1 | DocCommentsGoToResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocCommentsGoToResultUpdatedItemVariant1 | DocCommentsGoToResultUpdatedItemVariant2],
    },
    total=False,
)

DocCommentsGetResultAddress = TypedDict(
    "DocCommentsGetResultAddress",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsGetResultTargetRange = TypedDict(
    "DocCommentsGetResultTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocCommentsGetResultTarget = TypedDict(
    "DocCommentsGetResultTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocCommentsGetResultTargetRange,
    },
    total=False,
)

DocCommentsGetResult = TypedDict(
    "DocCommentsGetResult",
    {
        "address": DocCommentsGetResultAddress,
        "commentId": str,
        "createdTime": int | float,
        "creatorEmail": str,
        "creatorName": str,
        "importedId": str,
        "isInternal": bool,
        "parentCommentId": str,
        "status": Literal["open"] | Literal["resolved"],
        "target": DocCommentsGetResultTarget,
        "text": str,
    },
    total=False,
)

DocCommentsListResultMatchesItemAddress = TypedDict(
    "DocCommentsListResultMatchesItemAddress",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocCommentsListResultMatchesItemTargetRange = TypedDict(
    "DocCommentsListResultMatchesItemTargetRange",
    {
        "end": int | float,
        "start": int | float,
    },
    total=False,
)

DocCommentsListResultMatchesItemTarget = TypedDict(
    "DocCommentsListResultMatchesItemTarget",
    {
        "blockId": str,
        "kind": Literal["text"],
        "range": DocCommentsListResultMatchesItemTargetRange,
    },
    total=False,
)

DocCommentsListResultMatchesItem = TypedDict(
    "DocCommentsListResultMatchesItem",
    {
        "address": DocCommentsListResultMatchesItemAddress,
        "commentId": str,
        "createdTime": int | float,
        "creatorEmail": str,
        "creatorName": str,
        "importedId": str,
        "isInternal": bool,
        "parentCommentId": str,
        "status": Literal["open"] | Literal["resolved"],
        "target": DocCommentsListResultMatchesItemTarget,
        "text": str,
    },
    total=False,
)

DocCommentsListResult = TypedDict(
    "DocCommentsListResult",
    {
        "matches": list[DocCommentsListResultMatchesItem],
        "total": int | float,
    },
    total=False,
)

DocTrackChangesListResultChangesItemAddress = TypedDict(
    "DocTrackChangesListResultChangesItemAddress",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesListResultChangesItem = TypedDict(
    "DocTrackChangesListResultChangesItem",
    {
        "address": DocTrackChangesListResultChangesItemAddress,
        "author": str,
        "authorEmail": str,
        "authorImage": str,
        "date": str,
        "excerpt": str,
        "id": str,
        "type": Literal["insert"] | Literal["delete"] | Literal["format"],
    },
    total=False,
)

DocTrackChangesListResultMatchesItem = TypedDict(
    "DocTrackChangesListResultMatchesItem",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesListResult = TypedDict(
    "DocTrackChangesListResult",
    {
        "changes": list[DocTrackChangesListResultChangesItem],
        "matches": list[DocTrackChangesListResultMatchesItem],
        "total": int | float,
    },
    total=False,
)

DocTrackChangesGetResultAddress = TypedDict(
    "DocTrackChangesGetResultAddress",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesGetResult = TypedDict(
    "DocTrackChangesGetResult",
    {
        "address": DocTrackChangesGetResultAddress,
        "author": str,
        "authorEmail": str,
        "authorImage": str,
        "date": str,
        "excerpt": str,
        "id": str,
        "type": Literal["insert"] | Literal["delete"] | Literal["format"],
    },
    total=False,
)

DocTrackChangesAcceptResultInsertedItemVariant1 = TypedDict(
    "DocTrackChangesAcceptResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptResultInsertedItemVariant2 = TypedDict(
    "DocTrackChangesAcceptResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptResultRemovedItemVariant1 = TypedDict(
    "DocTrackChangesAcceptResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptResultRemovedItemVariant2 = TypedDict(
    "DocTrackChangesAcceptResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptResultUpdatedItemVariant1 = TypedDict(
    "DocTrackChangesAcceptResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptResultUpdatedItemVariant2 = TypedDict(
    "DocTrackChangesAcceptResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptResult = TypedDict(
    "DocTrackChangesAcceptResult",
    {
        "inserted": list[DocTrackChangesAcceptResultInsertedItemVariant1 | DocTrackChangesAcceptResultInsertedItemVariant2],
        "removed": list[DocTrackChangesAcceptResultRemovedItemVariant1 | DocTrackChangesAcceptResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocTrackChangesAcceptResultUpdatedItemVariant1 | DocTrackChangesAcceptResultUpdatedItemVariant2],
    },
    total=False,
)

DocTrackChangesRejectResultInsertedItemVariant1 = TypedDict(
    "DocTrackChangesRejectResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectResultInsertedItemVariant2 = TypedDict(
    "DocTrackChangesRejectResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectResultRemovedItemVariant1 = TypedDict(
    "DocTrackChangesRejectResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectResultRemovedItemVariant2 = TypedDict(
    "DocTrackChangesRejectResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectResultUpdatedItemVariant1 = TypedDict(
    "DocTrackChangesRejectResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectResultUpdatedItemVariant2 = TypedDict(
    "DocTrackChangesRejectResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectResult = TypedDict(
    "DocTrackChangesRejectResult",
    {
        "inserted": list[DocTrackChangesRejectResultInsertedItemVariant1 | DocTrackChangesRejectResultInsertedItemVariant2],
        "removed": list[DocTrackChangesRejectResultRemovedItemVariant1 | DocTrackChangesRejectResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocTrackChangesRejectResultUpdatedItemVariant1 | DocTrackChangesRejectResultUpdatedItemVariant2],
    },
    total=False,
)

DocTrackChangesAcceptAllResultInsertedItemVariant1 = TypedDict(
    "DocTrackChangesAcceptAllResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptAllResultInsertedItemVariant2 = TypedDict(
    "DocTrackChangesAcceptAllResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptAllResultRemovedItemVariant1 = TypedDict(
    "DocTrackChangesAcceptAllResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptAllResultRemovedItemVariant2 = TypedDict(
    "DocTrackChangesAcceptAllResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptAllResultUpdatedItemVariant1 = TypedDict(
    "DocTrackChangesAcceptAllResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptAllResultUpdatedItemVariant2 = TypedDict(
    "DocTrackChangesAcceptAllResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesAcceptAllResult = TypedDict(
    "DocTrackChangesAcceptAllResult",
    {
        "inserted": list[DocTrackChangesAcceptAllResultInsertedItemVariant1 | DocTrackChangesAcceptAllResultInsertedItemVariant2],
        "removed": list[DocTrackChangesAcceptAllResultRemovedItemVariant1 | DocTrackChangesAcceptAllResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocTrackChangesAcceptAllResultUpdatedItemVariant1 | DocTrackChangesAcceptAllResultUpdatedItemVariant2],
    },
    total=False,
)

DocTrackChangesRejectAllResultInsertedItemVariant1 = TypedDict(
    "DocTrackChangesRejectAllResultInsertedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectAllResultInsertedItemVariant2 = TypedDict(
    "DocTrackChangesRejectAllResultInsertedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectAllResultRemovedItemVariant1 = TypedDict(
    "DocTrackChangesRejectAllResultRemovedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectAllResultRemovedItemVariant2 = TypedDict(
    "DocTrackChangesRejectAllResultRemovedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectAllResultUpdatedItemVariant1 = TypedDict(
    "DocTrackChangesRejectAllResultUpdatedItemVariant1",
    {
        "entityId": str,
        "entityType": Literal["comment"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectAllResultUpdatedItemVariant2 = TypedDict(
    "DocTrackChangesRejectAllResultUpdatedItemVariant2",
    {
        "entityId": str,
        "entityType": Literal["trackedChange"],
        "kind": Literal["entity"],
    },
    total=False,
)

DocTrackChangesRejectAllResult = TypedDict(
    "DocTrackChangesRejectAllResult",
    {
        "inserted": list[DocTrackChangesRejectAllResultInsertedItemVariant1 | DocTrackChangesRejectAllResultInsertedItemVariant2],
        "removed": list[DocTrackChangesRejectAllResultRemovedItemVariant1 | DocTrackChangesRejectAllResultRemovedItemVariant2],
        "success": Literal[True],
        "updated": list[DocTrackChangesRejectAllResultUpdatedItemVariant1 | DocTrackChangesRejectAllResultUpdatedItemVariant2],
    },
    total=False,
)

DocOpenResultDocument = TypedDict(
    "DocOpenResultDocument",
    {
        "path": str,
        "source": str,
        "revision": int | float,
    },
    total=False,
)

DocOpenResultCollaboration = TypedDict(
    "DocOpenResultCollaboration",
    {
        "documentId": str,
        "url": str,
    },
    total=False,
)

DocOpenResult = TypedDict(
    "DocOpenResult",
    {
        "contextId": str,
        "sessionType": str,
        "document": DocOpenResultDocument,
        "collaboration": DocOpenResultCollaboration,
    },
    total=False,
)

DocSaveResultDocument = TypedDict(
    "DocSaveResultDocument",
    {
        "path": str,
        "source": str,
        "revision": int | float,
    },
    total=False,
)

DocSaveResultContext = TypedDict(
    "DocSaveResultContext",
    {
        "dirty": bool,
        "revision": int | float,
        "lastSavedAt": str,
    },
    total=False,
)

DocSaveResultOutput = TypedDict(
    "DocSaveResultOutput",
    {
        "path": str,
        "byteLength": int | float,
    },
    total=False,
)

DocSaveResult = TypedDict(
    "DocSaveResult",
    {
        "contextId": str,
        "saved": bool,
        "inPlace": bool,
        "document": DocSaveResultDocument,
        "context": DocSaveResultContext,
        "output": DocSaveResultOutput,
    },
    total=False,
)

DocCloseResultDocument = TypedDict(
    "DocCloseResultDocument",
    {
        "path": str,
        "source": str,
        "revision": int | float,
    },
    total=False,
)

DocCloseResult = TypedDict(
    "DocCloseResult",
    {
        "contextId": str,
        "closed": bool,
        "saved": bool,
        "discarded": bool,
        "defaultSessionCleared": bool,
        "wasDirty": bool,
        "document": DocCloseResultDocument,
    },
    total=False,
)

DocStatusResultDocument = TypedDict(
    "DocStatusResultDocument",
    {
        "path": str,
        "source": str,
    },
    total=False,
)

DocStatusResult = TypedDict(
    "DocStatusResult",
    {
        "contextId": str,
        "sessionType": str,
        "dirty": bool,
        "revision": int | float,
        "document": DocStatusResultDocument,
    },
    total=False,
)

DocDescribeResultOperationsItem = TypedDict(
    "DocDescribeResultOperationsItem",
    {
        "operationId": str,
        "command": str,
        "category": str,
        "description": str,
        "mutates": bool,
    },
    total=False,
)

DocDescribeResult = TypedDict(
    "DocDescribeResult",
    {
        "contractVersion": str,
        "operations": list[DocDescribeResultOperationsItem],
    },
    total=False,
)

DocDescribeCommandResult = TypedDict(
    "DocDescribeCommandResult",
    {
        "operationId": str,
        "command": str,
        "category": str,
        "description": str,
        "mutates": bool,
        "params": list[Any],
        "constraints": Any,
    },
    total=False,
)

DocSessionListResultSessionsItem = TypedDict(
    "DocSessionListResultSessionsItem",
    {
        "sessionId": str,
        "sessionType": str,
        "dirty": bool,
        "revision": int | float,
    },
    total=False,
)

DocSessionListResult = TypedDict(
    "DocSessionListResult",
    {
        "activeSessionId": str,
        "sessions": list[DocSessionListResultSessionsItem],
        "total": int | float,
    },
    total=False,
)

DocSessionSaveResultDocument = TypedDict(
    "DocSessionSaveResultDocument",
    {
        "path": str,
        "source": str,
        "revision": int | float,
    },
    total=False,
)

DocSessionSaveResultOutput = TypedDict(
    "DocSessionSaveResultOutput",
    {
        "path": str,
        "byteLength": int | float,
    },
    total=False,
)

DocSessionSaveResult = TypedDict(
    "DocSessionSaveResult",
    {
        "sessionId": str,
        "contextId": str,
        "saved": bool,
        "inPlace": bool,
        "document": DocSessionSaveResultDocument,
        "output": DocSessionSaveResultOutput,
    },
    total=False,
)

DocSessionCloseResultDocument = TypedDict(
    "DocSessionCloseResultDocument",
    {
        "path": str,
        "source": str,
        "revision": int | float,
    },
    total=False,
)

DocSessionCloseResult = TypedDict(
    "DocSessionCloseResult",
    {
        "sessionId": str,
        "contextId": str,
        "closed": bool,
        "saved": bool,
        "discarded": bool,
        "defaultSessionCleared": bool,
        "wasDirty": bool,
        "document": DocSessionCloseResultDocument,
    },
    total=False,
)

DocSessionSetDefaultResult = TypedDict(
    "DocSessionSetDefaultResult",
    {
        "activeSessionId": str,
    },
    total=False,
)

DocFindParamsWithinVariant1 = TypedDict(
    "DocFindParamsWithinVariant1",
    {
        "kind": Literal["block"],
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"],
        "nodeId": str,
    },
    total=False,
)

DocFindParamsWithinVariant2AnchorStart = TypedDict(
    "DocFindParamsWithinVariant2AnchorStart",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindParamsWithinVariant2AnchorEnd = TypedDict(
    "DocFindParamsWithinVariant2AnchorEnd",
    {
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocFindParamsWithinVariant2Anchor = TypedDict(
    "DocFindParamsWithinVariant2Anchor",
    {
        "start": DocFindParamsWithinVariant2AnchorStart,
        "end": DocFindParamsWithinVariant2AnchorEnd,
    },
    total=False,
)

DocFindParamsWithinVariant2 = TypedDict(
    "DocFindParamsWithinVariant2",
    {
        "kind": Literal["inline"],
        "nodeType": Literal["run"] | Literal["bookmark"] | Literal["comment"] | Literal["hyperlink"] | Literal["sdt"] | Literal["image"] | Literal["footnoteRef"] | Literal["tab"] | Literal["lineBreak"],
        "anchor": DocFindParamsWithinVariant2Anchor,
    },
    total=False,
)

DocFindParams = TypedDict(
    "DocFindParams",
    {
        "doc": str,
        "sessionId": str,
        "within": DocFindParamsWithinVariant1 | DocFindParamsWithinVariant2,
        "limit": int | float,
        "offset": int | float,
        "includeNodes": bool,
        "includeUnknown": bool,
        "type": str,
        "nodeType": str,
        "kind": str,
        "pattern": str,
        "mode": str,
        "caseSensitive": bool,
        "query": Any,
    },
    total=False,
)

DocGetNodeParams = TypedDict(
    "DocGetNodeParams",
    {
        "doc": str,
        "sessionId": str,
        "address": Any,
    },
    total=False,
)

DocGetNodeByIdParams = TypedDict(
    "DocGetNodeByIdParams",
    {
        "doc": str,
        "sessionId": str,
        "id": str,
        "nodeType": str,
    },
    total=False,
)

DocInfoParams = TypedDict(
    "DocInfoParams",
    {
        "doc": str,
        "sessionId": str,
    },
    total=False,
)

DocInsertParamsTargetRange = TypedDict(
    "DocInsertParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocInsertParamsTarget = TypedDict(
    "DocInsertParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocInsertParamsTargetRange,
    },
    total=False,
)

DocInsertParams = TypedDict(
    "DocInsertParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocInsertParamsTarget,
        "text": str,
        "blockId": str,
        "offset": int | float,
    },
    total=False,
)

DocReplaceParamsTargetRange = TypedDict(
    "DocReplaceParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocReplaceParamsTarget = TypedDict(
    "DocReplaceParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocReplaceParamsTargetRange,
    },
    total=False,
)

DocReplaceParams = TypedDict(
    "DocReplaceParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocReplaceParamsTarget,
        "text": str,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocDeleteParamsTargetRange = TypedDict(
    "DocDeleteParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocDeleteParamsTarget = TypedDict(
    "DocDeleteParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocDeleteParamsTargetRange,
    },
    total=False,
)

DocDeleteParams = TypedDict(
    "DocDeleteParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocDeleteParamsTarget,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatBoldParamsTargetRange = TypedDict(
    "DocFormatBoldParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatBoldParamsTarget = TypedDict(
    "DocFormatBoldParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocFormatBoldParamsTargetRange,
    },
    total=False,
)

DocFormatBoldParams = TypedDict(
    "DocFormatBoldParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocFormatBoldParamsTarget,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatItalicParamsTargetRange = TypedDict(
    "DocFormatItalicParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatItalicParamsTarget = TypedDict(
    "DocFormatItalicParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocFormatItalicParamsTargetRange,
    },
    total=False,
)

DocFormatItalicParams = TypedDict(
    "DocFormatItalicParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocFormatItalicParamsTarget,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatUnderlineParamsTargetRange = TypedDict(
    "DocFormatUnderlineParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatUnderlineParamsTarget = TypedDict(
    "DocFormatUnderlineParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocFormatUnderlineParamsTargetRange,
    },
    total=False,
)

DocFormatUnderlineParams = TypedDict(
    "DocFormatUnderlineParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocFormatUnderlineParamsTarget,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatStrikethroughParamsTargetRange = TypedDict(
    "DocFormatStrikethroughParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocFormatStrikethroughParamsTarget = TypedDict(
    "DocFormatStrikethroughParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocFormatStrikethroughParamsTargetRange,
    },
    total=False,
)

DocFormatStrikethroughParams = TypedDict(
    "DocFormatStrikethroughParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocFormatStrikethroughParamsTarget,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocCreateParagraphParamsAtVariant1 = TypedDict(
    "DocCreateParagraphParamsAtVariant1",
    {
        "kind": Literal["documentStart"],
    },
    total=False,
)

DocCreateParagraphParamsAtVariant2 = TypedDict(
    "DocCreateParagraphParamsAtVariant2",
    {
        "kind": Literal["documentEnd"],
    },
    total=False,
)

DocCreateParagraphParams = TypedDict(
    "DocCreateParagraphParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "at": DocCreateParagraphParamsAtVariant1 | DocCreateParagraphParamsAtVariant2 | Any | Any | Any | Any,
        "text": str,
        "input": Any,
    },
    total=False,
)

DocListsListParamsWithin = TypedDict(
    "DocListsListParamsWithin",
    {
        "kind": Literal["block"],
        "nodeType": Literal["paragraph"] | Literal["heading"] | Literal["listItem"] | Literal["table"] | Literal["tableRow"] | Literal["tableCell"] | Literal["image"] | Literal["sdt"],
        "nodeId": str,
    },
    total=False,
)

DocListsListParams = TypedDict(
    "DocListsListParams",
    {
        "doc": str,
        "sessionId": str,
        "within": DocListsListParamsWithin,
        "limit": int | float,
        "offset": int | float,
        "kind": str,
        "level": int | float,
        "ordinal": int | float,
        "query": Any,
    },
    total=False,
)

DocListsGetParamsAddress = TypedDict(
    "DocListsGetParamsAddress",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsGetParams = TypedDict(
    "DocListsGetParams",
    {
        "doc": str,
        "sessionId": str,
        "address": DocListsGetParamsAddress,
    },
    total=False,
)

DocListsInsertParamsTarget = TypedDict(
    "DocListsInsertParamsTarget",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsInsertParams = TypedDict(
    "DocListsInsertParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocListsInsertParamsTarget,
        "nodeId": str,
        "position": str,
        "text": str,
        "input": Any,
    },
    total=False,
)

DocListsSetTypeParamsTarget = TypedDict(
    "DocListsSetTypeParamsTarget",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsSetTypeParams = TypedDict(
    "DocListsSetTypeParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocListsSetTypeParamsTarget,
        "nodeId": str,
        "kind": str,
        "input": Any,
    },
    total=False,
)

DocListsIndentParamsTarget = TypedDict(
    "DocListsIndentParamsTarget",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsIndentParams = TypedDict(
    "DocListsIndentParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocListsIndentParamsTarget,
        "nodeId": str,
        "input": Any,
    },
    total=False,
)

DocListsOutdentParamsTarget = TypedDict(
    "DocListsOutdentParamsTarget",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsOutdentParams = TypedDict(
    "DocListsOutdentParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocListsOutdentParamsTarget,
        "nodeId": str,
        "input": Any,
    },
    total=False,
)

DocListsRestartParamsTarget = TypedDict(
    "DocListsRestartParamsTarget",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsRestartParams = TypedDict(
    "DocListsRestartParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocListsRestartParamsTarget,
        "nodeId": str,
        "input": Any,
    },
    total=False,
)

DocListsExitParamsTarget = TypedDict(
    "DocListsExitParamsTarget",
    {
        "kind": Literal["block"],
        "nodeType": Literal["listItem"],
        "nodeId": str,
    },
    total=False,
)

DocListsExitParams = TypedDict(
    "DocListsExitParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "dryRun": bool,
        "target": DocListsExitParamsTarget,
        "nodeId": str,
        "input": Any,
    },
    total=False,
)

DocCommentsAddParamsTargetRange = TypedDict(
    "DocCommentsAddParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocCommentsAddParamsTarget = TypedDict(
    "DocCommentsAddParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocCommentsAddParamsTargetRange,
    },
    total=False,
)

DocCommentsAddParams = TypedDict(
    "DocCommentsAddParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "target": DocCommentsAddParamsTarget,
        "text": str,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocCommentsEditParams = TypedDict(
    "DocCommentsEditParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
        "text": str,
    },
    total=False,
)

DocCommentsReplyParams = TypedDict(
    "DocCommentsReplyParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "parentId": str,
        "text": str,
    },
    total=False,
)

DocCommentsMoveParamsTargetRange = TypedDict(
    "DocCommentsMoveParamsTargetRange",
    {
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocCommentsMoveParamsTarget = TypedDict(
    "DocCommentsMoveParamsTarget",
    {
        "kind": Literal["text"],
        "blockId": str,
        "range": DocCommentsMoveParamsTargetRange,
    },
    total=False,
)

DocCommentsMoveParams = TypedDict(
    "DocCommentsMoveParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
        "target": DocCommentsMoveParamsTarget,
        "blockId": str,
        "start": int | float,
        "end": int | float,
    },
    total=False,
)

DocCommentsResolveParams = TypedDict(
    "DocCommentsResolveParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
    },
    total=False,
)

DocCommentsRemoveParams = TypedDict(
    "DocCommentsRemoveParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
    },
    total=False,
)

DocCommentsSetInternalParams = TypedDict(
    "DocCommentsSetInternalParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
        "isInternal": bool,
    },
    total=False,
)

DocCommentsSetActiveParams = TypedDict(
    "DocCommentsSetActiveParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "commentId": Any,
        "id": str,
        "clear": bool,
    },
    total=False,
)

DocCommentsGoToParams = TypedDict(
    "DocCommentsGoToParams",
    {
        "doc": str,
        "sessionId": str,
        "id": str,
    },
    total=False,
)

DocCommentsGetParams = TypedDict(
    "DocCommentsGetParams",
    {
        "doc": str,
        "sessionId": str,
        "id": str,
    },
    total=False,
)

DocCommentsListParams = TypedDict(
    "DocCommentsListParams",
    {
        "doc": str,
        "sessionId": str,
        "includeResolved": bool,
    },
    total=False,
)

DocTrackChangesListParams = TypedDict(
    "DocTrackChangesListParams",
    {
        "doc": str,
        "sessionId": str,
        "limit": int | float,
        "offset": int | float,
        "type": str,
    },
    total=False,
)

DocTrackChangesGetParams = TypedDict(
    "DocTrackChangesGetParams",
    {
        "doc": str,
        "sessionId": str,
        "id": str,
    },
    total=False,
)

DocTrackChangesAcceptParams = TypedDict(
    "DocTrackChangesAcceptParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
    },
    total=False,
)

DocTrackChangesRejectParams = TypedDict(
    "DocTrackChangesRejectParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
        "id": str,
    },
    total=False,
)

DocTrackChangesAcceptAllParams = TypedDict(
    "DocTrackChangesAcceptAllParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
    },
    total=False,
)

DocTrackChangesRejectAllParams = TypedDict(
    "DocTrackChangesRejectAllParams",
    {
        "doc": str,
        "sessionId": str,
        "out": str,
        "force": bool,
        "expectedRevision": int | float,
        "changeMode": str,
    },
    total=False,
)

DocOpenParams = TypedDict(
    "DocOpenParams",
    {
        "doc": str,
        "sessionId": str,
        "collaboration": Any,
        "collabDocumentId": str,
        "collabUrl": str,
    },
    total=False,
)

DocSaveParams = TypedDict(
    "DocSaveParams",
    {
        "sessionId": str,
        "out": str,
        "force": bool,
        "inPlace": bool,
    },
    total=False,
)

DocCloseParams = TypedDict(
    "DocCloseParams",
    {
        "sessionId": str,
        "discard": bool,
    },
    total=False,
)

DocStatusParams = TypedDict(
    "DocStatusParams",
    {
        "sessionId": str,
    },
    total=False,
)

DocDescribeParams = TypedDict(
    "DocDescribeParams",
    {
    },
    total=False,
)

DocDescribeCommandParams = TypedDict(
    "DocDescribeCommandParams",
    {
        "operationId": str,
    },
    total=False,
)

DocSessionListParams = TypedDict(
    "DocSessionListParams",
    {
    },
    total=False,
)

DocSessionSaveParams = TypedDict(
    "DocSessionSaveParams",
    {
        "sessionId": str,
        "out": str,
        "force": bool,
        "inPlace": bool,
    },
    total=False,
)

DocSessionCloseParams = TypedDict(
    "DocSessionCloseParams",
    {
        "sessionId": str,
        "discard": bool,
    },
    total=False,
)

DocSessionSetDefaultParams = TypedDict(
    "DocSessionSetDefaultParams",
    {
        "sessionId": str,
    },
    total=False,
)

class _SyncDocApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def find(self, params: DocFindParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFindResult:
        return self._runtime.invoke("doc.find", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def getNode(self, params: DocGetNodeParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocGetNodeResult:
        return self._runtime.invoke("doc.getNode", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def getNodeById(self, params: DocGetNodeByIdParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocGetNodeByIdResult:
        return self._runtime.invoke("doc.getNodeById", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def info(self, params: DocInfoParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocInfoResult:
        return self._runtime.invoke("doc.info", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def insert(self, params: DocInsertParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocInsertResult:
        return self._runtime.invoke("doc.insert", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def replace(self, params: DocReplaceParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocReplaceResult:
        return self._runtime.invoke("doc.replace", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def delete(self, params: DocDeleteParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocDeleteResult:
        return self._runtime.invoke("doc.delete", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    @property
    def format(self):
        return _SyncDocFormatApi(self._runtime)

    @property
    def create(self):
        return _SyncDocCreateApi(self._runtime)

    @property
    def lists(self):
        return _SyncDocListsApi(self._runtime)

    @property
    def comments(self):
        return _SyncDocCommentsApi(self._runtime)

    @property
    def trackChanges(self):
        return _SyncDocTrackChangesApi(self._runtime)

    def open(self, params: DocOpenParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocOpenResult:
        return self._runtime.invoke("doc.open", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def save(self, params: DocSaveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSaveResult:
        return self._runtime.invoke("doc.save", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def close(self, params: DocCloseParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCloseResult:
        return self._runtime.invoke("doc.close", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def status(self, params: DocStatusParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocStatusResult:
        return self._runtime.invoke("doc.status", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def describe(self, params: DocDescribeParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocDescribeResult:
        return self._runtime.invoke("doc.describe", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def describeCommand(self, params: DocDescribeCommandParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocDescribeCommandResult:
        return self._runtime.invoke("doc.describeCommand", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    @property
    def session(self):
        return _SyncDocSessionApi(self._runtime)

class _SyncDocFormatApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def bold(self, params: DocFormatBoldParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatBoldResult:
        return self._runtime.invoke("doc.format.bold", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def italic(self, params: DocFormatItalicParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatItalicResult:
        return self._runtime.invoke("doc.format.italic", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def underline(self, params: DocFormatUnderlineParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatUnderlineResult:
        return self._runtime.invoke("doc.format.underline", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def strikethrough(self, params: DocFormatStrikethroughParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatStrikethroughResult:
        return self._runtime.invoke("doc.format.strikethrough", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _SyncDocCreateApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def paragraph(self, params: DocCreateParagraphParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCreateParagraphResult:
        return self._runtime.invoke("doc.create.paragraph", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _SyncDocListsApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def list(self, params: DocListsListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsListResult:
        return self._runtime.invoke("doc.lists.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def get(self, params: DocListsGetParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsGetResult:
        return self._runtime.invoke("doc.lists.get", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def insert(self, params: DocListsInsertParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsInsertResult:
        return self._runtime.invoke("doc.lists.insert", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def setType(self, params: DocListsSetTypeParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsSetTypeResult:
        return self._runtime.invoke("doc.lists.setType", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def indent(self, params: DocListsIndentParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsIndentResult:
        return self._runtime.invoke("doc.lists.indent", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def outdent(self, params: DocListsOutdentParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsOutdentResult:
        return self._runtime.invoke("doc.lists.outdent", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def restart(self, params: DocListsRestartParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsRestartResult:
        return self._runtime.invoke("doc.lists.restart", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def exit(self, params: DocListsExitParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsExitResult:
        return self._runtime.invoke("doc.lists.exit", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _SyncDocCommentsApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def add(self, params: DocCommentsAddParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsAddResult:
        return self._runtime.invoke("doc.comments.add", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def edit(self, params: DocCommentsEditParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsEditResult:
        return self._runtime.invoke("doc.comments.edit", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def reply(self, params: DocCommentsReplyParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsReplyResult:
        return self._runtime.invoke("doc.comments.reply", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def move(self, params: DocCommentsMoveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsMoveResult:
        return self._runtime.invoke("doc.comments.move", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def resolve(self, params: DocCommentsResolveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsResolveResult:
        return self._runtime.invoke("doc.comments.resolve", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def remove(self, params: DocCommentsRemoveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsRemoveResult:
        return self._runtime.invoke("doc.comments.remove", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def setInternal(self, params: DocCommentsSetInternalParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsSetInternalResult:
        return self._runtime.invoke("doc.comments.setInternal", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def setActive(self, params: DocCommentsSetActiveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsSetActiveResult:
        return self._runtime.invoke("doc.comments.setActive", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def goTo(self, params: DocCommentsGoToParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsGoToResult:
        return self._runtime.invoke("doc.comments.goTo", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def get(self, params: DocCommentsGetParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsGetResult:
        return self._runtime.invoke("doc.comments.get", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def list(self, params: DocCommentsListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsListResult:
        return self._runtime.invoke("doc.comments.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _SyncDocTrackChangesApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def list(self, params: DocTrackChangesListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesListResult:
        return self._runtime.invoke("doc.trackChanges.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def get(self, params: DocTrackChangesGetParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesGetResult:
        return self._runtime.invoke("doc.trackChanges.get", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def accept(self, params: DocTrackChangesAcceptParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesAcceptResult:
        return self._runtime.invoke("doc.trackChanges.accept", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def reject(self, params: DocTrackChangesRejectParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesRejectResult:
        return self._runtime.invoke("doc.trackChanges.reject", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def acceptAll(self, params: DocTrackChangesAcceptAllParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesAcceptAllResult:
        return self._runtime.invoke("doc.trackChanges.acceptAll", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def rejectAll(self, params: DocTrackChangesRejectAllParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesRejectAllResult:
        return self._runtime.invoke("doc.trackChanges.rejectAll", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _SyncDocSessionApi:
    def __init__(self, runtime):
        self._runtime = runtime

    def list(self, params: DocSessionListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionListResult:
        return self._runtime.invoke("doc.session.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def save(self, params: DocSessionSaveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionSaveResult:
        return self._runtime.invoke("doc.session.save", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def close(self, params: DocSessionCloseParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionCloseResult:
        return self._runtime.invoke("doc.session.close", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    def setDefault(self, params: DocSessionSetDefaultParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionSetDefaultResult:
        return self._runtime.invoke("doc.session.setDefault", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _AsyncDocApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def find(self, params: DocFindParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFindResult:
        return await self._runtime.invoke("doc.find", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def getNode(self, params: DocGetNodeParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocGetNodeResult:
        return await self._runtime.invoke("doc.getNode", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def getNodeById(self, params: DocGetNodeByIdParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocGetNodeByIdResult:
        return await self._runtime.invoke("doc.getNodeById", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def info(self, params: DocInfoParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocInfoResult:
        return await self._runtime.invoke("doc.info", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def insert(self, params: DocInsertParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocInsertResult:
        return await self._runtime.invoke("doc.insert", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def replace(self, params: DocReplaceParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocReplaceResult:
        return await self._runtime.invoke("doc.replace", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def delete(self, params: DocDeleteParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocDeleteResult:
        return await self._runtime.invoke("doc.delete", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    @property
    def format(self):
        return _AsyncDocFormatApi(self._runtime)

    @property
    def create(self):
        return _AsyncDocCreateApi(self._runtime)

    @property
    def lists(self):
        return _AsyncDocListsApi(self._runtime)

    @property
    def comments(self):
        return _AsyncDocCommentsApi(self._runtime)

    @property
    def trackChanges(self):
        return _AsyncDocTrackChangesApi(self._runtime)

    async def open(self, params: DocOpenParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocOpenResult:
        return await self._runtime.invoke("doc.open", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def save(self, params: DocSaveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSaveResult:
        return await self._runtime.invoke("doc.save", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def close(self, params: DocCloseParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCloseResult:
        return await self._runtime.invoke("doc.close", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def status(self, params: DocStatusParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocStatusResult:
        return await self._runtime.invoke("doc.status", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def describe(self, params: DocDescribeParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocDescribeResult:
        return await self._runtime.invoke("doc.describe", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def describeCommand(self, params: DocDescribeCommandParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocDescribeCommandResult:
        return await self._runtime.invoke("doc.describeCommand", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    @property
    def session(self):
        return _AsyncDocSessionApi(self._runtime)

class _AsyncDocFormatApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def bold(self, params: DocFormatBoldParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatBoldResult:
        return await self._runtime.invoke("doc.format.bold", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def italic(self, params: DocFormatItalicParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatItalicResult:
        return await self._runtime.invoke("doc.format.italic", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def underline(self, params: DocFormatUnderlineParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatUnderlineResult:
        return await self._runtime.invoke("doc.format.underline", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def strikethrough(self, params: DocFormatStrikethroughParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocFormatStrikethroughResult:
        return await self._runtime.invoke("doc.format.strikethrough", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _AsyncDocCreateApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def paragraph(self, params: DocCreateParagraphParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCreateParagraphResult:
        return await self._runtime.invoke("doc.create.paragraph", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _AsyncDocListsApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def list(self, params: DocListsListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsListResult:
        return await self._runtime.invoke("doc.lists.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def get(self, params: DocListsGetParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsGetResult:
        return await self._runtime.invoke("doc.lists.get", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def insert(self, params: DocListsInsertParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsInsertResult:
        return await self._runtime.invoke("doc.lists.insert", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def setType(self, params: DocListsSetTypeParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsSetTypeResult:
        return await self._runtime.invoke("doc.lists.setType", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def indent(self, params: DocListsIndentParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsIndentResult:
        return await self._runtime.invoke("doc.lists.indent", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def outdent(self, params: DocListsOutdentParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsOutdentResult:
        return await self._runtime.invoke("doc.lists.outdent", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def restart(self, params: DocListsRestartParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsRestartResult:
        return await self._runtime.invoke("doc.lists.restart", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def exit(self, params: DocListsExitParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocListsExitResult:
        return await self._runtime.invoke("doc.lists.exit", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _AsyncDocCommentsApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def add(self, params: DocCommentsAddParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsAddResult:
        return await self._runtime.invoke("doc.comments.add", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def edit(self, params: DocCommentsEditParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsEditResult:
        return await self._runtime.invoke("doc.comments.edit", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def reply(self, params: DocCommentsReplyParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsReplyResult:
        return await self._runtime.invoke("doc.comments.reply", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def move(self, params: DocCommentsMoveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsMoveResult:
        return await self._runtime.invoke("doc.comments.move", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def resolve(self, params: DocCommentsResolveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsResolveResult:
        return await self._runtime.invoke("doc.comments.resolve", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def remove(self, params: DocCommentsRemoveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsRemoveResult:
        return await self._runtime.invoke("doc.comments.remove", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def setInternal(self, params: DocCommentsSetInternalParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsSetInternalResult:
        return await self._runtime.invoke("doc.comments.setInternal", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def setActive(self, params: DocCommentsSetActiveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsSetActiveResult:
        return await self._runtime.invoke("doc.comments.setActive", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def goTo(self, params: DocCommentsGoToParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsGoToResult:
        return await self._runtime.invoke("doc.comments.goTo", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def get(self, params: DocCommentsGetParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsGetResult:
        return await self._runtime.invoke("doc.comments.get", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def list(self, params: DocCommentsListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocCommentsListResult:
        return await self._runtime.invoke("doc.comments.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _AsyncDocTrackChangesApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def list(self, params: DocTrackChangesListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesListResult:
        return await self._runtime.invoke("doc.trackChanges.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def get(self, params: DocTrackChangesGetParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesGetResult:
        return await self._runtime.invoke("doc.trackChanges.get", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def accept(self, params: DocTrackChangesAcceptParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesAcceptResult:
        return await self._runtime.invoke("doc.trackChanges.accept", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def reject(self, params: DocTrackChangesRejectParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesRejectResult:
        return await self._runtime.invoke("doc.trackChanges.reject", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def acceptAll(self, params: DocTrackChangesAcceptAllParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesAcceptAllResult:
        return await self._runtime.invoke("doc.trackChanges.acceptAll", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def rejectAll(self, params: DocTrackChangesRejectAllParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocTrackChangesRejectAllResult:
        return await self._runtime.invoke("doc.trackChanges.rejectAll", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

class _AsyncDocSessionApi:
    def __init__(self, runtime):
        self._runtime = runtime

    async def list(self, params: DocSessionListParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionListResult:
        return await self._runtime.invoke("doc.session.list", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def save(self, params: DocSessionSaveParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionSaveResult:
        return await self._runtime.invoke("doc.session.save", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def close(self, params: DocSessionCloseParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionCloseResult:
        return await self._runtime.invoke("doc.session.close", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)

    async def setDefault(self, params: DocSessionSetDefaultParams | None = None, *, timeout_ms=None, stdin_bytes=None) -> DocSessionSetDefaultResult:
        return await self._runtime.invoke("doc.session.setDefault", params or {}, timeout_ms=timeout_ms, stdin_bytes=stdin_bytes)


class SuperDocClient:
    def __init__(self, *, env=None, default_change_mode=None):
        self._runtime = SuperDocSyncRuntime(env=env, default_change_mode=default_change_mode)
        self.doc = _SyncDocApi(self._runtime)


class AsyncSuperDocClient:
    def __init__(self, *, env=None, default_change_mode=None):
        self._runtime = SuperDocAsyncRuntime(env=env, default_change_mode=default_change_mode)
        self.doc = _AsyncDocApi(self._runtime)
