Schema markers

from typing import Annotated, Optional

from pydantic import BaseModel
from charter import Body, Case, Format, Mode, Path, Query


class SendMessage(BaseModel):
    user_id: Annotated[str, Path()]
    notify: Annotated[Optional[bool], Query()] = None
    raw: Annotated[str, Body(), Format("base64url")]
    thread_id: Annotated[Optional[str], Body(), Case("snake")] = None
    message_id: Annotated[Optional[str], Mode("response_only")] = None

class Path:
    def __init__(self, allow_slash: bool = False) -> None: ...

class Query:
    def __init__(self) -> None: ...

class Body:
    def __init__(self, envelop: bool = False) -> None: ...

class Format:
    def __init__(self, transform: str) -> None: ...

class Mode:
    def __init__(self, modes: str) -> None: ...

def partial_of(
    model: type[BaseModel],
    *,
    name: str | None = None,
    doc: str | None = None,
) -> type[BaseModel]: ...

from typing import Optional

from pydantic import BaseModel, Field

from charter import partial_of


class Label(BaseModel):
    name: str = Field(..., description="The display name of the label.")
    color: Optional[str] = Field(None, description="Hex colour to assign.")


PatchLabelRequest = partial_of(Label, name="PatchLabelRequest")

assert not PatchLabelRequest.model_fields["name"].is_required()
assert PatchLabelRequest.model_fields["name"].description == Label.model_fields["name"].description

class Case:
    def __init__(self, case: KeyCase) -> None: ...

from typing import Annotated

from pydantic import BaseModel
from charter import Body, Case


class Place(BaseModel):
    display_name: Annotated[str, Case("pascal"), Body()]  # DisplayName

class ConflictsWith:
    def __init__(self, *fields: str, reason: str = "") -> None: ...

from typing import Annotated, Optional

from pydantic import BaseModel, Field
from charter import ConflictsWith, Query, WireName


class ListEvents(BaseModel):
    sync_token: Annotated[Optional[str], Field(None), Query()]
    i_cal_uid: Annotated[
        Optional[str],
        Field(None),
        Query(),
        WireName("iCalUID"),
        ConflictsWith("sync_token", reason="Drop syncToken to run a fresh query."),
    ]

iCalUID, q, timeMin cannot be combined with syncToken. Drop syncToken to run a
fresh query.

class WireName:
    def __init__(self, name: str) -> None: ...

from typing import Annotated
from typing import Optional

from pydantic import BaseModel, Field
from charter import Query, WireName


class ListEvents(BaseModel):
    i_cal_uid: Annotated[Optional[str], Field(None), Query(), WireName("iCalUID")]

class Gloss:
    def __init__(self, text: str) -> None: ...

from typing import Annotated, Optional

from pydantic import BaseModel, Field
from charter import Body, Gloss


class CreateRefund(BaseModel):
    amount: Annotated[
        Optional[int],
        Field(
            None,
            ge=1,
            description=(
                "A positive integer in the smallest currency unit representing "
                "how much to refund."
            ),
        ),
        Body(),
        Gloss("Cents, not dollars: $15.00 is 1500. Multiply a decimal amount by 100."),
    ]

A positive integer in the smallest currency unit representing how much to
refund. Cents, not dollars: $15.00 is 1500. Multiply a decimal amount by 100.

KeyCase = Literal["camel", "snake", "pascal", "kebab"]

class TransportOverride(TypedDict, total=False):
    path: Dict[str, Any]
    query: Dict[str, Any]
    body: Any
    headers: Dict[str, str]

from pydantic import BaseModel
from charter import TransportOverride


class ForecastRequest(BaseModel):
    metric: bool = True
    language: str = "en"


def build_forecast_request(tool_input: ForecastRequest) -> TransportOverride:
    return {
        "query": {
            "metric": str(tool_input.metric).lower(),
            "language": tool_input.language,
            "details": "true",
        }
    }