# The functions below are private bridge plumbing whose nanobind signatures
# cannot be represented in Python syntax: their positional ABI keeps a
# required argument after a defaulted path argument, and a few use ``in`` as
# the native parameter name. They are intentionally absent from the private
# extension stub; the supported service API lives in ``hgraph``.
_hgraph\.register_service_impl$:

_hgraph\.service_impl_output$:

_hgraph\.register_multi_service_impl$:

_hgraph\.adaptor_client$:

_hgraph\.adaptor_to_graph$:

_hgraph\.register_adaptor_impl$:

_hgraph\.service_adaptor_client$:

_hgraph\.service_adaptor_client_from_graph$:

_hgraph\.service_adaptor_client_to_graph$:

_hgraph\.service_adaptor_to_graph$:

_hgraph\.register_service_adaptor_impl$:

# These bound declarations otherwise retain C++ implementation spellings in
# forward references. Pattern replacements are nanobind's documented escape
# hatch for annotations that differ from the actual C++ signature metadata.
_hgraph\.TimeSeries\.value$:
    @property
    def value(self) -> object:
        \doc

_hgraph\.TimeSeries\.delta_value$:
    @property
    def delta_value(self) -> object:
        \doc

_hgraph\.TimeSeries\.modified$:
    @property
    def modified(self) -> bool:
        \doc

_hgraph\.TimeSeries\.valid$:
    @property
    def valid(self) -> bool:
        \doc

_hgraph\.TimeSeries\.owning_node$:
    @property
    def owning_node(self) -> Node | None:
        \doc

_hgraph\.TimeSeries\.owning_graph$:
    @property
    def owning_graph(self) -> Graph | None:
        \doc

_hgraph\.TimeSeries\.parent_input$:
    @property
    def parent_input(self) -> TimeSeries | None:
        \doc

_hgraph\.TimeSeries\.output$:
    @property
    def output(self) -> TimeSeriesOutput | None:
        \doc

# TimeSeries is one native runtime-view class whose collection/window surface
# dispatches by the schema kind.  Describe the public Python contract rather
# than leaking nanobind's erased ``object`` return types into editor support.
_hgraph\.TimeSeries\.(size|min_size)$:
    @property
    def \1(self) -> int | datetime.timedelta:
        \doc

_hgraph\.TimeSeries\.value_times$:
    \import numpy
    @property
    def value_times(self) -> numpy.ndarray:
        \doc

_hgraph\.TimeSeries\.(keys|modified_keys|valid_keys|added_keys|removed_keys)$:
    def \1(self) -> list[object]:
        \doc

_hgraph\.TimeSeries\.values$:
    def values(self) -> list[TimeSeries | object]:
        \doc

_hgraph\.TimeSeries\.(modified_values|valid_values|added_values|removed_values)$:
    def \1(self) -> list[TimeSeries]:
        \doc

_hgraph\.TimeSeries\.(items|modified_items|valid_items|added_items|removed_items)$:
    def \1(self) -> list[tuple[object, TimeSeries]]:
        \doc

_hgraph\.TimeSeries\.(added|removed)$:
    def \1(self) -> frozenset[object]:
        \doc

_hgraph\.TimeSeries\.get$:
    def get(self, key: object) -> TimeSeries | None:
        \doc

_hgraph\.TimeSeries\.key_from_value$:
    def key_from_value(self, value: TimeSeries) -> object | None:
        \doc

_hgraph\.TimeSeries\.__getitem__$:
    def __getitem__(self, key: object) -> TimeSeries: ...

_hgraph\.TimeSeries\.__iter__$:
    def __iter__(self) -> Iterator[object]: ...

_hgraph\.TimeSeries\.as_schema$:
    @property
    def as_schema(self) -> TimeSeries:
        \doc

_hgraph\.TimeSeries\.__getattr__$:
    def __getattr__(self, name: str) -> TimeSeries: ...

_hgraph\.OutputView\.(size|min_size)$:
    @property
    def \1(self) -> int | datetime.timedelta:
        \doc

