lsp_schema.py

from __future__ import annotations

from typing import Literal
from typing import NotRequired
from typing import TypedDict

_BaseTypes = Literal['URI', 'DocumentUri', 'integer', 'uinteger', 'decimal', 'RegExp', 'string', 'boolean', 'null']


class EnumerationType(TypedDict):
    kind: Literal['base']
    name: Literal['string', 'integer', 'uinteger']


class EnumerationEntry(TypedDict):
    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    name: str
    proposed: NotRequired[bool]
    since: NotRequired[str]
    value: str | int


class ReferenceType(TypedDict):
    """Represents a reference to another type (e.g. `TextDocument`). This is either a `Structure`, a `Enumeration` or a `TypeAlias` in the same meta model."""  # noqa: E501

    kind: Literal['reference']
    name: str


class Property(TypedDict):
    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    name: str
    optional: NotRequired[bool]
    proposed: NotRequired[bool]
    since: NotRequired[str]
    type: EveryType


class StringLiteralType(TypedDict):
    """Represents a string literal type (e.g. `kind: 'rename'`)."""

    kind: Literal['stringLiteral']
    value: str


class AndType(TypedDict):
    """Represents an `and`type (e.g. TextDocumentParams & WorkDoneProgressParams`)."""

    items: list[EveryType]
    kind: Literal['and']


class OrType(TypedDict):
    """Represents an `or` type (e.g. `Location | LocationLink`)."""

    items: list[EveryType]
    kind: Literal['or']


class ArrayType(TypedDict):
    """Represents an array type (e.g. `TextDocument[]`)."""

    element: EveryType
    kind: Literal['array']


class BaseType(TypedDict):
    """Represents a base type like `string` or `DocumentUri`."""

    name: _BaseTypes
    kind: Literal['base']


class BooleanLiteralType(TypedDict):
    """Represents a boolean literal type (e.g. `kind: true`)."""

    value: bool
    kind: Literal['booleanLiteral']


class Enumeration(TypedDict):
    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    name: str
    proposed: NotRequired[bool]
    since: NotRequired[str]
    supportsCustomValues: NotRequired[bool]
    type: EnumerationType
    values: list[EnumerationEntry]


class IntegerLiteralType(TypedDict):
    value: int
    kind: Literal['integerLiteral']
    """Represents an integer literal type (e.g. `kind: 1`)."""


class _MapKeyType_1(TypedDict):
    kind: Literal['base']
    name: Literal['URI', 'DocumentUri', 'string', 'integer']


MapKeyType = _MapKeyType_1 | ReferenceType
"""Represents a type that can be used as a key in a map type. If a reference type is used then the type must either resolve to a `string` or `integer` type. (e.g. `type ChangeAnnotationIdentifier === string`)."""  # noqa: E501


class MapType(TypedDict):
    key: MapKeyType
    kind: Literal['map']
    value: EveryType


MessageDirection = Literal['clientToServer', 'serverToClient', 'both']
"""Indicates in which direction a message is sent in the protocol."""


class Notification(TypedDict):
    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    messageDirection: MessageDirection
    method: str
    params: NotRequired[EveryType]
    proposed: NotRequired[bool]
    registrationMethod: NotRequired[str]
    """Optional a dynamic registration method if it different from the request's method."""
    registrationOptions: NotRequired[EveryType]
    """Optional registration options if the notification supports dynamic registration."""
    since: NotRequired[str]
    typeName: str


class Request(TypedDict):
    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    errorData: NotRequired[EveryType]
    messageDirection: MessageDirection
    method: str
    params: NotRequired[EveryType]
    partialResult: NotRequired[EveryType]
    proposed: NotRequired[bool]
    registrationMethod: NotRequired[str]
    registrationOptions: NotRequired[EveryType]
    result: EveryType
    since: NotRequired[str]
    typeName: str


class Structure(TypedDict):
    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    extends: NotRequired[list[EveryType]]
    """Structures extended from. This structures form a polymorphic type hierarchy."""
    mixins: NotRequired[list[EveryType]]
    """Structures to mix in. The properties of these structures are `copied` into this structure. Mixins don't form a polymorphic type hierarchy in LSP."""  # noqa: E501
    name: str
    properties: list[Property]
    proposed: NotRequired[bool]
    since: NotRequired[str]


class StructureLiteral(TypedDict):
    """Defines a unnamed structure of an object literal."""

    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    properties: list[Property]
    proposed: NotRequired[bool]
    since: NotRequired[str]


class StructureLiteralType(TypedDict):
    """Represents a literal structure (e.g. `property: { start: uinteger; end: uinteger; }`)."""

    kind: Literal['literal']
    value: StructureLiteral


class TupleType(TypedDict):
    """Represents a `tuple` type (e.g. `[integer, integer]`)."""

    kind: Literal['tuple']
    items: list[EveryType]


class TypeAlias(TypedDict):
    """Defines a type alias. (e.g. `type Definition = Location | LocationLink`)."""

    deprecated: NotRequired[str]
    documentation: NotRequired[str]
    name: str
    proposed: NotRequired[bool]
    since: NotRequired[str]
    type: EveryType


TypeKind = Literal[
    'base',
    'reference',
    'array',
    'map',
    'and',
    'or',
    'tuple',
    'literal',
    'stringLiteral',
    'integerLiteral',
    'booleanLiteral',
]


class MetaData(TypedDict):
    version: str


class MetaModel(TypedDict):
    enumerations: list[Enumeration]
    metaData: MetaData
    notifications: list[Notification]
    requests: list[Request]
    structures: list[Structure]
    typeAliases: list[TypeAlias]


EveryType = (
    BaseType
    | ReferenceType
    | ArrayType
    | MapType
    | AndType
    | OrType
    | TupleType
    | StructureLiteralType
    | StringLiteralType
    | IntegerLiteralType
    | BooleanLiteralType
)