type-bridge-schema-codegen 2.0.1

Deterministic projection-only schema emitters for type-bridge
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

from collections.abc import Iterator
from datetime import UTC, date, datetime, timedelta
from decimal import Decimal
from typing import assert_type

from generated_v2 import (
    Aliases,
    Container,
    Employment,
    Event,
    EventRef,
    FieldToken,
    FunctionRef,
    Identifier,
    Membership,
    Nickname,
    Person,
    PersonRef,
    PlayerStats,
    Robot,
    RoleToken,
    Score,
    ValBool,
    ValConstrained,
    ValDate,
    ValDatetime,
    ValDatetimeTz,
    ValDecimal,
    ValDouble,
    ValDuration,
    find_events,
)

assert_type(Employment.employee, RoleToken[Employment, Person])
assert_type(Container.item, RoleToken[Container, Event])
assert_type(Event.subject, RoleToken[Event, Person])
assert_type(Membership.member, RoleToken[Membership, Person | Robot])
assert_type(Person.identifier, FieldToken[Person])
assert_type(Person.nickname, FieldToken[Person])
assert_type(Person.aliases, FieldToken[Person])

person = Person(
    identifier=Identifier("person-1"),
    nickname=Nickname("alice"),
    aliases=[Aliases("a"), Aliases("b")],
    score=Score(3),
    val_bool=ValBool(True),
    val_constrained=ValConstrained(20),
    val_date=ValDate(date(2026, 7, 29)),
    val_datetime=ValDatetime(datetime(2026, 7, 29)),
    val_datetime_tz=ValDatetimeTz(datetime(2026, 7, 29, tzinfo=UTC)),
    val_decimal=ValDecimal(Decimal("3.5")),
    val_double=ValDouble(3.5),
    val_duration=ValDuration(timedelta(seconds=3)),
)
assert_type(person.identifier, Identifier)
assert_type(person.nickname, Nickname | None)
assert_type(person.aliases, tuple[Aliases, ...])

event = Event(subject=person)
assert_type(event.subject, Person)

employment = Employment(employee=person)
assert_type(employment.employee, Person)

container = Container(item=[EventRef("event-iid")])
assert_type(container.item, tuple[EventRef, ...])

person_reference = PersonRef("person-iid", identifier=Identifier("person-1"))
assert_type(person_reference, PersonRef)

stats = PlayerStats(wins=3, nickname=None)
assert_type(stats, PlayerStats)

assert_type(
    find_events,
    FunctionRef[[Event], Iterator[Event]],
)