_hgraph\.OutputView\.value_times$:
    \import numpy
    @property
    def value_times(self) -> numpy.ndarray:
        \doc

_hgraph\.OutputView\.(keys|modified_keys|valid_keys|added_keys|removed_keys)$:
    def \1(self) -> list[object]:
        \doc

_hgraph\.OutputView\.values$:
    def values(self) -> list[OutputView | object]:
        \doc

_hgraph\.OutputView\.(modified_values|valid_values|added_values|removed_values)$:
    def \1(self) -> list[OutputView]:
        \doc

_hgraph\.OutputView\.(items|modified_items|valid_items|added_items|removed_items)$:
    def \1(self) -> list[tuple[object, OutputView]]:
        \doc

_hgraph\.OutputView\.(added|removed)$:
    def \1(self) -> frozenset[object]:
        \doc

_hgraph\.OutputView\.get$:
    def get(self, key: object) -> OutputView | None:
        \doc

_hgraph\.OutputView\.pop$:
    def pop(self, key: object) -> OutputView | None:
        \doc

_hgraph\.OutputView\.key_from_value$:
    def key_from_value(self, value: OutputView) -> object | None:
        \doc

_hgraph\.OutputView\.__getitem__$:
    def __getitem__(self, key: object) -> OutputView: ...

_hgraph\.OutputView\.__setitem__$:
    def __setitem__(self, key: object, value: object) -> None: ...

_hgraph\.OutputView\.__delitem__$:
    def __delitem__(self, key: object) -> None: ...

_hgraph\.OutputView\.__iter__$:
    def __iter__(self) -> Iterator[object]: ...

_hgraph\.OutputView\.as_schema$:
    @property
    def as_schema(self) -> OutputView:
        \doc

_hgraph\.OutputView\.__getattr__$:
    def __getattr__(self, name: str) -> OutputView: ...

# Input/Node topology returns a distinct read-only output wrapper. It has the
# complete observational surface for every TS kind but deliberately omits all
# endpoint and value mutation methods.
_hgraph\.TimeSeriesOutput\.(size|min_size)$:
    @property
    def \1(self) -> int | datetime.timedelta:
        \doc

_hgraph\.TimeSeriesOutput\.value_times$:
    \import numpy
    @property
    def value_times(self) -> numpy.ndarray:
        \doc

_hgraph\.TimeSeriesOutput\.owning_node$:
    @property
    def owning_node(self) -> Node | None:
        \doc

_hgraph\.TimeSeriesOutput\.owning_graph$:
    @property
    def owning_graph(self) -> Graph | None:
        \doc

_hgraph\.TimeSeriesOutput\.(keys|modified_keys|valid_keys|added_keys|removed_keys)$:
    def \1(self) -> list[object]:
        \doc

_hgraph\.TimeSeriesOutput\.values$:
    def values(self) -> list[TimeSeriesOutput | object]:
        \doc

_hgraph\.TimeSeriesOutput\.(modified_values|valid_values|added_values|removed_values)$:
    def \1(self) -> list[TimeSeriesOutput]:
        \doc

_hgraph\.TimeSeriesOutput\.(items|modified_items|valid_items|added_items|removed_items)$:
    def \1(self) -> list[tuple[object, TimeSeriesOutput]]:
        \doc

_hgraph\.TimeSeriesOutput\.(added|removed)$:
    def \1(self) -> frozenset[object]:
        \doc

_hgraph\.TimeSeriesOutput\.get$:
    def get(self, key: object) -> TimeSeriesOutput | None:
        \doc

_hgraph\.TimeSeriesOutput\.key_from_value$:
    def key_from_value(self, value: TimeSeriesOutput) -> object | None:
        \doc

_hgraph\.TimeSeriesOutput\.__getitem__$:
    def __getitem__(self, key: object) -> TimeSeriesOutput: ...

_hgraph\.TimeSeriesOutput\.__iter__$:
    def __iter__(self) -> Iterator[object]: ...

_hgraph\.TimeSeriesOutput\.as_schema$:
    @property
    def as_schema(self) -> TimeSeriesOutput:
        \doc

_hgraph\.TimeSeriesOutput\.__getattr__$:
    def __getattr__(self, name: str) -> TimeSeriesOutput: ...

_hgraph\.TimeSeriesRef\.items$:
    @property
    def items(self) -> tuple[TimeSeriesRef, ...]:
        \doc

_hgraph\.TimeSeriesRef\.__getitem__$:
    def __getitem__(self, index: int) -> TimeSeriesRef: ...

_hgraph\.TimeSeriesRef\.__iter__$:
    def __iter__(self) -> Iterator[TimeSeriesRef]: ...

_hgraph\.Graph\.parent_node$:
    @property
    def parent_node(self) -> Node | None:
        \doc

_hgraph\.Graph\.nodes$:
    @property
    def nodes(self) -> list[Node]:
        \doc

_hgraph\.Node\.scalars$:
    @property
    def scalars(self) -> object | None:
        \doc

_hgraph\.Node\.input$:
    @property
    def input(self) -> TimeSeries | None:
        \doc

_hgraph\.Node\.inputs$:
    @property
    def inputs(self) -> dict[str, TimeSeries] | None:
        \doc

_hgraph\.Node\.(output|recordable_state|error_output)$:
    @property
    def \1(self) -> TimeSeriesOutput | None:
        \doc

_hgraph\.Node\.scheduler$:
    @property
    def scheduler(self) -> SchedulerState | None:
        \doc

_hgraph\.CivilDateTime\.time$:
    @property
    def time(self) -> datetime.time: ...

_hgraph\.Wiring\.service_client_paths$:
    def service_client_paths(self) -> list[tuple[str, str]]: ...

_hgraph\.Wiring\.built_service_paths$:
    def built_service_paths(self) -> list[tuple[str, str]]: ...

_hgraph\.RecordReplayScope\.__init__$:
    def __init__(self, mode: int, recordable_id: str = '') -> None: ...

_hgraph\.Scheduler\.has_tag$:
    def has_tag(self, tag: str) -> bool:
        \doc

_hgraph\.RuntimeGlobalState\.keys$:
    def keys(self) -> list[str]:
        \doc

_hgraph\.RuntimeGlobalState\.values$:
    def values(self) -> list[object]:
        \doc

_hgraph\.RuntimeGlobalState\.items$:
    def items(self) -> list[tuple[str, object]]:
        \doc

_hgraph\.RuntimeGlobalState\.__iter__$:
    def __iter__(self) -> Iterator[str]:
        \doc

_hgraph\.RuntimeGlobalState\.setdefault$:
    def setdefault(self, key: str, default: object | None = None) -> object:
        \doc

_hgraph\.RuntimeGlobalState\.pop$:
    @overload
    def pop(self, key: str) -> object:
        """Remove and return a value, raising KeyError when the key is absent."""
    @overload
    def pop(self, key: str, default: object) -> object:
        """Remove and return a value, or return the default when absent."""

_hgraph\.Scheduler\.schedule$:
    @overload
    def schedule(self, when: datetime.datetime, tag: str | None = None, on_wall_clock: bool = False) -> None:
        """Schedule at an absolute evaluation time."""
    @overload
    def schedule(self, when: datetime.timedelta, tag: str | None = None, on_wall_clock: bool = False) -> None:
        """Schedule after a duration relative to the current evaluation time."""

_hgraph\.Scheduler\.pop_tag$:
    def pop_tag(self, tag: str, default: object | None = None) -> datetime.datetime | object | None:
        \doc

_hgraph\.Scheduler\.un_schedule$:
    def un_schedule(self, tag: str | None = None) -> None:
        \doc

_hgraph\.Traits\.get_trait$:
    def get_trait(self, trait: str) -> object:
        \doc

_hgraph\.Traits\.get_trait_or$:
    def get_trait_or(self, trait: str, default: object | None = None) -> object:
        \doc

_hgraph\.RecordableStateView\.as_schema$:
    @property
    def as_schema(self) -> RecordableStateView:
        \doc
