From c9bc9a440f1de5b7efbcc4979f964e01bc5429b9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 02:42:49 -0800 Subject: [PATCH 01/11] chore(quest): claim quest/m1/ffi-export/api-surface.md Quest-Claim: 18488b674bb30948 From 8b496f63c79b3ac95c7927ebf51c33b73764957a Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 03:47:39 -0800 Subject: [PATCH 02/11] ffi: lock each language's rendered API in surface files Co-Authored-By: Claude Opus 5.5 --- ffi/justfile | 21 + ffi/surface/api/c.h | 2190 ++++++ ffi/surface/api/cpp.hpp | 1918 +++++ ffi/surface/api/dart.dart | 1639 ++++ ffi/surface/api/go.txt | 1841 +++++ ffi/surface/api/kotlin.kt | 1432 ++++ ffi/surface/api/python.pyi | 1506 ++++ ffi/surface/api/swift.swift | 1436 ++++ ffi/surface/api/web.d.ts | 2618 ++++++ ffi/surface/moq-web/web.d.ts | 14007 +++++++++++++++++++++++++++++++++ ffi/surface/moq/c.h | 12419 +++++++++++++++++++++++++++++ ffi/surface/moq/cpp.hpp | 11665 +++++++++++++++++++++++++++ ffi/surface/moq/dart.dart | 10350 ++++++++++++++++++++++++ ffi/surface/moq/go.txt | 11101 ++++++++++++++++++++++++++ ffi/surface/moq/kotlin.kt | 9728 +++++++++++++++++++++++ ffi/surface/moq/python.pyi | 9690 +++++++++++++++++++++++ ffi/surface/moq/swift.swift | 9328 ++++++++++++++++++++++ ffi/surface/surface.py | 880 +++ ffi/surface/test_surface.py | 313 + sh/dispatch.sh | 11 +- 20 files changed, 104091 insertions(+), 2 deletions(-) create mode 100644 ffi/surface/api/c.h create mode 100644 ffi/surface/api/cpp.hpp create mode 100644 ffi/surface/api/dart.dart create mode 100644 ffi/surface/api/go.txt create mode 100644 ffi/surface/api/kotlin.kt create mode 100644 ffi/surface/api/python.pyi create mode 100644 ffi/surface/api/swift.swift create mode 100644 ffi/surface/api/web.d.ts create mode 100644 ffi/surface/moq-web/web.d.ts create mode 100644 ffi/surface/moq/c.h create mode 100644 ffi/surface/moq/cpp.hpp create mode 100644 ffi/surface/moq/dart.dart create mode 100644 ffi/surface/moq/go.txt create mode 100644 ffi/surface/moq/kotlin.kt create mode 100644 ffi/surface/moq/python.pyi create mode 100644 ffi/surface/moq/swift.swift create mode 100644 ffi/surface/surface.py create mode 100644 ffi/surface/test_surface.py diff --git a/ffi/justfile b/ffi/justfile index 4d1712aca..29fde9470 100644 --- a/ffi/justfile +++ b/ffi/justfile @@ -64,6 +64,27 @@ fix: run *args: cargo run --locked --quiet -- {{ args }} +# Write surface/, each binding's API as its language renders it, from the api fixture's export and moq's stand-in's at the pinned moq revision: --check fails where a committed file differs instead. The files are x86_64 Linux's exports, whose targets they name. +surface *flags: moq-write (standin "" "web") + #!/usr/bin/env bash + set -euo pipefail + if [ "{{ arch() }}-{{ os() }}" != x86_64-linux ]; then + echo "the surface files are x86_64 Linux's exports: run this there" >&2 + exit 1 + fi + # moq-write's export, of the host alone. + if [ "$(jq -c .api.targets target/export/moq/api.json)" != '["x86_64-unknown-linux-gnu"]' ]; then + echo "target/export/moq merged the APIs staged in target/moq-api: delete them for the host's export" >&2 + exit 1 + fi + # The api fixture as its tests export it, with wasm32 for the web binding. + cargo run --locked --quiet -- --config fixtures/api/ffi.toml --out target/surface/api --target x86_64-unknown-linux-gnu --target wasm32-wasip1 -- --features doubled + cargo run --locked --quiet -- --config moq/web.toml --manifest-path target/moq-ffi-web/Cargo.toml --target wasm32-wasip1 --out target/surface/moq-web + python3 -I surface/surface.py {{ flags }} target/surface/api surface/api + python3 -I surface/surface.py {{ flags }} target/export/moq surface/moq + # Its other bindings are moq's on wasm32, which no one ships. + python3 -I surface/surface.py {{ flags }} target/surface/moq-web surface/moq-web web.d.ts + # Census the stand-in facade moq/ffi.toml exports into target/census/moq-ffi.md, from the pinned moq revision or a checkout, failing when moq/ffi.toml excludes an item that exports. census checkout="": (standin checkout) cargo run --locked --quiet -- --config moq/ffi.toml --manifest-path target/moq-ffi/Cargo.toml --census target/census diff --git a/ffi/surface/api/c.h b/ffi/surface/api/c.h new file mode 100644 index 000000000..1635c0472 --- /dev/null +++ b/ffi/surface/api/c.h @@ -0,0 +1,2190 @@ +/* api.h */ +#ifndef API_H +#define API_H +#include +#include +#include +#ifdef __cplusplus +extern "C" { +#endif +#define API_CONTRACT ((uint64_t)0x20a58f2a80705774ULL) +uint64_t api_contract(void); +uint32_t api_target(void); +typedef int32_t api_status; +enum { + API_STATUS_MOVED = 1, + API_STATUS_EXCLUSIVE = 2, + API_STATUS_BORROWED = 3, + API_STATUS_THREAD = 4, + API_STATUS_LENT = 5, + API_STATUS_OUTLIVED = 6, + API_STATUS_NOT_SEND = 7, +}; +const char *api_status_message(api_status status); +typedef struct api_buf { + const uint8_t *ptr; + size_t len; + void *owner; +} api_buf; +void api_buf_free(api_buf buf); +api_buf api_buf_copy(api_buf view); +api_buf api_buf_clone(api_buf buf); +typedef struct api_u128 { + uint64_t lo; + uint64_t hi; +} api_u128; +typedef struct api_duration { + uint64_t secs; + uint32_t nanos; +} api_duration; +typedef struct api_ipv4_addr { + uint8_t octets[4]; +} api_ipv4_addr; +typedef struct api_ipv6_addr { + uint8_t octets[16]; +} api_ipv6_addr; +typedef struct api_ip_addr { + bool v6; + union { + api_ipv4_addr v4; + api_ipv6_addr v6; + } ip; +} api_ip_addr; +typedef struct api_socket_addr_v4 { + api_ipv4_addr ip; + uint16_t port; +} api_socket_addr_v4; +typedef struct api_socket_addr_v6 { + api_ipv6_addr ip; + uint16_t port; + uint32_t flowinfo; + uint32_t scope_id; +} api_socket_addr_v6; +typedef struct api_socket_addr { + bool v6; + union { + api_socket_addr_v4 v4; + api_socket_addr_v6 v6; + } addr; +} api_socket_addr; +typedef struct api_waker { + void (*wake)(void *data); + void (*drop)(void *data); + void *data; +} api_waker; +void api_thread_wake(api_waker wake); +void api_thread_drain(void); +typedef struct api_foreign_future { + bool (*poll)(void *data, api_waker waker); + void (*free)(void *data); + void *data; +} api_foreign_future; +typedef struct api_foreign_reader { + bool (*read)(void *data, uint8_t *buf, size_t len, size_t *n, api_buf *err); + bool (*seek)(void *data, int whence, int64_t offset, uint64_t *position, api_buf *err); + void *data; +} api_foreign_reader; +typedef enum api_poll { + API_POLL_PENDING = 0, + API_POLL_READY = 1, + API_POLL_ERROR = 2, +} api_poll; +typedef struct api_Board api_Board; +typedef struct api_Receipt api_Receipt; +typedef struct api_Draft api_Draft; +typedef struct api_Filed_Receipt api_Filed_Receipt; +typedef struct api_Pad_u16 api_Pad_u16; +typedef struct api_Pad_u8 api_Pad_u8; +typedef struct api_Layered api_Layered; +typedef struct api_Marker api_Marker; +typedef struct api_Batch api_Batch; +typedef struct api_Batch_2 api_Batch_2; +typedef struct api_Waiter api_Waiter; +typedef struct api_Logger api_Logger; +typedef struct api_Journal api_Journal; +typedef struct api_Local api_Local; +typedef struct api_LocalWaiter api_LocalWaiter; +typedef struct api_Retry api_Retry; +typedef struct api_Digest api_Digest; +typedef struct api_Cursor api_Cursor; +typedef struct api_Outer_Inner_u8 api_Outer_Inner_u8; +typedef struct api_Slot_u32 api_Slot_u32; +typedef struct api_Slot_u8 api_Slot_u8; +typedef struct api_Resolving api_Resolving; +typedef struct api_Codecs api_Codecs; +typedef struct api_Der api_Der; +typedef struct api_Verbosity api_Verbosity; +typedef struct api_Site api_Site; +typedef struct api_Trail api_Trail; +typedef struct api_Worker api_Worker; +typedef struct api_Handle api_Handle; +typedef struct api_Area api_Area; +typedef struct api_Counter api_Counter; +typedef struct api_Meter api_Meter; +typedef struct api_Meters api_Meters; +typedef struct api_Registry api_Registry; +typedef struct api_Ledger api_Ledger; +typedef struct api_Slip api_Slip; +typedef struct api_Sheet api_Sheet; +typedef struct api_Name api_Name; +typedef struct api_Channel api_Channel; +typedef struct api_Gap api_Gap; +typedef struct api_Berth api_Berth; +typedef struct api_Mark api_Mark; +typedef struct api_Message api_Message; +typedef struct api_Node api_Node; +typedef struct api_Tally api_Tally; +typedef struct api_Tallies api_Tallies; +typedef struct api_Gauge api_Gauge; +typedef struct api_Latch api_Latch; +typedef struct api_Token api_Token; +typedef struct api_Stack api_Stack; +typedef struct api_Refusal api_Refusal; +typedef struct api_c api_c; +typedef struct api_Key api_Key; +typedef struct api_clash_Store api_clash_Store; +typedef struct api_tls_Session api_tls_Session; +typedef struct api_Url api_Url; +typedef struct api_Json api_Json; +typedef struct api_Instant api_Instant; +typedef struct api_std_io_Error api_std_io_Error; +typedef struct api_tls_Config api_tls_Config; +typedef struct api_tls_Cert api_tls_Cert; +typedef struct api_tls_Resolver api_tls_Resolver; +typedef struct api_tls_Codec api_tls_Codec; +typedef struct api_Spawned api_Spawned; +typedef struct api_LogThread api_LogThread; +typedef enum api_Shape { + API_SHAPE_CIRCLE = 1, + API_SHAPE_SQUARE = 4, +} api_Shape; +typedef enum api_Status_ { + API_STATUS__MOVED = 0, + API_STATUS__KEPT = 1, +} api_Status_; +typedef enum api_Family { + API_FAMILY_NATIVE = 0, + API_FAMILY_WASM = 1, +} api_Family; +typedef enum api_VecClashTone { + API_VECCLASHTONE_ERROR = 0, +} api_VecClashTone; +typedef enum api_Level { + API_LEVEL_TRACE = 0, + API_LEVEL_DEBUG = 1, + API_LEVEL_INFO = 2, + API_LEVEL_WARN = 3, + API_LEVEL_ERROR = 4, +} api_Level; +typedef enum api_bound { + API_BOUND_UNBOUNDED = 0, + API_BOUND_INCLUDED = 1, + API_BOUND_EXCLUDED = 2, +} api_bound; +typedef struct api_vec_Counter { + api_Counter *const *ptr; + size_t len; + void *owner; +} api_vec_Counter; +void api_vec_Counter_free(api_vec_Counter vec); +typedef struct api_Point { + int32_t x; + int32_t y; +} api_Point; +typedef struct api_option_Point { + bool some; + api_Point value; +} api_option_Point; +typedef struct api_option_duration { + bool some; + api_duration value; +} api_option_duration; +typedef struct api_Label { + api_buf name; + api_option_Point at; + api_option_duration ttl; +} api_Label; +typedef struct api_vec_Label { + const api_Label *ptr; + size_t len; + void *owner; +} api_vec_Label; +void api_vec_Label_free(api_vec_Label vec); +typedef struct api_vec_Point { + const api_Point *ptr; + size_t len; + void *owner; +} api_vec_Point; +void api_vec_Point_free(api_vec_Point vec); +typedef struct api_vec_Refusal { + api_Refusal *const *ptr; + size_t len; + void *owner; +} api_vec_Refusal; +void api_vec_Refusal_free(api_vec_Refusal vec); +typedef struct api_vec_Shape { + const api_Shape *ptr; + size_t len; + void *owner; +} api_vec_Shape; +void api_vec_Shape_free(api_vec_Shape vec); +typedef struct api_vec_Token { + api_Token *const *ptr; + size_t len; + void *owner; +} api_vec_Token; +void api_vec_Token_free(api_vec_Token vec); +typedef struct api_vec_bytes { + const api_buf *ptr; + size_t len; + void *owner; +} api_vec_bytes; +void api_vec_bytes_free(api_vec_bytes vec); +typedef struct api_clash_Tone { + uint16_t hz; +} api_clash_Tone; +typedef struct api_vec_clash_Tone { + const api_clash_Tone *ptr; + size_t len; + void *owner; +} api_vec_clash_Tone; +void api_vec_clash_Tone_free(api_vec_clash_Tone vec); +typedef struct api_vec_f32 { + const float *ptr; + size_t len; + void *owner; +} api_vec_f32; +void api_vec_f32_free(api_vec_f32 vec); +typedef struct api_vec_f64 { + const double *ptr; + size_t len; + void *owner; +} api_vec_f64; +void api_vec_f64_free(api_vec_f64 vec); +typedef struct api_vec_i16 { + const int16_t *ptr; + size_t len; + void *owner; +} api_vec_i16; +void api_vec_i16_free(api_vec_i16 vec); +typedef struct api_vec_i32 { + const int32_t *ptr; + size_t len; + void *owner; +} api_vec_i32; +void api_vec_i32_free(api_vec_i32 vec); +typedef struct api_vec_i64 { + const int64_t *ptr; + size_t len; + void *owner; +} api_vec_i64; +void api_vec_i64_free(api_vec_i64 vec); +typedef struct api_vec_i8 { + const int8_t *ptr; + size_t len; + void *owner; +} api_vec_i8; +void api_vec_i8_free(api_vec_i8 vec); +typedef struct api_vec_option_path { + const api_buf *ptr; + size_t len; + void *owner; +} api_vec_option_path; +void api_vec_option_path_free(api_vec_option_path vec); +typedef struct api_vec_path { + const api_buf *ptr; + size_t len; + void *owner; +} api_vec_path; +void api_vec_path_free(api_vec_path vec); +typedef struct api_vec_socket_addr { + const api_socket_addr *ptr; + size_t len; + void *owner; +} api_vec_socket_addr; +void api_vec_socket_addr_free(api_vec_socket_addr vec); +typedef struct api_vec_string { + const api_buf *ptr; + size_t len; + void *owner; +} api_vec_string; +void api_vec_string_free(api_vec_string vec); +typedef struct api_vec_tls_Cert { + api_tls_Cert *const *ptr; + size_t len; + void *owner; +} api_vec_tls_Cert; +void api_vec_tls_Cert_free(api_vec_tls_Cert vec); +typedef struct api_vec_tls_Codec { + api_tls_Codec *const *ptr; + size_t len; + void *owner; +} api_vec_tls_Codec; +void api_vec_tls_Codec_free(api_vec_tls_Codec vec); +typedef struct api_tuple_Counter_Refusal { + api_Counter *_0; + api_Refusal *_1; +} api_tuple_Counter_Refusal; +typedef struct api_vec_tuple_Counter_Refusal { + const api_tuple_Counter_Refusal *ptr; + size_t len; + void *owner; +} api_vec_tuple_Counter_Refusal; +void api_vec_tuple_Counter_Refusal_free(api_vec_tuple_Counter_Refusal vec); +typedef struct api_tuple_string_Counter { + api_buf _0; + api_Counter *_1; +} api_tuple_string_Counter; +typedef struct api_vec_tuple_string_Counter { + const api_tuple_string_Counter *ptr; + size_t len; + void *owner; +} api_vec_tuple_string_Counter; +void api_vec_tuple_string_Counter_free(api_vec_tuple_string_Counter vec); +typedef struct api_tuple_string_Json { + api_buf _0; + api_Json *_1; +} api_tuple_string_Json; +typedef struct api_vec_tuple_string_Json { + const api_tuple_string_Json *ptr; + size_t len; + void *owner; +} api_vec_tuple_string_Json; +void api_vec_tuple_string_Json_free(api_vec_tuple_string_Json vec); +typedef struct api_tuple_string_Point { + api_buf _0; + api_Point _1; +} api_tuple_string_Point; +typedef struct api_vec_tuple_string_Point { + const api_tuple_string_Point *ptr; + size_t len; + void *owner; +} api_vec_tuple_string_Point; +void api_vec_tuple_string_Point_free(api_vec_tuple_string_Point vec); +typedef struct api_tuple_string_Shape_Point { + api_buf _0; + api_Shape _1; + api_Point _2; +} api_tuple_string_Shape_Point; +typedef struct api_vec_tuple_string_Shape_Point { + const api_tuple_string_Shape_Point *ptr; + size_t len; + void *owner; +} api_vec_tuple_string_Shape_Point; +void api_vec_tuple_string_Shape_Point_free(api_vec_tuple_string_Shape_Point vec); +typedef struct api_Ticket { + uint32_t opaque[1]; +} api_Ticket; +typedef struct api_tuple_string_Ticket { + api_buf _0; + api_Ticket _1; +} api_tuple_string_Ticket; +typedef struct api_vec_tuple_string_Ticket { + const api_tuple_string_Ticket *ptr; + size_t len; + void *owner; +} api_vec_tuple_string_Ticket; +void api_vec_tuple_string_Ticket_free(api_vec_tuple_string_Ticket vec); +typedef struct api_vec_u16 { + const uint16_t *ptr; + size_t len; + void *owner; +} api_vec_u16; +void api_vec_u16_free(api_vec_u16 vec); +typedef struct api_vec_u32 { + const uint32_t *ptr; + size_t len; + void *owner; +} api_vec_u32; +void api_vec_u32_free(api_vec_u32 vec); +typedef struct api_vec_u64 { + const uint64_t *ptr; + size_t len; + void *owner; +} api_vec_u64; +void api_vec_u64_free(api_vec_u64 vec); +typedef struct api_vec_vec_u32 { + const api_vec_u32 *ptr; + size_t len; + void *owner; +} api_vec_vec_u32; +void api_vec_vec_u32_free(api_vec_vec_u32 vec); +typedef struct api_bound_u64 { + api_bound kind; + uint64_t value; +} api_bound_u64; +typedef struct api_bounds_u64 { + api_bound_u64 start; + api_bound_u64 end; +} api_bounds_u64; +typedef struct api_range_u64 { + uint64_t start; + uint64_t end; +} api_range_u64; +typedef struct api_array_u8_4 { + uint8_t items[4]; +} api_array_u8_4; +typedef struct api_option_Level { + bool some; + api_Level value; +} api_option_Level; +typedef struct api_Moment { + uint64_t opaque[2]; +} api_Moment; +typedef struct api_option_Moment { + bool some; + api_Moment value; +} api_option_Moment; +typedef struct api_Reading { + bool ok; + float level; + double ratio; + uint32_t mark; + api_Shape shape; + api_Point at; + api_buf note; + uint64_t count; + int8_t offset; + size_t len; + uint16_t tag; +} api_Reading; +typedef struct api_option_Reading { + bool some; + api_Reading value; +} api_option_Reading; +typedef struct api_Stamp { + uint64_t opaque[1]; +} api_Stamp; +typedef struct api_option_Stamp { + bool some; + api_Stamp value; +} api_option_Stamp; +typedef struct api_option_char { + bool some; + uint32_t value; +} api_option_char; +typedef struct api_option_non_zero_u64 { + bool some; + uint64_t value; +} api_option_non_zero_u64; +typedef struct api_polar_Point { + uint8_t turns; + uint32_t distance; +} api_polar_Point; +typedef struct api_option_polar_Point { + bool some; + api_polar_Point value; +} api_option_polar_Point; +typedef struct api_tuple_Counter { + api_Counter *_0; +} api_tuple_Counter; +typedef struct api_option_tuple_Counter { + bool some; + api_tuple_Counter value; +} api_option_tuple_Counter; +typedef struct api_option_tuple_Counter_Refusal { + bool some; + api_tuple_Counter_Refusal value; +} api_option_tuple_Counter_Refusal; +typedef struct api_option_u32 { + bool some; + uint32_t value; +} api_option_u32; +typedef struct api_tuple_option_u32 { + api_option_u32 _0; +} api_tuple_option_u32; +typedef struct api_option_tuple_option_u32 { + bool some; + api_tuple_option_u32 value; +} api_option_tuple_option_u32; +typedef struct api_tuple_string { + api_buf _0; +} api_tuple_string; +typedef struct api_option_tuple_string { + bool some; + api_tuple_string value; +} api_option_tuple_string; +typedef struct api_tuple_string_Shape { + api_buf _0; + api_Shape _1; +} api_tuple_string_Shape; +typedef struct api_option_tuple_string_Shape { + bool some; + api_tuple_string_Shape value; +} api_option_tuple_string_Shape; +typedef struct api_tuple_u8_u16 { + uint8_t _0; + uint16_t _1; +} api_tuple_u8_u16; +typedef struct api_tuple_tuple_u8_u16_u32 { + api_tuple_u8_u16 _0; + uint32_t _1; +} api_tuple_tuple_u8_u16_u32; +typedef struct api_option_tuple_tuple_u8_u16_u32 { + bool some; + api_tuple_tuple_u8_u16_u32 value; +} api_option_tuple_tuple_u8_u16_u32; +typedef struct api_tuple_u8_u16_u32 { + uint8_t _0; + uint16_t _1; + uint32_t _2; +} api_tuple_u8_u16_u32; +typedef struct api_tuple_tuple_u8_u16_u32_ { + api_tuple_u8_u16_u32 _0; +} api_tuple_tuple_u8_u16_u32_; +typedef struct api_option_tuple_tuple_u8_u16_u32_ { + bool some; + api_tuple_tuple_u8_u16_u32_ value; +} api_option_tuple_tuple_u8_u16_u32_; +typedef struct api_tuple_u8_i16_u32_u64 { + uint8_t _0; + int16_t _1; + uint32_t _2; + uint64_t _3; +} api_tuple_u8_i16_u32_u64; +typedef struct api_option_tuple_u8_i16_u32_u64 { + bool some; + api_tuple_u8_i16_u32_u64 value; +} api_option_tuple_u8_i16_u32_u64; +typedef struct api_tuple_usize_usize { + size_t _0; + size_t _1; +} api_tuple_usize_usize; +typedef struct api_option_tuple_usize_usize { + bool some; + api_tuple_usize_usize value; +} api_option_tuple_usize_usize; +typedef struct api_option_u128 { + bool some; + api_u128 value; +} api_option_u128; +typedef struct api_option_u64 { + bool some; + uint64_t value; +} api_option_u64; +typedef struct api_Seat { + api_Mark *mark; + uint32_t row; +} api_Seat; +typedef enum api_Choice_tag { + API_CHOICE_EMPTY = 0, + API_CHOICE_PICKED = 1, +} api_Choice_tag; +typedef struct api_Choice_Picked { + api_Mark *_0; +} api_Choice_Picked; +typedef struct api_Choice { + api_Choice_tag tag; + union { + api_Choice_Picked picked; + }; +} api_Choice; +typedef struct api_tuple_Counter_Mark_Seat_Choice { + api_Counter *_0; + api_Mark *_1; + api_Seat _2; + api_Choice _3; +} api_tuple_Counter_Mark_Seat_Choice; +typedef struct api_tuple_Counter_bytes { + api_Counter *_0; + api_buf _1; +} api_tuple_Counter_bytes; +typedef struct api_tuple_Mark_bytes { + api_Mark *_0; + api_buf _1; +} api_tuple_Mark_bytes; +typedef struct api_tuple_bytes { + api_buf _0; +} api_tuple_bytes; +typedef struct api_tuple_bytes_Refusal { + api_buf _0; + api_Refusal *_1; +} api_tuple_bytes_Refusal; +typedef struct api_tuple_bytes_u32 { + api_buf _0; + uint32_t _1; +} api_tuple_bytes_u32; +typedef struct api_tuple_string_u32 { + api_buf _0; + uint32_t _1; +} api_tuple_string_u32; +typedef struct api_tuple_u32_u32 { + uint32_t _0; + uint32_t _1; +} api_tuple_u32_u32; +typedef struct api_Parcel { + api_Mark *mark; + api_buf payload; +} api_Parcel; +typedef struct api_Score { + uint64_t opaque[1]; +} api_Score; +typedef struct api_Weighted { + api_Score score; + uint32_t weight; +} api_Weighted; +typedef struct api_Stamped { + api_Stamp at; + uint32_t count; +} api_Stamped; +typedef struct api_CancellationError { + uint32_t code; +} api_CancellationError; +typedef struct api_Packet { + uint32_t seq; + api_buf payload; +} api_Packet; +typedef struct api_Hasher { + uint8_t seed; +} api_Hasher; +typedef struct api_Size { + uint32_t width; + uint32_t height; +} api_Size; +typedef struct api_Note { + api_buf text; +} api_Note; +typedef struct api_Packaged { + uint32_t api; +} api_Packaged; +typedef struct api_Atlas { + api_vec_tuple_string_Point points; + api_vec_u32 ids; +} api_Atlas; +typedef struct api_Span { + api_tuple_u32_u32 bounds; + api_option_tuple_string_Shape named; +} api_Span; +typedef struct api_Window { + api_range_u64 range; + api_bound_u64 end; +} api_Window; +typedef struct api_LongArray { + uint64_t opaque[2]; +} api_LongArray; +typedef struct api_JvmField { + uint32_t n; +} api_JvmField; +typedef struct api_JvmStatic { + uint32_t n; +} api_JvmStatic; +typedef struct api_OptIn { + uint32_t n; +} api_OptIn; +typedef struct api_Wide { + uint64_t opaque[128]; +} api_Wide; +typedef struct api_Clocked { + api_Moment at; + uint32_t count; +} api_Clocked; +typedef struct api_Hits { + uint64_t opaque[2]; +} api_Hits; +typedef struct api_Extent { + uint64_t opaque[2]; +} api_Extent; +typedef struct api_Pair_Size_u8 { + api_Size left; + uint8_t right; +} api_Pair_Size_u8; +typedef struct api_Pair_non_zero_u16 { + uint16_t left; + uint16_t right; +} api_Pair_non_zero_u16; +typedef struct api_Pair_u32 { + uint32_t left; + uint32_t right; +} api_Pair_u32; +typedef struct api_Pair_u8_Size { + uint8_t left; + api_Size right; +} api_Pair_u8_Size; +typedef struct api_Right_u8 { + uint8_t value; +} api_Right_u8; +typedef struct api_Left_Right_u8 { + api_Right_u8 value; +} api_Left_Right_u8; +typedef struct api_Left_u8 { + uint8_t value; +} api_Left_u8; +typedef struct api_Right_Left_u8 { + api_Left_u8 value; +} api_Right_Left_u8; +typedef struct api_Inner_u8 { + uint8_t value; +} api_Inner_u8; +typedef struct api_Boxed_u16 { + uint16_t value; +} api_Boxed_u16; +typedef struct api_Boxed_u8 { + uint8_t value; +} api_Boxed_u8; +typedef struct api_LogCount { + uint32_t kept; +} api_LogCount; +typedef struct api_Wrap_u32 { + uint32_t value; +} api_Wrap_u32; +typedef struct api_PolarTurn { + uint8_t whole; +} api_PolarTurn; +typedef struct api_Peer { + api_socket_addr addr; + api_vec_string names; +} api_Peer; +typedef struct api_Shadowed { + api_vec_i32 other; + uint8_t a; + uint8_t b; +} api_Shadowed; +typedef struct api_Numbers { + api_vec_u16 u16s; + api_vec_u32 u32s; + api_vec_u64 u64s; + api_vec_i8 i8s; + api_vec_i16 i16s; + api_vec_i32 i32s; + api_vec_i64 i64s; + api_vec_f32 f32s; + api_vec_f64 f64s; + api_vec_i32 some; +} api_Numbers; +typedef struct api_Measure { + double value; + api_Numbers numbers; +} api_Measure; +typedef struct api_Limits_bytes { + api_buf low; + api_buf high; +} api_Limits_bytes; +typedef struct api_Limits_duration { + api_duration low; + api_duration high; +} api_Limits_duration; +typedef struct api_Page { + uint32_t size; +} api_Page; +typedef struct api_Booth { + api_Mark *mark; +} api_Booth; +typedef struct api_Cancelled { + uint8_t step; +} api_Cancelled; +typedef struct api_StartSeekable { + uint64_t at; +} api_StartSeekable; +typedef struct api_DoubleArray { + uint32_t len; +} api_DoubleArray; +typedef struct api_NonZeros { + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint64_t u64; + size_t usize; + int8_t i8; + int16_t i16; + int32_t i32; + int64_t i64; + ptrdiff_t isize; +} api_NonZeros; +typedef struct api_a { + uint8_t b; +} api_a; +typedef struct api_Qualifiers { + double api; + double kotlin; +} api_Qualifiers; +typedef struct api_polar_Turn { + uint8_t part; +} api_polar_Turn; +typedef struct api_clash_TONE { + uint8_t db; +} api_clash_TONE; +typedef struct api_clash_Span { + uint32_t width; +} api_clash_Span; +typedef struct api_tls_policy_Lifetime { + uint32_t seconds; +} api_tls_policy_Lifetime; +typedef struct api_Core { + uint32_t id; +} api_Core; +typedef enum api_Array_tag { + API_ARRAY_U8X4 = 0, +} api_Array_tag; +typedef struct api_Array_U8x4 { + uint8_t _0; +} api_Array_U8x4; +typedef struct api_Array { + api_Array_tag tag; + union { + api_Array_U8x4 u8x4; + }; +} api_Array; +typedef enum api_Platform_tag { + API_PLATFORM_WASM = 0, + API_PLATFORM_NATIVE = 1, +} api_Platform_tag; +typedef struct api_Platform_Wasm { + uint32_t bits; +} api_Platform_Wasm; +typedef struct api_Platform_Native { + uint32_t _0; +} api_Platform_Native; +typedef struct api_Platform { + api_Platform_tag tag; + union { + api_Platform_Wasm wasm; + api_Platform_Native native; + }; +} api_Platform; +typedef enum api_Placement_tag { + API_PLACEMENT_ANYWHERE = 0, + API_PLACEMENT_PINNED = 1, +} api_Placement_tag; +typedef struct api_Placement_Pinned { + api_Core _0; +} api_Placement_Pinned; +typedef struct api_Placement { + api_Placement_tag tag; + union { + api_Placement_Pinned pinned; + }; +} api_Placement; +typedef enum api_Event_tag { + API_EVENT_MOVED = 0, + API_EVENT_NAMED = 1, + API_EVENT_DONE = 2, +} api_Event_tag; +typedef struct api_Event_Moved { + api_Point _0; +} api_Event_Moved; +typedef struct api_Event_Named { + api_buf name; +} api_Event_Named; +typedef struct api_Event { + api_Event_tag tag; + union { + api_Event_Moved moved; + api_Event_Named named; + }; +} api_Event; +typedef enum api_Clash_tag { + API_CLASH_POINT = 0, + API_CLASH_SHAPE = 1, + API_CLASH_EVENT = 2, + API_CLASH_DOUBLE = 3, + API_CLASH_FLOAT = 4, + API_CLASH_STRING = 5, + API_CLASH_INT = 6, + API_CLASH_BOOLEAN = 7, + API_CLASH_NATIVE = 8, + API_CLASH_BYTES = 9, + API_CLASH_ANY = 10, + API_CLASH_UNIT = 11, + API_CLASH_WAKER = 12, + API_CLASH_MUT = 13, + API_CLASH_PAIR = 14, + API_CLASH_STAMP = 15, + API_CLASH_MOMENT = 16, +} api_Clash_tag; +typedef struct api_Clash_Point { + api_Point _0; +} api_Clash_Point; +typedef struct api_Clash_Shape { + api_Shape _0; +} api_Clash_Shape; +typedef struct api_Clash_Event { + api_Event _0; +} api_Clash_Event; +typedef struct api_Clash_Double { + double _0; +} api_Clash_Double; +typedef struct api_Clash_Float { + float _0; +} api_Clash_Float; +typedef struct api_Clash_String { + api_buf _0; +} api_Clash_String; +typedef struct api_Clash_Int { + int32_t _0; +} api_Clash_Int; +typedef struct api_Clash_Boolean { + bool _0; +} api_Clash_Boolean; +typedef struct api_Clash_Native { + uint32_t _0; +} api_Clash_Native; +typedef struct api_Clash_Bytes { + api_buf _0; +} api_Clash_Bytes; +typedef struct api_Clash_Pair { + uint8_t _0; + uint8_t _1; +} api_Clash_Pair; +typedef struct api_Clash_Stamp { + int64_t _0; +} api_Clash_Stamp; +typedef struct api_Clash_Moment { + api_Moment _0; +} api_Clash_Moment; +typedef struct api_Clash { + api_Clash_tag tag; + union { + api_Clash_Point point; + api_Clash_Shape shape; + api_Clash_Event event; + api_Clash_Double double_; + api_Clash_Float float_; + api_Clash_String string; + api_Clash_Int int_; + api_Clash_Boolean boolean; + api_Clash_Native native; + api_Clash_Bytes bytes; + api_Clash_Pair pair; + api_Clash_Stamp stamp; + api_Clash_Moment moment; + }; +} api_Clash; +typedef enum api_Stage_tag { + API_STAGE_INIT = 0, + API_STAGE_DONE = 1, +} api_Stage_tag; +typedef struct api_Stage_Init { + uint32_t _0; +} api_Stage_Init; +typedef struct api_Stage { + api_Stage_tag tag; + union { + api_Stage_Init init; + }; +} api_Stage; +typedef enum api_Error_tag { + API_ERROR_UNDERFLOW = 0, + API_ERROR_OVERFLOW = 1, +} api_Error_tag; +typedef struct api_Error_Underflow { + uint64_t by; +} api_Error_Underflow; +typedef struct api_Error { + api_Error_tag tag; + union { + api_Error_Underflow underflow; + }; +} api_Error; +typedef enum api_Labelled_tag { + API_LABELLED_TAGGED = 0, + API_LABELLED_BARE = 1, +} api_Labelled_tag; +typedef struct api_Labelled_Tagged { + uint32_t tag; +} api_Labelled_Tagged; +typedef struct api_Labelled { + api_Labelled_tag tag; + union { + api_Labelled_Tagged tagged; + }; +} api_Labelled; +typedef enum api_b_tag { + API_B_ONE = 0, + API_B_TWO = 1, +} api_b_tag; +typedef struct api_b_Two { + uint8_t _0; +} api_b_Two; +typedef struct api_b { + api_b_tag tag; + union { + api_b_Two two; + }; +} api_b; +typedef enum api_Builtin_tag { + API_BUILTIN_ANY = 0, + API_BUILTIN_BOOLEAN = 1, + API_BUILTIN_INT = 2, + API_BUILTIN_NATIVE = 3, +} api_Builtin_tag; +typedef struct api_Builtin_Any { + api_vec_i32 _0; +} api_Builtin_Any; +typedef struct api_Builtin_Boolean { + double _0; +} api_Builtin_Boolean; +typedef struct api_Builtin_Int { + double _0; +} api_Builtin_Int; +typedef struct api_Builtin_Native { + double _0; +} api_Builtin_Native; +typedef struct api_Builtin { + api_Builtin_tag tag; + union { + api_Builtin_Any any; + api_Builtin_Boolean boolean; + api_Builtin_Int int_; + api_Builtin_Native native; + }; +} api_Builtin; +typedef struct api_Log_vtable { + void (*free)(void *data); + bool (*log)(void *data, uint8_t level, api_buf line); +} api_Log_vtable; +typedef struct api_Log { + const api_Log_vtable *vtable; + void *data; +} api_Log; +typedef struct api_Beat_vtable { + void (*free)(void *data); + uint32_t (*beat)(void *data); +} api_Beat_vtable; +typedef struct api_Beat { + const api_Beat_vtable *vtable; + void *data; +} api_Beat; +#define API_LIMIT ((uint64_t)1000ULL) +#define API_FAR ((int64_t)9223372036854775807LL) +void api_Parcel_free(api_Parcel *self); +void api_Weighted_free(api_Weighted *self); +uint64_t api_Weighted_total(const api_Weighted *self); +void api_Stamped_free(api_Stamped *self); +uint64_t api_Stamped_total(const api_Stamped *self); +void api_CancellationError_free(api_CancellationError *self); +void api_Packet_free(api_Packet *self); +void api_Hasher_free(api_Hasher *self); +void api_Size_free(api_Size *self); +bool api_Size_eq(const api_Size *a, const api_Size *b); +api_buf api_Size_debug(const api_Size *self); +void api_Point_free(api_Point *self); +bool api_Point_eq(const api_Point *a, const api_Point *b); +api_buf api_Point_debug(const api_Point *self); +api_Point api_Point_default(void); +api_Point api_Point_offset(const api_Point *self, int32_t dx, int32_t dy); +void api_Label_free(api_Label *self); +bool api_Label_eq(const api_Label *a, const api_Label *b); +api_buf api_Label_debug(const api_Label *self); +void api_Note_free(api_Note *self); +bool api_Note_eq(const api_Note *a, const api_Note *b); +api_buf api_Note_debug(const api_Note *self); +api_Note api_Note_default(void); +void api_Reading_free(api_Reading *self); +bool api_Reading_eq(const api_Reading *a, const api_Reading *b); +api_buf api_Reading_debug(const api_Reading *self); +api_option_Reading api_Reading_next(const api_Reading *self); +void api_Packaged_free(api_Packaged *self); +bool api_Packaged_eq(const api_Packaged *a, const api_Packaged *b); +api_buf api_Packaged_debug(const api_Packaged *self); +api_Point api_Packaged_point(const api_Packaged *self); +api_Shape api_Packaged_shape(const api_Packaged *self); +void api_Atlas_free(api_Atlas *self); +bool api_Atlas_eq(const api_Atlas *a, const api_Atlas *b); +api_buf api_Atlas_debug(const api_Atlas *self); +api_Atlas api_Atlas_with(const api_Atlas *self, api_buf name, api_Point at); +void api_Span_free(api_Span *self); +bool api_Span_eq(const api_Span *a, const api_Span *b); +api_buf api_Span_debug(const api_Span *self); +void api_Window_free(api_Window *self); +bool api_Window_eq(const api_Window *a, const api_Window *b); +api_buf api_Window_debug(const api_Window *self); +bool api_Window_contains(const api_Window *self, uint64_t n); +bool api_Ticket_eq(const api_Ticket *a, const api_Ticket *b); +api_buf api_Ticket_debug(const api_Ticket *self); +api_Ticket api_Ticket_new(uint32_t number); +uint32_t api_Ticket_number(const api_Ticket *self); +uint32_t api_Ticket_clones(void); +void api_Seat_free(api_Seat *self); +bool api_Seat_eq(const api_Seat *a, const api_Seat *b, api_status *status); +api_buf api_Seat_debug(const api_Seat *self, api_status *status); +uint64_t api_Seat_count(const api_Seat *self, api_status *status); +bool api_Stamp_eq(const api_Stamp *a, const api_Stamp *b); +api_buf api_Stamp_debug(const api_Stamp *self); +api_Stamp api_Stamp_from_millis(uint64_t millis); +uint64_t api_Stamp_secs(const api_Stamp *self); +api_Stamp api_Stamp_whole(const api_Stamp *self); +bool api_Stamp_later(const api_Stamp *self, api_Stamp other); +bool api_Moment_eq(const api_Moment *a, const api_Moment *b); +api_buf api_Moment_debug(const api_Moment *self); +api_option_Moment api_Moment_new(uint64_t ticks, uint64_t rate); +uint64_t api_Moment_millis(const api_Moment *self); +api_Moment api_Moment_after(const api_Moment *self, uint64_t ticks); +bool api_LongArray_eq(const api_LongArray *a, const api_LongArray *b); +api_buf api_LongArray_debug(const api_LongArray *self); +api_LongArray api_LongArray_new(uint64_t low, uint64_t high); +uint64_t api_LongArray_c_(const api_LongArray *self); +void api_LongArray_also(const api_LongArray *self, void (*f)(void *data, uint64_t), void *f_data); +void api_JvmField_free(api_JvmField *self); +bool api_JvmField_eq(const api_JvmField *a, const api_JvmField *b); +api_buf api_JvmField_debug(const api_JvmField *self); +void api_JvmStatic_free(api_JvmStatic *self); +bool api_JvmStatic_eq(const api_JvmStatic *a, const api_JvmStatic *b); +api_buf api_JvmStatic_debug(const api_JvmStatic *self); +void api_OptIn_free(api_OptIn *self); +bool api_OptIn_eq(const api_OptIn *a, const api_OptIn *b); +api_buf api_OptIn_debug(const api_OptIn *self); +bool api_Wide_eq(const api_Wide *a, const api_Wide *b); +api_buf api_Wide_debug(const api_Wide *self); +api_Wide api_Wide_new(uint64_t seed); +uint64_t api_Wide_sum(const api_Wide *self); +void api_Clocked_free(api_Clocked *self); +bool api_Clocked_eq(const api_Clocked *a, const api_Clocked *b); +api_buf api_Clocked_debug(const api_Clocked *self); +api_buf api_Score_debug(const api_Score *self); +api_Score api_Score_of(uint64_t count); +uint64_t api_Score_count(const api_Score *self); +void api_Score_add(api_Score *self, api_Score other); +api_Score api_Score_doubled(const api_Score *self); +uint64_t api_Score_take(api_Score *self); +uint64_t api_Score_note(api_Score *self, const api_Mark *mark, api_status *status); +void api_Score_absorb(api_Score *self, api_Score other, api_Score *other_out, uint64_t *out0, uint64_t *out1); +bool api_Hits_eq(const api_Hits *a, const api_Hits *b); +api_buf api_Hits_debug(const api_Hits *self); +api_Hits api_Hits_default(void); +uint64_t api_Hits_hits_get(const api_Hits *self); +void api_Hits_hits_set(api_Hits *self, uint64_t value); +uint64_t api_Hits_misses_get(const api_Hits *self); +void api_Hits_misses_set(api_Hits *self, uint64_t value); +api_Hits api_Hits_of(uint64_t hits, uint64_t misses); +void api_Hits_add(api_Hits *self, api_Hits other); +bool api_Hits_eq_(api_Hits *self, api_Hits other); +bool api_Extent_eq(const api_Extent *a, const api_Extent *b); +api_buf api_Extent_debug(const api_Extent *self); +uint64_t api_Extent_start_get(const api_Extent *self); +void api_Extent_start_set(api_Extent *self, uint64_t value); +api_Extent api_Extent_new(uint64_t start, uint64_t len); +uint64_t api_Extent_end(const api_Extent *self); +uint64_t api_Extent_slide(api_Extent *self, uint64_t by); +void api_Pair_Size_u8_free(api_Pair_Size_u8 *self); +bool api_Pair_Size_u8_eq(const api_Pair_Size_u8 *a, const api_Pair_Size_u8 *b); +api_buf api_Pair_Size_u8_debug(const api_Pair_Size_u8 *self); +api_Pair_u8_Size api_Pair_Size_u8_swap(const api_Pair_Size_u8 *self); +void api_Pair_non_zero_u16_free(api_Pair_non_zero_u16 *self); +bool api_Pair_non_zero_u16_eq(const api_Pair_non_zero_u16 *a, const api_Pair_non_zero_u16 *b); +api_buf api_Pair_non_zero_u16_debug(const api_Pair_non_zero_u16 *self); +api_Pair_non_zero_u16 api_Pair_non_zero_u16_swap(const api_Pair_non_zero_u16 *self); +bool api_Pair_non_zero_u16_even(const api_Pair_non_zero_u16 *self); +void api_Pair_u32_free(api_Pair_u32 *self); +bool api_Pair_u32_eq(const api_Pair_u32 *a, const api_Pair_u32 *b); +api_buf api_Pair_u32_debug(const api_Pair_u32 *self); +api_Pair_u32 api_Pair_u32_swap(const api_Pair_u32 *self); +bool api_Pair_u32_even(const api_Pair_u32 *self); +uint32_t api_Pair_u32_sum(const api_Pair_u32 *self); +api_Pair_u8_Size api_Pair_u32_beside_Size(const api_Pair_u32 *self, api_Size right); +void api_Pair_u8_Size_free(api_Pair_u8_Size *self); +bool api_Pair_u8_Size_eq(const api_Pair_u8_Size *a, const api_Pair_u8_Size *b); +api_buf api_Pair_u8_Size_debug(const api_Pair_u8_Size *self); +void api_Left_Right_u8_free(api_Left_Right_u8 *self); +bool api_Left_Right_u8_eq(const api_Left_Right_u8 *a, const api_Left_Right_u8 *b); +api_buf api_Left_Right_u8_debug(const api_Left_Right_u8 *self); +void api_Left_u8_free(api_Left_u8 *self); +bool api_Left_u8_eq(const api_Left_u8 *a, const api_Left_u8 *b); +api_buf api_Left_u8_debug(const api_Left_u8 *self); +void api_Right_Left_u8_free(api_Right_Left_u8 *self); +bool api_Right_Left_u8_eq(const api_Right_Left_u8 *a, const api_Right_Left_u8 *b); +api_buf api_Right_Left_u8_debug(const api_Right_Left_u8 *self); +void api_Right_u8_free(api_Right_u8 *self); +bool api_Right_u8_eq(const api_Right_u8 *a, const api_Right_u8 *b); +api_buf api_Right_u8_debug(const api_Right_u8 *self); +void api_Inner_u8_free(api_Inner_u8 *self); +bool api_Inner_u8_eq(const api_Inner_u8 *a, const api_Inner_u8 *b); +api_buf api_Inner_u8_debug(const api_Inner_u8 *self); +void api_Boxed_u16_free(api_Boxed_u16 *self); +bool api_Boxed_u16_eq(const api_Boxed_u16 *a, const api_Boxed_u16 *b); +api_buf api_Boxed_u16_debug(const api_Boxed_u16 *self); +void api_Boxed_u8_free(api_Boxed_u8 *self); +bool api_Boxed_u8_eq(const api_Boxed_u8 *a, const api_Boxed_u8 *b); +api_buf api_Boxed_u8_debug(const api_Boxed_u8 *self); +void api_LogCount_free(api_LogCount *self); +bool api_LogCount_eq(const api_LogCount *a, const api_LogCount *b); +api_buf api_LogCount_debug(const api_LogCount *self); +void api_Wrap_u32_free(api_Wrap_u32 *self); +bool api_Wrap_u32_eq(const api_Wrap_u32 *a, const api_Wrap_u32 *b); +api_buf api_Wrap_u32_debug(const api_Wrap_u32 *self); +void api_PolarTurn_free(api_PolarTurn *self); +bool api_PolarTurn_eq(const api_PolarTurn *a, const api_PolarTurn *b); +api_buf api_PolarTurn_debug(const api_PolarTurn *self); +void api_Peer_free(api_Peer *self); +bool api_Peer_eq(const api_Peer *a, const api_Peer *b); +api_buf api_Peer_debug(const api_Peer *self); +api_vec_string api_Peer_aliases(const api_Peer *self); +api_Peer api_Peer_next(const api_Peer *self, api_buf name); +void api_Shadowed_free(api_Shadowed *self); +bool api_Shadowed_eq(const api_Shadowed *a, const api_Shadowed *b); +api_buf api_Shadowed_debug(const api_Shadowed *self); +void api_Numbers_free(api_Numbers *self); +bool api_Numbers_eq(const api_Numbers *a, const api_Numbers *b); +api_buf api_Numbers_debug(const api_Numbers *self); +api_Numbers api_Numbers_edges(void); +api_Numbers api_Numbers_zero(bool negative); +api_Numbers api_Numbers_reversed(const api_Numbers *self); +void api_Measure_free(api_Measure *self); +bool api_Measure_eq(const api_Measure *a, const api_Measure *b); +api_buf api_Measure_debug(const api_Measure *self); +api_Measure api_Measure_new(double value, bool negative); +void api_Limits_bytes_free(api_Limits_bytes *self); +bool api_Limits_bytes_eq(const api_Limits_bytes *a, const api_Limits_bytes *b); +api_buf api_Limits_bytes_debug(const api_Limits_bytes *self); +void api_Limits_duration_free(api_Limits_duration *self); +bool api_Limits_duration_eq(const api_Limits_duration *a, const api_Limits_duration *b); +api_buf api_Limits_duration_debug(const api_Limits_duration *self); +void api_Page_free(api_Page *self); +bool api_Page_eq(const api_Page *a, const api_Page *b); +api_buf api_Page_debug(const api_Page *self); +api_Page api_Page_default(void); +void api_Booth_free(api_Booth *self); +bool api_Booth_eq(const api_Booth *a, const api_Booth *b, api_status *status); +api_buf api_Booth_debug(const api_Booth *self, api_status *status); +void api_Cancelled_free(api_Cancelled *self); +bool api_Cancelled_eq(const api_Cancelled *a, const api_Cancelled *b); +api_buf api_Cancelled_debug(const api_Cancelled *self); +void api_StartSeekable_free(api_StartSeekable *self); +bool api_StartSeekable_eq(const api_StartSeekable *a, const api_StartSeekable *b); +api_buf api_StartSeekable_debug(const api_StartSeekable *self); +void api_DoubleArray_free(api_DoubleArray *self); +bool api_DoubleArray_eq(const api_DoubleArray *a, const api_DoubleArray *b); +api_buf api_DoubleArray_debug(const api_DoubleArray *self); +void api_NonZeros_free(api_NonZeros *self); +api_buf api_NonZeros_debug(const api_NonZeros *self); +void api_a_free(api_a *self); +bool api_a_eq(const api_a *a, const api_a *b); +api_buf api_a_debug(const api_a *self); +void api_Qualifiers_free(api_Qualifiers *self); +bool api_Qualifiers_eq(const api_Qualifiers *a, const api_Qualifiers *b); +void api_polar_Point_free(api_polar_Point *self); +bool api_polar_Point_eq(const api_polar_Point *a, const api_polar_Point *b); +api_buf api_polar_Point_debug(const api_polar_Point *self); +void api_polar_Turn_free(api_polar_Turn *self); +bool api_polar_Turn_eq(const api_polar_Turn *a, const api_polar_Turn *b); +api_buf api_polar_Turn_debug(const api_polar_Turn *self); +void api_clash_Tone_free(api_clash_Tone *self); +bool api_clash_Tone_eq(const api_clash_Tone *a, const api_clash_Tone *b); +api_buf api_clash_Tone_debug(const api_clash_Tone *self); +void api_clash_TONE_free(api_clash_TONE *self); +bool api_clash_TONE_eq(const api_clash_TONE *a, const api_clash_TONE *b); +api_buf api_clash_TONE_debug(const api_clash_TONE *self); +void api_clash_Span_free(api_clash_Span *self); +bool api_clash_Span_eq(const api_clash_Span *a, const api_clash_Span *b); +api_buf api_clash_Span_to_string(const api_clash_Span *self); +api_buf api_clash_Span_debug(const api_clash_Span *self); +uint32_t api_clash_Span_width(const api_clash_Span *self); +api_buf api_clash_Span_to_string_(const api_clash_Span *self); +void api_tls_policy_Lifetime_free(api_tls_policy_Lifetime *self); +bool api_tls_policy_Lifetime_eq(const api_tls_policy_Lifetime *a, const api_tls_policy_Lifetime *b); +api_buf api_tls_policy_Lifetime_debug(const api_tls_policy_Lifetime *self); +void api_Core_free(api_Core *self); +void api_Choice_free(api_Choice *self); +void api_Array_free(api_Array *self); +void api_Platform_free(api_Platform *self); +void api_Placement_free(api_Placement *self); +bool api_Shape_eq(const api_Shape *a, const api_Shape *b); +api_buf api_Shape_debug(const api_Shape *self); +api_vec_Shape api_Shape_ALL(void); +api_vec_Shape api_Shape_BOTH(void); +void api_Event_free(api_Event *self); +bool api_Event_eq(const api_Event *a, const api_Event *b); +api_buf api_Event_debug(const api_Event *self); +void api_Clash_free(api_Clash *self); +bool api_Clash_eq(const api_Clash *a, const api_Clash *b); +api_buf api_Clash_debug(const api_Clash *self); +api_option_Point api_Clash_point(const api_Clash *self); +api_Clash api_Clash_of(double value); +api_buf api_Clash_bytes(const api_Clash *self); +api_Reading api_Clash_reading(const api_Clash *self, uint32_t kotlin); +api_vec_vec_u32 api_Clash_listed(api_vec_u32 java, uint32_t kotlin, uint32_t *kotlin_out); +typedef struct api_Clash_after_future api_Clash_after_future; +api_Clash_after_future *api_Clash_after(api_foreign_future first, double kotlin); +api_poll api_Clash_after_start(api_foreign_future first, double kotlin, api_Clash *out, api_Clash_after_future **future); +api_poll api_Clash_after_poll(api_Clash_after_future *future, api_waker waker, api_Clash *out); +void api_Clash_after_future_free(api_Clash_after_future *future); +api_buf api_Clash_joined(const api_Clash *self, api_buf lent, api_buf owned, api_buf maybe); +typedef struct api_Clash_tagged_future api_Clash_tagged_future; +api_Clash_tagged_future *api_Clash_tagged(const api_Clash *self, api_buf tag); +api_poll api_Clash_tagged_start(const api_Clash *self, api_buf tag, api_buf *out, api_Clash_tagged_future **future); +api_poll api_Clash_tagged_poll(api_Clash_tagged_future *future, api_waker waker, api_buf *out); +void api_Clash_tagged_future_free(api_Clash_tagged_future *future); +api_Stamp api_Clash_stamp(const api_Clash *self, uint64_t kotlin); +api_Moment api_Clash_moment(const api_Clash *self, uint64_t kotlin); +api_Clash api_Clash_at(api_Point api); +api_buf api_Clash_describe(const api_Clash *self, api_buf text, uint32_t n, api_Shape shape, uint32_t out_, uint32_t *out__out); +void api_Stage_free(api_Stage *self); +bool api_Stage_eq(const api_Stage *a, const api_Stage *b); +api_buf api_Stage_debug(const api_Stage *self); +void api_Error_free(api_Error *self); +bool api_Error_eq(const api_Error *a, const api_Error *b); +api_buf api_Error_to_string(const api_Error *self); +api_buf api_Error_debug(const api_Error *self); +bool api_Status__eq(const api_Status_ *a, const api_Status_ *b); +api_buf api_Status__debug(const api_Status_ *self); +void api_Labelled_free(api_Labelled *self); +bool api_Labelled_eq(const api_Labelled *a, const api_Labelled *b); +api_buf api_Labelled_debug(const api_Labelled *self); +bool api_Family_eq(const api_Family *a, const api_Family *b); +api_buf api_Family_debug(const api_Family *self); +bool api_VecClashTone_eq(const api_VecClashTone *a, const api_VecClashTone *b); +api_buf api_VecClashTone_debug(const api_VecClashTone *self); +void api_b_free(api_b *self); +bool api_b_eq(const api_b *a, const api_b *b); +api_buf api_b_debug(const api_b *self); +void api_Builtin_free(api_Builtin *self); +bool api_Builtin_eq(const api_Builtin *a, const api_Builtin *b); +bool api_Level_eq(const api_Level *a, const api_Level *b); +uint64_t api_Level_hash(const api_Level *self); +api_buf api_Level_to_string(const api_Level *self); +void api_Board_free(api_Board *self); +void api_Board_drop(api_Board *self, api_status *status); +api_Board *api_Board_new(api_vec_tuple_string_Counter counters, api_status *status); +api_vec_tuple_string_Counter api_Board_into_counters(api_Board *self, api_status *status); +api_vec_tuple_string_Counter api_Board_ranked(const api_Board *self, api_status *status); +api_Counter *api_Board_best(const api_Board *self, api_status *status); +void api_Receipt_free(api_Receipt *self); +void api_Receipt_drop(api_Receipt *self, api_status *status); +api_Receipt *api_Receipt_clone(const api_Receipt *self, api_status *status); +uint32_t api_Receipt_count(const api_Receipt *self, api_status *status); +void api_Draft_free(api_Draft *self); +void api_Draft_drop(api_Draft *self, api_status *status); +bool api_Draft_edited(const api_Draft *self, api_status *status); +api_buf api_Draft_describe(const api_Draft *self, api_status *status); +uint32_t api_Draft_commit(api_Draft *self, api_status *status); +api_buf api_Draft_title_get(const api_Draft *self, api_status *status); +void api_Draft_title_set(api_Draft *self, api_buf value, api_status *status); +uint32_t api_Draft_lines(const api_Draft *self, api_status *status); +void api_Draft_write(api_Draft *self, api_buf line, api_status *status); +void api_Filed_Receipt_free(api_Filed_Receipt *self); +void api_Filed_Receipt_drop(api_Filed_Receipt *self, api_status *status); +api_Filed_Receipt *api_Filed_Receipt_clone(const api_Filed_Receipt *self, api_status *status); +uint32_t api_Filed_Receipt_count(const api_Filed_Receipt *self, api_status *status); +void api_Pad_u16_free(api_Pad_u16 *self); +api_Pad_u16 *api_Pad_u16_wide(void); +uint16_t api_Pad_u16_tag(const api_Pad_u16 *self); +uint16_t api_Pad_u16_title(const api_Pad_u16 *self); +api_buf api_Pad_u16_describe(const api_Pad_u16 *self); +void api_Pad_u8_free(api_Pad_u8 *self); +api_Pad_u8 *api_Pad_u8_small(void); +api_buf api_Pad_u8_describe(const api_Pad_u8 *self); +api_buf api_Pad_u8_title_get(const api_Pad_u8 *self); +uint32_t api_Pad_u8_lines(const api_Pad_u8 *self); +void api_Layered_free(api_Layered *self); +api_Layered *api_Layered_new(void); +api_buf api_Layered_title_get(const api_Layered *self); +uint32_t api_Layered_lines(const api_Layered *self); +void api_Marker_free(api_Marker *self); +void api_Marker_drop(api_Marker *self, api_status *status); +api_Marker *api_Marker_new(api_buf label, int32_t x, int32_t y); +api_buf api_Marker_label(const api_Marker *self, api_status *status); +int32_t api_Marker_x_get(const api_Marker *self, api_status *status); +void api_Marker_x_set(api_Marker *self, int32_t value, api_status *status); +int32_t api_Marker_y_get(const api_Marker *self, api_status *status); +void api_Marker_y_set(api_Marker *self, int32_t value, api_status *status); +api_Point api_Marker_offset(const api_Marker *self, int32_t dx, int32_t dy, api_status *status); +void api_Batch_free(api_Batch *self); +void api_Batch_drop(api_Batch *self, api_status *status); +api_Batch *api_Batch_new(void); +bool api_Batch_push(api_Batch *self, uint32_t v, api_status *status); +size_t api_Batch_capacity(const api_Batch *self, api_status *status); +void api_Batch_2_free(api_Batch_2 *self); +void api_Batch_2_drop(api_Batch_2 *self, api_status *status); +api_Batch_2 *api_Batch_2_new(void); +bool api_Batch_2_push(api_Batch_2 *self, uint32_t v, api_status *status); +size_t api_Batch_2_capacity(const api_Batch_2 *self, api_status *status); +void api_Waiter_free(api_Waiter *self); +void api_Waiter_drop(api_Waiter *self, api_status *status); +api_Waiter *api_Waiter_new(api_waker waker_); +api_waker api_Waiter_waker(const api_Waiter *self, api_status *status); +api_waker api_Waiter_context(const api_Waiter *self, api_status *status); +typedef struct api_Waiter_poll_future_future api_Waiter_poll_future_future; +api_Waiter_poll_future_future *api_Waiter_poll_future(api_foreign_future future_); +api_poll api_Waiter_poll_future_start(api_foreign_future future_, api_Waiter_poll_future_future **future); +api_poll api_Waiter_poll_future_poll(api_Waiter_poll_future_future *future, api_waker waker); +void api_Waiter_poll_future_future_free(api_Waiter_poll_future_future *future); +void api_Logger_free(api_Logger *self); +api_Logger *api_Logger_new(api_Log sink); +bool api_Logger_write(const api_Logger *self, api_buf line); +bool api_Logger_write_from_thread(const api_Logger *self, api_buf line); +void api_Journal_free(api_Journal *self); +void api_Journal_drop(api_Journal *self, api_status *status); +api_Journal *api_Journal_new(api_Log sink); +void api_Journal_redirect(api_Journal *self, api_Log sink, api_status *status); +bool api_Journal_write(const api_Journal *self, api_buf line, api_status *status); +void api_Local_free(api_Local *self); +void api_Local_drop(api_Local *self, api_status *status); +bool api_Local_eq(const api_Local *a, const api_Local *b, api_status *status); +uint64_t api_Local_hash(const api_Local *self, api_status *status); +api_Local *api_Local_default(void); +api_Local *api_Local_default_homed(void); +api_Local *api_Local_new(void); +api_Local *api_Local_new_homed(void); +uint32_t api_Local_bump(const api_Local *self, api_status *status); +api_Local *api_Local_share(const api_Local *self, api_status *status); +typedef struct api_Local_later_future api_Local_later_future; +api_Local_later_future *api_Local_later(const api_Local *self, api_status *status); +api_poll api_Local_later_start(const api_Local *self, uint32_t *out, api_Local_later_future **future, api_status *status); +api_poll api_Local_later_poll(api_Local_later_future *future, api_waker waker, uint32_t *out, api_status *status); +void api_Local_later_future_free(api_Local_later_future *future); +uint32_t api_Local_visit(const api_Local *self, uint32_t (*f)(void *data), void *f_data, api_status *status); +typedef struct api_Local_poll_count_future api_Local_poll_count_future; +api_Local_poll_count_future *api_Local_poll_count(const api_Local *self, api_status *status); +api_poll api_Local_poll_count_start(const api_Local *self, uint32_t *out, api_Local_poll_count_future **future, api_status *status); +api_poll api_Local_poll_count_poll(api_Local_poll_count_future *future, api_waker waker, uint32_t *out, api_status *status); +void api_Local_poll_count_future_free(api_Local_poll_count_future *future); +uint64_t api_Local_thread_number(const api_Local *self, api_status *status); +bool api_Local_on_own_thread(const api_Local *self, api_status *status); +void api_LocalWaiter_free(api_LocalWaiter *self); +void api_LocalWaiter_drop(api_LocalWaiter *self, api_status *status); +api_LocalWaiter *api_LocalWaiter_new(api_waker waker_); +api_LocalWaiter *api_LocalWaiter_new_homed(api_waker waker_); +typedef struct api_LocalWaiter_poll_ready_future api_LocalWaiter_poll_ready_future; +api_LocalWaiter_poll_ready_future *api_LocalWaiter_poll_ready(uint32_t n); +api_poll api_LocalWaiter_poll_ready_start(uint32_t n, uint32_t *out, api_LocalWaiter_poll_ready_future **future); +api_poll api_LocalWaiter_poll_ready_poll(api_LocalWaiter_poll_ready_future *future, api_waker waker, uint32_t *out, api_status *status); +void api_LocalWaiter_poll_ready_future_free(api_LocalWaiter_poll_ready_future *future); +api_LocalWaiter_poll_ready_future *api_LocalWaiter_poll_ready_homed(uint32_t n); +api_poll api_LocalWaiter_poll_ready_start_homed(uint32_t n, uint32_t *out, api_LocalWaiter_poll_ready_future **future); +void api_Retry_free(api_Retry *self); +void api_Retry_drop(api_Retry *self, api_status *status); +api_option_u32 api_Retry_limit_get(const api_Retry *self, api_status *status); +void api_Retry_limit_set(api_Retry *self, api_option_u32 value, api_status *status); +api_Retry *api_Retry_new(api_option_u32 limit); +uint32_t api_Retry_limit(const api_Retry *self, api_status *status); +uint32_t api_Retry_delay(const api_Retry *self, api_status *status); +void api_Retry_set_limit(api_Retry *self, uint32_t limit, api_status *status); +void api_Digest_free(api_Digest *self); +void api_Digest_drop(api_Digest *self, api_status *status); +api_array_u8_4 api_Digest_sum_get(const api_Digest *self, api_status *status); +void api_Digest_sum_set(api_Digest *self, api_array_u8_4 value, api_status *status); +api_Digest *api_Digest_new(void); +api_array_u8_4 api_Digest_flipped(const api_Digest *self, api_array_u8_4 mask, api_status *status); +void api_Cursor_free(api_Cursor *self); +void api_Cursor_drop(api_Cursor *self, api_status *status); +uint64_t api_Cursor_at(const api_Cursor *self, api_status *status); +void api_Outer_Inner_u8_free(api_Outer_Inner_u8 *self); +api_Outer_Inner_u8 *api_Outer_Inner_u8_new(uint8_t value); +uint8_t api_Outer_Inner_u8_get(const api_Outer_Inner_u8 *self); +void api_Slot_u32_free(api_Slot_u32 *self); +api_Slot_u32 *api_Slot_u32_new(uint32_t value); +void api_Slot_u8_free(api_Slot_u8 *self); +api_Slot_u8 *api_Slot_u8_new(uint8_t value); +uint16_t api_Slot_u8_value(const api_Slot_u8 *self); +void api_Resolving_free(api_Resolving *self); +void api_Resolving_drop(api_Resolving *self, api_status *status); +api_tls_Resolver *api_Resolving_0_get(const api_Resolving *self, api_status *status); +void api_Resolving_0_set(api_Resolving *self, api_tls_Resolver *value, api_status *status); +api_Resolving *api_Resolving_new(api_buf name); +void api_Codecs_free(api_Codecs *self); +void api_Codecs_drop(api_Codecs *self, api_status *status); +api_Codecs *api_Codecs_default(void); +api_vec_tls_Codec api_Codecs_list_get(const api_Codecs *self, api_status *status); +void api_Codecs_list_set(api_Codecs *self, api_vec_tls_Codec value, api_status *status); +api_Codecs *api_Codecs_new(void); +uint32_t api_Codecs_ids(api_Codecs *self, api_status *status); +void api_Der_free(api_Der *self); +api_Der *api_Der_from_slice(api_buf bytes); +api_buf api_Der_bytes(const api_Der *self); +void api_Verbosity_free(api_Verbosity *self); +void api_Verbosity_drop(api_Verbosity *self, api_status *status); +api_Level api_Verbosity_level_get(const api_Verbosity *self, api_status *status); +void api_Verbosity_level_set(api_Verbosity *self, api_Level value, api_status *status); +api_Verbosity *api_Verbosity_new(api_Level level); +api_option_Level api_Verbosity_filter(const api_Verbosity *self, api_status *status); +void api_Site_free(api_Site *self); +void api_Site_drop(api_Site *self, api_status *status); +api_Url *api_Site_home_get(const api_Site *self, api_status *status); +void api_Site_home_set(api_Site *self, api_Url *value, api_status *status); +api_Site *api_Site_new(api_Url *home, api_status *status); +void api_Trail_free(api_Trail *self); +void api_Trail_drop(api_Trail *self, api_status *status); +api_Trail *api_Trail_new(api_vec_Point points, api_vec_string names); +api_vec_Point api_Trail_points(const api_Trail *self, api_status *status); +api_vec_Label api_Trail_labels(const api_Trail *self, api_status *status); +api_vec_Point api_Trail_iter(const api_Trail *self, api_status *status); +api_vec_string api_Trail_names(const api_Trail *self, api_status *status); +api_vec_Point api_Trail_beyond(const api_Trail *self, int32_t x, api_status *status); +api_buf api_Trail_bytes(const api_Trail *self, api_status *status); +api_vec_Label api_Trail_drain(api_Trail *self, api_status *status); +void api_Worker_free(api_Worker *self); +api_Worker *api_Worker_new(uint32_t id); +uint32_t api_Worker_id(const api_Worker *self); +void api_Handle_free(api_Handle *self); +api_Handle *api_Handle_new(uint32_t count); +uint32_t api_Handle_count(const api_Handle *self); +typedef struct api_Handle_later_future api_Handle_later_future; +api_Handle_later_future *api_Handle_later(uint32_t count); +api_poll api_Handle_later_start(uint32_t count, api_Handle **out, api_Handle_later_future **future); +api_poll api_Handle_later_poll(api_Handle_later_future *future, api_waker waker, api_Handle **out); +void api_Handle_later_future_free(api_Handle_later_future *future); +void api_Area_free(api_Area *self); +bool api_Area_borrowed(const api_Area *self); +api_Area *api_Area_clone(const api_Area *self); +api_buf api_Area_debug(const api_Area *self); +api_Area *api_Area_new(api_Size size); +api_Size api_Area_size(const api_Area *self); +uint64_t api_Area_pixels(const api_Area *self); +uint64_t api_Area_scaled_Point(const api_Area *self, api_Point by); +void api_Counter_free(api_Counter *self); +void api_Counter_drop(api_Counter *self, api_status *status); +api_Counter *api_Counter_clone(const api_Counter *self, api_status *status); +api_buf api_Counter_debug(const api_Counter *self, api_status *status); +api_Counter *api_Counter_default(void); +api_Counter *api_Counter_new(api_buf name, uint64_t start); +uint64_t api_Counter_get(const api_Counter *self, api_status *status); +uint64_t api_Counter_offset(const api_Counter *self, uint64_t handle, uint64_t h, api_status *status); +uint64_t api_Counter_into_sum(api_Counter *self, uint64_t close, api_status *status); +api_buf api_Counter_name(const api_Counter *self, api_status *status); +bool api_Counter_add(api_Counter *self, uint64_t n, uint64_t *out, api_Error *err, api_status *status); +bool api_Counter_sub(api_Counter *self, uint64_t n, uint64_t *out, api_Error *err, api_status *status); +bool api_Counter_edited(const api_Counter *self, api_status *status); +uint64_t api_Counter_plus(const api_Counter *self, const api_Counter *other, api_status *status); +uint64_t api_Counter_clamped(const api_Counter *self, const api_Counter *low, const api_Counter *high, api_status *status); +typedef struct api_Counter_plus_later_future api_Counter_plus_later_future; +api_Counter_plus_later_future *api_Counter_plus_later(const api_Counter *self, const api_Counter *other, api_status *status); +api_poll api_Counter_plus_later_start(const api_Counter *self, const api_Counter *other, uint64_t *out, api_Counter_plus_later_future **future, api_status *status); +api_poll api_Counter_plus_later_poll(api_Counter_plus_later_future *future, api_waker waker, uint64_t *out); +void api_Counter_plus_later_future_free(api_Counter_plus_later_future *future); +bool api_Counter_add_to(const api_Counter *self, api_Counter *other, api_status *status); +api_Label api_Counter_into_label(api_Counter *self, api_option_Point at, api_status *status); +void api_Counter_rename(api_Counter *self, api_buf name, api_status *status); +void api_Counter_split(api_Counter *self, uint64_t at, api_Counter **out0, api_Counter **out1, api_status *status); +bool api_Counter_is(const api_Counter *self, api_buf name, api_status *status); +api_Counter *api_Counter_seeded_Point(api_buf name, api_Point from); +api_Counter *api_Counter_seeded_Counter(api_buf name, const api_Counter *from, api_status *status); +api_Counter *api_Counter_seeded_Size(api_buf name, api_Size from); +api_Counter *api_Counter_seeded_Wrap_u32(api_buf name, api_Wrap_u32 from); +api_Counter *api_Counter_seeded_polar_Point(api_buf name, api_polar_Point from); +void api_Meter_free(api_Meter *self); +void api_Meter_drop(api_Meter *self, api_status *status); +api_Meter *api_Meter_default(void); +uint64_t api_Meter_add(const api_Meter *self, uint64_t n, api_status *status); +uint64_t api_Meter_count(const api_Meter *self, api_status *status); +void api_Meter_reset(api_Meter *self, api_status *status); +void api_Meters_free(api_Meters *self); +void api_Meters_drop(api_Meters *self, api_status *status); +api_Meters *api_Meters_default(void); +api_Meter *api_Meters_last_get(const api_Meters *self, api_status *status); +void api_Meters_last_set(api_Meters *self, api_Meter *value, api_status *status); +api_Meter *api_Meters_spare_get(const api_Meters *self, api_status *status); +void api_Meters_spare_set(api_Meters *self, api_Meter *value, api_status *status); +api_Meters *api_Meters_new(void); +api_Meter *api_Meters_first(const api_Meters *self, api_status *status); +void api_Meters_clear(api_Meters *self, api_status *status); +void api_Registry_free(api_Registry *self); +void api_Registry_drop(api_Registry *self, api_status *status); +api_Registry *api_Registry_default(void); +api_Counter *api_Registry_first_get(const api_Registry *self, api_status *status); +void api_Registry_first_set(api_Registry *self, api_Counter *value, api_status *status); +api_Registry *api_Registry_new(api_Counter *first, api_status *status); +api_Counter *api_Registry_last(const api_Registry *self, api_status *status); +void api_Registry_push(api_Registry *self, api_Counter *counter, api_status *status); +bool api_Registry_edit(api_Registry *self, bool (*edit)(void *data, api_Counter *), void *edit_data, api_status *status); +void api_Ledger_free(api_Ledger *self); +void api_Ledger_drop(api_Ledger *self, api_status *status); +api_Ledger *api_Ledger_default(void); +api_Ledger *api_Ledger_new(void); +bool api_Ledger_edit(api_Ledger *self, api_Draft **out, api_Error *err, api_status *status); +bool api_Ledger_edit_homed(api_Ledger *self, api_Draft **out, api_Error *err, api_status *status); +uint32_t api_Ledger_published(const api_Ledger *self, api_status *status); +api_buf api_Ledger_title(const api_Ledger *self, api_status *status); +void api_Ledger_seal(api_Ledger *self, api_status *status); +api_Receipt *api_Ledger_receipt(api_Ledger *self, api_status *status); +api_Receipt *api_Ledger_noted(api_Ledger *self, api_status *status); +api_Filed_Receipt *api_Ledger_file_Receipt(api_Ledger *self, api_Receipt *item, api_status *status); +api_Slip *api_Ledger_slip(api_Ledger *self, api_status *status); +api_Slip *api_Ledger_slip_homed(api_Ledger *self, api_status *status); +void api_Slip_free(api_Slip *self); +void api_Slip_drop(api_Slip *self, api_status *status); +api_Slip *api_Slip_clone(const api_Slip *self, api_status *status); +api_Receipt *api_Slip_receipt_get(const api_Slip *self, api_status *status); +void api_Slip_receipt_set(api_Slip *self, api_Receipt *value, api_status *status); +api_Receipt *api_Slip_global_get(const api_Slip *self, api_status *status); +void api_Slip_global_set(api_Slip *self, api_Receipt *value, api_status *status); +uint32_t api_Slip_count(const api_Slip *self, api_status *status); +void api_Sheet_free(api_Sheet *self); +void api_Sheet_drop(api_Sheet *self, api_status *status); +api_Sheet *api_Sheet_clone(const api_Sheet *self, api_status *status); +api_buf api_Sheet_debug(const api_Sheet *self, api_status *status); +api_Sheet *api_Sheet_default(void); +api_buf api_Sheet_title_get(const api_Sheet *self, api_status *status); +void api_Sheet_title_set(api_Sheet *self, api_buf value, api_status *status); +api_Sheet *api_Sheet_new(void); +uint32_t api_Sheet_lines(const api_Sheet *self, api_status *status); +void api_Sheet_write(api_Sheet *self, api_buf line, api_status *status); +api_buf api_Sheet_describe(const api_Sheet *self, api_status *status); +void api_Name_free(api_Name *self); +void api_Name_drop(api_Name *self, api_status *status); +api_Name *api_Name_clone(const api_Name *self, api_status *status); +bool api_Name_eq(const api_Name *a, const api_Name *b, api_status *status); +api_buf api_Name_debug(const api_Name *self, api_status *status); +api_Name *api_Name_owned(api_buf text); +api_buf api_Name_as_str(const api_Name *self, api_status *status); +api_Name *api_Name_join(const api_Name *self, const api_Name *other, api_status *status); +api_Name *api_Name_borrowed(api_buf text); +bool api_Name_shares(const api_Name *self, const api_Name *other, api_status *status); +void api_Name_rename(api_Name *self, api_buf text, api_status *status); +void api_Channel_free(api_Channel *self); +void api_Channel_drop(api_Channel *self, api_status *status); +api_Channel *api_Channel_clone(const api_Channel *self, api_status *status); +api_Channel *api_Channel_default(void); +api_Channel *api_Channel_new(void); +void api_Channel_clear(api_Channel *self, api_status *status); +void api_Channel_send(const api_Channel *self, api_buf payload, api_status *status); +typedef struct api_Channel_recv_future api_Channel_recv_future; +api_Channel_recv_future *api_Channel_recv(const api_Channel *self, api_status *status); +api_poll api_Channel_recv_start(const api_Channel *self, api_buf *out, api_Channel_recv_future **future, api_status *status); +api_poll api_Channel_recv_poll(api_Channel_recv_future *future, api_waker waker, api_buf *out); +void api_Channel_recv_future_free(api_Channel_recv_future *future); +void api_Channel_notify(const api_Channel *self, api_waker waker_, api_status *status); +typedef struct api_Channel_send_later_future api_Channel_send_later_future; +api_Channel_send_later_future *api_Channel_send_later(const api_Channel *self, api_buf payload, api_status *status); +api_poll api_Channel_send_later_start(const api_Channel *self, api_buf payload, api_Channel_send_later_future **future, api_status *status); +api_poll api_Channel_send_later_poll(api_Channel_send_later_future *future, api_waker waker); +void api_Channel_send_later_future_free(api_Channel_send_later_future *future); +typedef struct api_Channel_tagged_future api_Channel_tagged_future; +api_Channel_tagged_future *api_Channel_tagged(const api_Channel *self, api_buf tag, api_status *status); +api_poll api_Channel_tagged_start(const api_Channel *self, api_buf tag, api_buf *out, api_Channel_tagged_future **future, api_status *status); +api_poll api_Channel_tagged_poll(api_Channel_tagged_future *future, api_waker waker, api_buf *out); +void api_Channel_tagged_future_free(api_Channel_tagged_future *future); +typedef struct api_Channel_itemized_future api_Channel_itemized_future; +api_Channel_itemized_future *api_Channel_itemized(const api_Channel *self, api_vec_u32 items, api_status *status); +api_poll api_Channel_itemized_start(const api_Channel *self, api_vec_u32 items, size_t *out, api_Channel_itemized_future **future, api_status *status); +api_poll api_Channel_itemized_poll(api_Channel_itemized_future *future, api_waker waker, size_t *out); +void api_Channel_itemized_future_free(api_Channel_itemized_future *future); +typedef struct api_Channel_poll_take_future api_Channel_poll_take_future; +api_Channel_poll_take_future *api_Channel_poll_take(const api_Channel *self, api_status *status); +api_poll api_Channel_poll_take_start(const api_Channel *self, api_buf *out, api_Channel_poll_take_future **future, api_status *status); +api_poll api_Channel_poll_take_poll(api_Channel_poll_take_future *future, api_waker waker, api_buf *out); +void api_Channel_poll_take_future_free(api_Channel_poll_take_future *future); +typedef struct api_Channel_poll_measure_future api_Channel_poll_measure_future; +api_Channel_poll_measure_future *api_Channel_poll_measure(api_Channel *self, size_t extra, api_status *status); +api_poll api_Channel_poll_measure_start(api_Channel *self, size_t extra, size_t *out, api_Error *err, api_Channel_poll_measure_future **future, api_status *status); +api_poll api_Channel_poll_measure_poll(api_Channel_poll_measure_future *future, api_waker waker, size_t *out, api_Error *err); +void api_Channel_poll_measure_future_free(api_Channel_poll_measure_future *future); +void api_Channel_listen(const api_Channel *self, api_waker cx, api_status *status); +typedef struct api_Channel_recv_sized_future api_Channel_recv_sized_future; +api_Channel_recv_sized_future *api_Channel_recv_sized(const api_Channel *self, api_status *status); +api_poll api_Channel_recv_sized_start(const api_Channel *self, api_buf *out0, size_t *out1, api_Channel_recv_sized_future **future, api_status *status); +api_poll api_Channel_recv_sized_poll(api_Channel_recv_sized_future *future, api_waker waker, api_buf *out0, size_t *out1); +void api_Channel_recv_sized_future_free(api_Channel_recv_sized_future *future); +typedef struct api_Channel_recv_nonempty_future api_Channel_recv_nonempty_future; +api_Channel_recv_nonempty_future *api_Channel_recv_nonempty(const api_Channel *self, api_status *status); +api_poll api_Channel_recv_nonempty_start(const api_Channel *self, api_buf *out, api_Error *err, api_Channel_recv_nonempty_future **future, api_status *status); +api_poll api_Channel_recv_nonempty_poll(api_Channel_recv_nonempty_future *future, api_waker waker, api_buf *out, api_Error *err); +void api_Channel_recv_nonempty_future_free(api_Channel_recv_nonempty_future *future); +void api_Channel_send_from_thread(const api_Channel *self, api_buf payload, api_status *status); +void api_Gap_free(api_Gap *self); +bool api_Gap_borrowed(const api_Gap *self); +api_Gap *api_Gap_clone(const api_Gap *self); +bool api_Gap_eq(const api_Gap *a, const api_Gap *b); +api_buf api_Gap_debug(const api_Gap *self); +api_Gap *api_Gap_new(uint64_t wide, uint8_t narrow); +uint64_t api_Gap_sum(const api_Gap *self); +void api_Berth_free(api_Berth *self); +bool api_Berth_borrowed(const api_Berth *self); +api_Berth *api_Berth_clone(const api_Berth *self); +api_buf api_Berth_debug(const api_Berth *self); +api_Berth *api_Berth_new(api_option_u32 at); +api_option_u32 api_Berth_at(const api_Berth *self); +void api_Mark_free(api_Mark *self); +void api_Mark_drop(api_Mark *self, api_status *status); +api_Mark *api_Mark_clone(const api_Mark *self, api_status *status); +bool api_Mark_eq(const api_Mark *a, const api_Mark *b, api_status *status); +api_buf api_Mark_debug(const api_Mark *self, api_status *status); +api_Mark *api_Mark_of(uint64_t count); +uint64_t api_Mark_count(const api_Mark *self, api_status *status); +void api_Mark_add(api_Mark *self, uint64_t by, api_status *status); +void api_Message_free(api_Message *self); +void api_Message_drop(api_Message *self, api_status *status); +api_Message *api_Message_clone(const api_Message *self, api_status *status); +api_buf api_Message_debug(const api_Message *self, api_status *status); +api_option_Stamp api_Message_stamp_get(const api_Message *self, api_status *status); +void api_Message_stamp_set(api_Message *self, api_option_Stamp value, api_status *status); +api_buf api_Message_payload_get(const api_Message *self, api_status *status); +void api_Message_payload_set(api_Message *self, api_buf value, api_status *status); +api_Message *api_Message_new(api_option_Stamp stamp, api_buf payload); +bool api_Message_sent(const api_Message *self, api_status *status); +void api_Node_free(api_Node *self); +void api_Node_drop(api_Node *self, api_status *status); +api_buf api_Node_debug(const api_Node *self, api_status *status); +uint64_t api_Node_value_get(const api_Node *self, api_status *status); +void api_Node_value_set(api_Node *self, uint64_t value, api_status *status); +api_Node *api_Node_new(uint64_t value, api_Node *next, api_status *status); +void api_Node_push(api_Node *self, uint64_t value, api_status *status); +uint64_t api_Node_sum(const api_Node *self, api_status *status); +void api_Tally_free(api_Tally *self); +void api_Tally_drop(api_Tally *self, api_status *status); +bool api_Tally_eq(const api_Tally *a, const api_Tally *b, api_status *status); +api_buf api_Tally_debug(const api_Tally *self, api_status *status); +api_Tally *api_Tally_default(void); +api_Tally *api_Tally_new(void); +uint32_t api_Tally_bump(const api_Tally *self, api_status *status); +typedef struct api_Tally_bump_later_future api_Tally_bump_later_future; +api_Tally_bump_later_future *api_Tally_bump_later(const api_Tally *self, api_status *status); +api_poll api_Tally_bump_later_start(const api_Tally *self, uint32_t *out, api_Tally_bump_later_future **future, api_status *status); +api_poll api_Tally_bump_later_poll(api_Tally_bump_later_future *future, api_waker waker, uint32_t *out, api_status *status); +void api_Tally_bump_later_future_free(api_Tally_bump_later_future *future); +api_Tally_bump_later_future *api_Tally_bump_later_homed(const api_Tally *self, api_status *status); +api_poll api_Tally_bump_later_start_homed(const api_Tally *self, uint32_t *out, api_Tally_bump_later_future **future, api_status *status); +void api_Tallies_free(api_Tallies *self); +void api_Tallies_drop(api_Tallies *self, api_status *status); +api_Tallies *api_Tallies_default(void); +api_Tallies *api_Tallies_new(void); +api_Tally *api_Tallies_first(const api_Tallies *self, api_status *status); +void api_Gauge_free(api_Gauge *self); +void api_Gauge_drop(api_Gauge *self, api_status *status); +bool api_Gauge_borrowed(const api_Gauge *self); +api_Gauge *api_Gauge_clone(const api_Gauge *self, api_status *status); +api_Gauge *api_Gauge_new(uint64_t level); +void api_Gauge_set(const api_Gauge *self, uint64_t level, api_status *status); +uint64_t api_Gauge_level(const api_Gauge *self, api_status *status); +uint64_t api_Gauge_into_level(api_Gauge *self, api_status *status); +typedef struct api_Gauge_later_future api_Gauge_later_future; +api_Gauge_later_future *api_Gauge_later(const api_Gauge *self, api_status *status); +api_poll api_Gauge_later_start(const api_Gauge *self, uint64_t *out, api_Gauge_later_future **future, api_status *status); +api_poll api_Gauge_later_poll(api_Gauge_later_future *future, api_waker waker, uint64_t *out); +void api_Gauge_later_future_free(api_Gauge_later_future *future); +typedef struct api_Gauge_reaches_future api_Gauge_reaches_future; +api_Gauge_reaches_future *api_Gauge_reaches(const api_Gauge *self, uint64_t this_, api_status *status); +api_poll api_Gauge_reaches_start(const api_Gauge *self, uint64_t this_, bool *out, api_Gauge_reaches_future **future, api_status *status); +api_poll api_Gauge_reaches_poll(api_Gauge_reaches_future *future, api_waker waker, bool *out); +void api_Gauge_reaches_future_free(api_Gauge_reaches_future *future); +void api_Latch_free(api_Latch *self); +api_Latch *api_Latch_clone(const api_Latch *self); +api_Latch *api_Latch_default(void); +bool api_Latch_set(const api_Latch *self, uint32_t value); +api_option_u32 api_Latch_get(const api_Latch *self); +void api_Token_free(api_Token *self); +void api_Token_drop(api_Token *self, api_status *status); +api_Token *api_Token_clone(const api_Token *self, api_status *status); +uint32_t api_Token_id_get(const api_Token *self, api_status *status); +void api_Token_id_set(api_Token *self, uint32_t value, api_status *status); +api_Token *api_Token_new(uint32_t id); +api_vec_Token api_Token_twice(const api_Token *self, api_status *status); +void api_Stack_free(api_Stack *self); +void api_Stack_drop(api_Stack *self, api_status *status); +api_buf api_Stack_debug(const api_Stack *self, api_status *status); +api_Stack *api_Stack_default(void); +api_Stack *api_Stack_new(void); +void api_Stack_push(api_Stack *self, api_Counter *item, api_status *status); +api_Counter *api_Stack_pop(api_Stack *self, api_status *status); +size_t api_Stack_depth(const api_Stack *self, api_status *status); +uint64_t api_Stack_depth_past_Point(const api_Stack *self, api_Point from, api_status *status); +uint64_t api_Stack_depth_past_Counter(const api_Stack *self, const api_Counter *from, api_status *status); +uint64_t api_Stack_depth_past_Size(const api_Stack *self, api_Size from, api_status *status); +uint64_t api_Stack_depth_past_Wrap_u32(const api_Stack *self, api_Wrap_u32 from, api_status *status); +void api_Refusal_free(api_Refusal *self); +void api_Refusal_drop(api_Refusal *self, api_status *status); +api_buf api_Refusal_to_string(const api_Refusal *self, api_status *status); +api_buf api_Refusal_debug(const api_Refusal *self, api_status *status); +void api_c_free(api_c *self); +bool api_c_eq(const api_c *a, const api_c *b); +api_buf api_c_debug(const api_c *self); +api_c *api_c_new(uint8_t value); +void api_Key_free(api_Key *self); +bool api_Key_borrowed(const api_Key *self); +api_Key *api_Key_clone(const api_Key *self); +bool api_Key_eq(const api_Key *a, const api_Key *b); +uint64_t api_Key_hash(const api_Key *self); +api_buf api_Key_debug(const api_Key *self); +api_Key *api_Key_new(api_buf name); +uint64_t api_Key_hash_of(const api_Key *self); +void api_clash_Store_free(api_clash_Store *self); +api_clash_Store *api_clash_Store_new(uint32_t count); +uint32_t api_clash_Store_free_(const api_clash_Store *self); +uint32_t api_clash_Store_close(const api_clash_Store *self); +void api_tls_Session_free(api_tls_Session *self); +api_buf api_tls_Session_alpn(const api_tls_Session *self); +api_tls_policy_Lifetime api_tls_Session_lifetime(const api_tls_Session *self); +void api_Url_free(api_Url *self); +void api_Url_drop(api_Url *self, api_status *status); +bool api_Url_borrowed(const api_Url *self); +api_Url *api_Url_clone(const api_Url *self, api_status *status); +bool api_Url_eq(const api_Url *a, const api_Url *b, api_status *status); +uint64_t api_Url_hash(const api_Url *self, api_status *status); +api_buf api_Url_to_string(const api_Url *self, api_status *status); +api_buf api_Url_debug(const api_Url *self, api_status *status); +bool api_Url_parse(api_buf input, api_Url **out, api_buf *err); +void api_Json_free(api_Json *self); +void api_Json_drop(api_Json *self, api_status *status); +bool api_Json_parse(api_buf input, api_Json **out, api_buf *err); +api_buf api_Json_to_text(const api_Json *self, api_status *status); +void api_Instant_free(api_Instant *self); +bool api_Instant_borrowed(const api_Instant *self); +api_Instant *api_Instant_clone(const api_Instant *self); +bool api_Instant_eq(const api_Instant *a, const api_Instant *b); +uint64_t api_Instant_hash(const api_Instant *self); +api_buf api_Instant_debug(const api_Instant *self); +void api_std_io_Error_free(api_std_io_Error *self); +void api_std_io_Error_drop(api_std_io_Error *self, api_status *status); +void api_tls_Config_free(api_tls_Config *self); +void api_tls_Config_drop(api_tls_Config *self, api_status *status); +bool api_tls_Config_borrowed(const api_tls_Config *self); +api_tls_Config *api_tls_Config_clone(const api_tls_Config *self, api_status *status); +void api_tls_Cert_free(api_tls_Cert *self); +void api_tls_Cert_drop(api_tls_Cert *self, api_status *status); +void api_tls_Resolver_free(api_tls_Resolver *self); +void api_tls_Resolver_drop(api_tls_Resolver *self, api_status *status); +bool api_tls_Resolver_borrowed(const api_tls_Resolver *self); +api_tls_Resolver *api_tls_Resolver_clone(const api_tls_Resolver *self, api_status *status); +void api_tls_Codec_free(api_tls_Codec *self); +void api_tls_Codec_drop(api_tls_Codec *self, api_status *status); +void api_Spawned_free(api_Spawned *self); +void api_Spawned_drop(api_Spawned *self, api_status *status); +api_Spawned *api_Spawned_new(uint32_t (*task)(void *data), void *task_data, void (*task_free)(void *data)); +uint32_t api_Spawned_join(api_Spawned *self, api_status *status); +void api_LogThread_free(api_LogThread *self); +void api_LogThread_drop(api_LogThread *self, api_status *status); +api_LogThread *api_LogThread_new(api_Log log, api_buf line); +bool api_LogThread_join(api_LogThread *self, api_status *status); +bool api_has_text(api_Note note); +uint64_t api_marked(const api_Mark *api_marked, api_status *status); +api_option_Reading api_reading(uint32_t n); +api_buf api_reading_debug(uint32_t n); +api_option_Reading api_reading_echo(api_option_Reading reading); +void api_reading_bump(api_option_Reading reading, api_option_Reading *reading_out); +api_Stage api_advance(api_Stage stage); +void api_only(api_Counter *counter, api_Counter **out0, api_status *status); +void api_widths(uint64_t n, uint8_t *out0, int16_t *out1, uint32_t *out2, uint64_t *out3); +bool api_divide(uint64_t a, uint64_t b, uint64_t *out0, uint64_t *out1, api_Error *err); +bool api_corner(bool unit, api_tuple_u32_u32 *out, api_Error *err); +typedef struct api_corner_later_future api_corner_later_future; +api_corner_later_future *api_corner_later(void); +api_poll api_corner_later_start(api_tuple_u32_u32 *out, api_corner_later_future **future); +api_poll api_corner_later_poll(api_corner_later_future *future, api_waker waker, api_tuple_u32_u32 *out); +void api_corner_later_future_free(api_corner_later_future *future); +api_option_tuple_u8_i16_u32_u64 api_spread(uint64_t n); +api_option_tuple_usize_usize api_find(api_buf haystack, api_buf needle); +api_vec_tuple_string_Shape_Point api_rows(api_vec_Point points); +bool api_port(api_buf text, uint16_t *out, api_buf *err); +uint32_t api_span(uint32_t start, uint32_t end); +void api_halves(api_Span span, api_tuple_u32_u32 *out0, api_tuple_u32_u32 *out1); +api_option_tuple_option_u32 api_doubled(api_option_tuple_option_u32 value); +api_option_tuple_string api_title(bool formal); +api_option_tuple_string api_named(api_buf name); +api_tuple_bytes api_lent_back(api_tuple_bytes value); +api_tuple_bytes api_boxed_tuple(api_buf bytes); +void api_swapped(api_tuple_string_u32 pair, uint32_t *out0, api_buf *out1); +bool api_lasting(const api_Draft *draft, api_status *status); +uint32_t api_stored(api_Receipt *receipt, api_status *status); +uint32_t api_tallied(api_Receipt *receipt, api_status *status); +uint32_t api_summed_up_Receipt(api_Receipt *totaled, api_status *status); +uint32_t api_erased(api_Receipt *receipt, api_status *status); +api_Name *api_longer(api_Name *a, const api_Name *b, api_status *status); +api_Name *api_unnamed(void); +uint64_t api_total(api_range_u64 range); +uint32_t api_reach(uint32_t start, uint32_t end); +api_option_u128 api_scaled(api_u128 v, uint64_t by); +api_Batch_2 *api_pair(void); +uint64_t api_drain_4(api_Batch *batch, api_status *status); +uint64_t api_drain_2(api_Batch_2 *batch, api_status *status); +size_t api_capacities_4_4(const api_Batch *a, const api_Batch *b, api_status *status); +size_t api_capacities_4_2(const api_Batch *a, const api_Batch_2 *b, api_status *status); +size_t api_capacities_2_4(const api_Batch_2 *a, const api_Batch *b, api_status *status); +size_t api_capacities_2_2(const api_Batch_2 *a, const api_Batch_2 *b, api_status *status); +typedef struct api_fill_4_future api_fill_4_future; +api_fill_4_future *api_fill_4(api_Batch *batch, uint32_t v, api_status *status); +api_poll api_fill_4_start(api_Batch *batch, uint32_t v, api_vec_u32 *out, api_fill_4_future **future, api_status *status); +api_poll api_fill_4_poll(api_fill_4_future *future, api_waker waker, api_vec_u32 *out); +void api_fill_4_future_free(api_fill_4_future *future); +typedef struct api_fill_2_future api_fill_2_future; +api_fill_2_future *api_fill_2(api_Batch_2 *batch, uint32_t v, api_status *status); +api_poll api_fill_2_start(api_Batch_2 *batch, uint32_t v, api_vec_u32 *out, api_fill_2_future **future, api_status *status); +api_poll api_fill_2_poll(api_fill_2_future *future, api_waker waker, api_vec_u32 *out); +void api_fill_2_future_free(api_fill_2_future *future); +api_range_u64 api_widen(api_range_u64 range, uint64_t by); +size_t api_count(api_bounds_u64 range); +api_bound_u64 api_end(uint64_t limit); +void api_ends(uint64_t limit, api_bound_u64 *out0, api_bound_u64 *out1); +bool api_below(uint64_t n, uint64_t limit, uint64_t *out, api_bounds_u64 *err); +typedef struct api_drive_future api_drive_future; +api_drive_future *api_drive(api_Moment start, bool (*poll)(void *data, api_Moment, const api_Waiter *, api_option_Moment *, api_buf *), void *poll_data, void (*poll_free)(void *data)); +api_poll api_drive_start(api_Moment start, bool (*poll)(void *data, api_Moment, const api_Waiter *, api_option_Moment *, api_buf *), void *poll_data, void (*poll_free)(void *data), api_buf *out, api_drive_future **future); +api_poll api_drive_poll(api_drive_future *future, api_waker waker, api_buf *out); +void api_drive_future_free(api_drive_future *future); +api_buf api_made(uint32_t n, api_buf (*make)(void *data, uint32_t), void *make_data); +api_vec_tuple_string_Ticket api_tickets(api_vec_tuple_string_Ticket entries); +api_Ticket api_reissue(api_Ticket ticket, api_Ticket (*swap)(void *data, api_Ticket), void *swap_data); +api_Ticket api_reissue_lent(api_Ticket ticket, api_Ticket (*swap)(void *data, api_Ticket), void *swap_data); +api_Seat api_seat(const api_Mark *mark, uint32_t row, api_status *status); +uint64_t api_admit(api_tuple_Counter_Mark_Seat_Choice entry, api_status *status); +uint64_t api_choose(api_Choice choice, api_status *status); +uint64_t api_heft(api_tuple_Mark_bytes marked, api_Parcel lent, api_tuple_Counter_bytes moved, api_status *status); +bool api_spend(api_Counter *e, api_Counter *it, uint64_t *out, api_buf *err, api_status *status); +bool api_is_kept(api_Status_ status); +bool api_attempt(bool (*check)(void *data, api_buf *), void *check_data, api_buf *err); +bool api_tail(api_foreign_reader file, uint64_t len, api_buf *out0, uint64_t *out1, api_buf *err); +bool api_seek_to(api_foreign_reader file, uint64_t at, uint64_t *out, api_buf *err); +typedef struct api_halved_future api_halved_future; +api_halved_future *api_halved(uint32_t n); +api_poll api_halved_start(uint32_t n, api_option_u32 *out, api_halved_future **future); +api_poll api_halved_poll(api_halved_future *future, api_waker waker, api_option_u32 *out); +void api_halved_future_free(api_halved_future *future); +typedef struct api_yielded_future api_yielded_future; +api_yielded_future *api_yielded(uint32_t value); +api_poll api_yielded_start(uint32_t value, uint32_t *out, api_yielded_future **future); +api_poll api_yielded_poll(api_yielded_future *future, api_waker waker, uint32_t *out); +void api_yielded_future_free(api_yielded_future *future); +typedef struct api_after_future api_after_future; +api_after_future *api_after(api_foreign_future first, uint32_t value); +api_poll api_after_start(api_foreign_future first, uint32_t value, uint32_t *out, api_after_future **future); +api_poll api_after_poll(api_after_future *future, api_waker waker, uint32_t *out); +void api_after_future_free(api_after_future *future); +typedef struct api_within_future api_within_future; +api_within_future *api_within(uint32_t polls, api_foreign_future future_); +api_poll api_within_start(uint32_t polls, api_foreign_future future_, api_Error *err, api_within_future **future); +api_poll api_within_poll(api_within_future *future, api_waker waker, api_Error *err); +void api_within_future_free(api_within_future *future); +bool api_moment_at(uint64_t ticks, uint64_t rate, api_Moment *out, api_buf *err); +bool api_stamp_at(uint64_t millis, api_Stamp *out, api_buf *err); +api_Moment api_shifted(api_Moment moment, api_Moment (*shift)(void *data, api_Moment), void *shift_data); +uint32_t api_jvm_sum(api_JvmField field, api_JvmStatic method, api_OptIn opt); +api_Clocked api_clocked_after(api_Clocked clocked, uint64_t ticks); +uint32_t api_emit(api_Log log, api_buf lines); +typedef struct api_counted_future api_counted_future; +api_counted_future *api_counted(uint32_t n, void (*count)(void *data, uint32_t), void *count_data); +api_poll api_counted_start(uint32_t n, void (*count)(void *data, uint32_t), void *count_data, uint32_t *out, api_Error *err, api_counted_future **future); +api_poll api_counted_poll(api_counted_future *future, api_waker waker, uint32_t *out, api_Error *err); +void api_counted_future_free(api_counted_future *future); +uint32_t api_filter(api_buf lines, bool (*keep)(void *data, uint8_t, api_buf), void *keep_data); +typedef struct api_log_later_future api_log_later_future; +api_log_later_future *api_log_later(api_Log log); +api_poll api_log_later_start(api_Log log, bool *out, api_log_later_future **future); +api_poll api_log_later_poll(api_log_later_future *future, api_waker waker, bool *out); +void api_log_later_future_free(api_log_later_future *future); +uint32_t api_log_counts(api_Log log, uint8_t level, const api_Counter *counter, api_vec_Counter more, api_status *status); +bool api_on_first_thread(void); +uint32_t api_locals_dropped(void); +api_Local *api_local_or_new(const api_Local *local, api_status *status); +api_Local *api_local_or_new_homed(const api_Local *local, api_status *status); +typedef struct api_local_or_new_later_future api_local_or_new_later_future; +api_local_or_new_later_future *api_local_or_new_later(const api_Local *local, api_status *status); +api_poll api_local_or_new_later_start(const api_Local *local, api_Local **out, api_local_or_new_later_future **future, api_status *status); +api_poll api_local_or_new_later_poll(api_local_or_new_later_future *future, api_waker waker, api_Local **out, api_status *status); +void api_local_or_new_later_future_free(api_local_or_new_later_future *future); +api_local_or_new_later_future *api_local_or_new_later_homed(const api_Local *local, api_status *status); +api_poll api_local_or_new_later_start_homed(const api_Local *local, api_Local **out, api_local_or_new_later_future **future, api_status *status); +uint32_t api_bump_either(const api_Local *first, const api_Local *second, api_status *status); +typedef struct api_local_after_future api_local_after_future; +api_local_after_future *api_local_after(void); +api_poll api_local_after_start(api_Local **out, api_local_after_future **future); +api_poll api_local_after_poll(api_local_after_future *future, api_waker waker, api_Local **out, api_status *status); +void api_local_after_future_free(api_local_after_future *future); +api_local_after_future *api_local_after_homed(void); +api_poll api_local_after_start_homed(api_Local **out, api_local_after_future **future); +typedef struct api_local_later_future api_local_later_future; +api_local_later_future *api_local_later(uint32_t n); +api_poll api_local_later_start(uint32_t n, uint32_t *out, api_local_later_future **future); +api_poll api_local_later_poll(api_local_later_future *future, api_waker waker, uint32_t *out, api_status *status); +void api_local_later_future_free(api_local_later_future *future); +api_local_later_future *api_local_later_homed(uint32_t n); +api_poll api_local_later_start_homed(uint32_t n, uint32_t *out, api_local_later_future **future); +typedef struct api_poll_tripled_future api_poll_tripled_future; +api_poll_tripled_future *api_poll_tripled(uint32_t n); +api_poll api_poll_tripled_start(uint32_t n, uint32_t *out, api_poll_tripled_future **future); +api_poll api_poll_tripled_poll(api_poll_tripled_future *future, api_waker waker, uint32_t *out, api_status *status); +void api_poll_tripled_future_free(api_poll_tripled_future *future); +api_poll_tripled_future *api_poll_tripled_homed(uint32_t n); +api_poll api_poll_tripled_start_homed(uint32_t n, uint32_t *out, api_poll_tripled_future **future); +uint64_t api_watch(const api_Gauge *gauge, uint64_t (*watch)(void *data, const api_Gauge *), void *watch_data, api_status *status); +api_buf api_token_bytes(uint32_t id, uint32_t len); +api_buf api_token_slice(uint32_t id, uint32_t len, uint32_t of); +api_Packet api_next_packet(api_Packet packet); +bool api_fingerprint(api_buf hex, api_array_u8_4 *out, api_buf *err); +uint32_t api_dropped(void); +uint32_t api_bump_both(const api_Tally *a, const api_Tally *b, api_status *status); +uint32_t api_offset(uint32_t (*by)(void *data), void *by_data_, uint32_t by_data); +uint32_t api_shift(uint32_t (*by__)(void *data), void *by___data, uint32_t c_by__); +uint64_t api_walk(uint64_t steps, uint64_t (*visit)(void *data, const api_Cursor *), void *visit_data); +uint32_t api_each(uint32_t steps, void (*visit)(void *data, uint32_t), void *visit_data); +uint32_t api_peek(const api_Tally *tally, uint32_t (*peek)(void *data, const api_Tally *), void *peek_data, api_status *status); +size_t api_len(api_buf payload); +api_buf api_hex(api_buf payload); +api_buf api_timed_hex(api_buf payload); +api_buf api_timed_text(const api_Json *value, api_status *status); +api_buf api_sample_hex(api_buf sample); +api_buf api_queued_hex(api_buf queued); +api_buf api_tick_name(api_Label tick); +api_buf api_rooted_name(api_Label rooted); +api_buf api_stored_text(api_buf stored); +api_buf api_layer_name(api_Label layer); +api_buf api_greet(api_buf name, api_Shape shape); +api_buf api_describe(api_Event event); +api_Pair_Size_u8 api_tag(api_Size size, uint8_t tag); +uint8_t api_cross(api_Left_Right_u8 left, api_Right_Left_u8 right); +uint64_t api_kept_Point(api_Point from); +uint64_t api_kept_Counter(api_Counter *from, api_status *status); +uint64_t api_kept_Size(api_Size from); +uint64_t api_kept_Wrap_u32(api_Wrap_u32 from); +uint64_t api_kept_polar_Point(api_polar_Point from); +int32_t api_keep_Point(api_Point kept); +int32_t api_kept_or_Point(api_option_Point kept); +int32_t api_keeper_Point(api_Point keeper); +api_Boxed_u16 api_BOXED(void); +api_Boxed_u8 api_keeps(api_Log log); +uint32_t api_weigh_Point(api_Point from); +uint32_t api_apply_non_zero_u16(api_Pair_non_zero_u16 pair, uint32_t (*f)(void *data, uint16_t), void *f_data); +uint32_t api_apply_u32(api_Pair_u32 pair, uint32_t (*f)(void *data, uint32_t), void *f_data); +uint32_t api_report_non_zero_u16(api_Pair_non_zero_u16 pair, api_Log log); +uint32_t api_report_u32(api_Pair_u32 pair, api_Log log); +uint32_t api_tally_LogCount(api_Log log); +uint32_t api_wind(api_PolarTurn whole, api_polar_Turn part); +uint64_t api_area(api_Size size); +uint64_t api_seeds_Point_Point(api_Point from); +uint64_t api_seeds_Point_Counter(const api_Counter *from, api_status *status); +uint64_t api_seeds_Point_Size(api_Size from); +uint64_t api_seeds_Point_Wrap_u32(api_Wrap_u32 from); +uint64_t api_seeds_Point_polar_Point(api_polar_Point from); +uint64_t api_seeds_Counter_Point(api_Point from); +uint64_t api_seeds_Counter_Counter(const api_Counter *from, api_status *status); +uint64_t api_seeds_Counter_Size(api_Size from); +uint64_t api_seeds_Counter_Wrap_u32(api_Wrap_u32 from); +uint64_t api_seeds_Counter_polar_Point(api_polar_Point from); +api_Area *api_grow(const api_Area *area, uint32_t by); +api_Slot_u32 *api_wide(uint32_t value); +api_buf api_host(const api_Url *url, api_status *status); +bool api_resolve(api_Url *base, api_buf path, api_Url **out, api_buf *err, api_status *status); +api_vec_u16 api_ports(api_vec_socket_addr addrs); +api_duration api_doubled_ttl(api_duration ttl); +api_buf api_file(api_buf dir, api_buf name); +api_buf api_stray(void); +void api_visit_stray(void (*visit)(void *data, api_buf), void *visit_data); +api_option_char api_next_char(uint32_t c); +api_option_duration api_extended(api_duration duration, api_duration by); +api_vec_option_path api_parents(api_vec_path paths); +api_vec_string api_words(api_buf text); +api_buf api_sentence(api_vec_string words); +void api_put_number(uint32_t value, api_buf buf, api_buf *buf_out); +api_duration api_second_later(api_duration w235); +bool api_digit(api_buf r, api_buf *r_out, uint8_t *out, api_Error *err); +uint32_t api_push_counted(api_tuple_bytes_u32 entry, uint8_t byte, api_tuple_bytes_u32 *entry_out); +void api_nudge(api_Point point, int32_t by, api_Point *point_out); +void api_nudge_by(api_Point point, const api_Refusal *refusal, api_Point *point_out, api_status *status); +api_tls_Config *api_secure(api_buf alpn); +api_buf api_alpn(api_tls_Config *config, api_status *status); +api_buf api_alpn_lent(const api_tls_Config *config, api_status *status); +api_tls_Cert *api_certify(api_buf der); +typedef struct api_byte_len_future api_byte_len_future; +api_byte_len_future *api_byte_len(api_buf bytes); +api_poll api_byte_len_start(api_buf bytes, size_t *out, api_byte_len_future **future); +api_poll api_byte_len_poll(api_byte_len_future *future, api_waker waker, size_t *out); +void api_byte_len_future_free(api_byte_len_future *future); +size_t api_cert_len(const api_tls_Cert *cert, api_status *status); +api_buf api_cert_der(api_tls_Cert *cert, api_status *status); +size_t api_chain_len(api_vec_tls_Cert chain, api_status *status); +bool api_verify(const api_tls_Cert *cert, uint32_t *out, api_buf *err, api_status *status); +bool api_parse_cert(api_buf text, uint32_t *out, api_buf *err); +typedef struct api_parse_later_future api_parse_later_future; +api_parse_later_future *api_parse_later(api_buf text); +api_poll api_parse_later_start(api_buf text, uint32_t *out, api_buf *err, api_parse_later_future **future); +api_poll api_parse_later_poll(api_parse_later_future *future, api_waker waker, uint32_t *out, api_buf *err); +void api_parse_later_future_free(api_parse_later_future *future); +api_tls_Resolver *api_resolver(api_buf name); +api_buf api_resolved(api_tls_Resolver *resolver, api_status *status); +api_std_io_Error *api_failure(api_buf message); +api_buf api_failure_message(const api_std_io_Error *error, api_status *status); +api_buf api_failure_kind(api_std_io_Error *error, api_status *status); +uint32_t api_sum_all(api_vec_u32 items); +uint64_t api_weigh_all_Counter(api_vec_Counter items, api_status *status); +size_t api_offered_len(api_vec_bytes alpns); +api_buf api_join_words(api_vec_string words); +bool api_resume(api_buf alpn, uint32_t seconds, api_tls_Session **out, api_buf *err); +size_t api_either(api_buf text); +typedef struct api_either_later_future api_either_later_future; +api_either_later_future *api_either_later(api_buf text); +api_poll api_either_later_start(api_buf text, size_t *out, api_either_later_future **future); +api_poll api_either_later_poll(api_either_later_future *future, api_waker waker, size_t *out); +void api_either_later_future_free(api_either_later_future *future); +api_buf api_prefixed(api_buf payload, api_buf prefix); +int32_t api_sum_lists(api_vec_i32 a, api_vec_i32 b, api_vec_i32 c); +int32_t api_coordinates(api_option_Point point); +api_vec_bytes api_chunks(api_buf bytes, size_t size); +api_vec_Counter api_counters(api_vec_string names); +uint64_t api_worth(api_vec_Counter some, api_vec_Counter boxed, api_status *status); +api_option_u64 api_held_count(api_option_tuple_Counter held, api_status *status); +api_Counter *api_boxed_counter(api_buf name); +api_buf api_boxed_name(api_Counter *boxed, api_status *status); +uint32_t api_less(uint32_t value, uint32_t _value); +api_vec_u32 api_sums(api_vec_vec_u32 rows); +api_vec_vec_u32 api_least(api_vec_vec_u32 sets); +void api_split_last(api_vec_i32 items, api_vec_i32 *out0, uint32_t *out1); +uint64_t api_sum_u32(api_vec_u32 items); +api_vec_i64 api_doubled_i64(api_vec_i64 items); +api_vec_f64 api_boxed_floats(api_vec_f64 items); +api_Point api_summed(api_vec_Point points); +api_duration api_breadth(api_Limits_duration limits); +api_Limits_bytes api_byte_limits(api_buf low, api_buf high); +api_buf api_joined(api_vec_bytes parts); +api_buf api_first_of(api_vec_string items); +uint64_t api_read_len(api_buf reader); +size_t api_longest(api_vec_string words); +api_buf api_encode(const api_Json *value, api_status *status); +api_Json *api_tagged(api_Json *doc, api_buf tag, api_status *status); +api_vec_tuple_string_Json api_entries(api_vec_tuple_string_Json entries, api_buf tag, api_status *status); +api_vec_tuple_string_Json api_sections(api_vec_tuple_string_Json entries, api_status *status); +api_Instant *api_now(void); +api_Instant *api_later(const api_Instant *at, api_duration by); +api_duration api_since(const api_Instant *later, const api_Instant *earlier); +bool api_has_instant(api_Instant *at); +api_option_Level api_louder(api_option_Level filter); +api_buf api_spell(api_option_Level filter); +api_vec_string api_GREETINGS(void); +api_vec_u32 api_PRIMES(void); +api_vec_Counter api_numbered(api_vec_string names); +void api_nexts(api_socket_addr_v4 v4, api_socket_addr_v6 v6, api_socket_addr_v4 *out0, api_socket_addr_v6 *out1); +void api_next_ips(api_ipv4_addr v4, api_ipv6_addr v6, api_ipv4_addr *out0, api_ipv6_addr *out1); +api_ip_addr api_flip(api_ip_addr ip); +api_buf api_reasons(api_vec_tuple_Counter_Refusal pairs, api_option_tuple_Counter_Refusal last, api_status *status); +size_t api_excuse(api_buf note, api_tuple_bytes_Refusal entry, api_status *status); +uint32_t api_relay(api_Log log, api_vec_Refusal refusals, api_status *status); +bool api_refuse(api_buf reason, uint32_t *out, api_Refusal **err); +api_Platform api_platform(void); +uint32_t api_pointer_bits(api_Platform platform); +api_Labelled api_same_labelled(api_Labelled labelled); +api_Placement api_placement(void); +bool api_is_family(api_Family family); +uint32_t api_wasm_only(void); +bool api_wasm_take(api_Counter *counter, uint64_t *out, api_Error *err, api_status *status); +void api_wasm_log(api_Log log); +uint64_t api_booth_count(api_Booth booth, api_status *status); +api_Page api_page(void); +uint32_t api_beats(api_Beat beat); +int32_t api_same(double a, double b); +bool api_return_values(api_Point point, bool fail, api_Point *point_out, api_buf *out0, api_option_tuple_u8_i16_u32_u64 *out1, api_vec_bytes *out2, api_Error *err); +bool api_return_moved(api_Counter *counter, bool fail, api_Counter **out, api_Error *err, api_status *status); +api_NonZeros api_non_zeros(void); +api_buf api_describe_non_zeros(api_NonZeros non_zeros); +api_option_non_zero_u64 api_next_hop(api_option_non_zero_u64 hop); +uint16_t api_farther_hop(api_Pair_non_zero_u16 hops); +api_duration api_same_duration(api_duration v); +uint64_t api_same_u64(uint64_t v); +size_t api_same_usize(size_t v); +ptrdiff_t api_same_isize(ptrdiff_t v); +api_u128 api_same_u128(api_u128 v); +uint32_t api_same_char(uint32_t v); +api_buf api_same_string(api_buf v); +api_buf api_same_path(api_buf v); +api_socket_addr api_same_socket_addr(api_socket_addr v); +api_socket_addr_v4 api_same_socket_addr_v4(api_socket_addr_v4 v); +api_socket_addr_v6 api_same_socket_addr_v6(api_socket_addr_v6 v); +api_ip_addr api_same_ip_addr(api_ip_addr v); +uint64_t api_crowded(api_Reading reading, api_Stamp a, api_Stamp b, uint64_t n0, uint64_t n1, uint64_t n2, uint64_t n3, uint64_t n4, uint64_t n5, uint64_t n6, uint64_t n7, uint64_t n8, uint64_t n9, uint64_t n10, uint64_t n11, uint64_t n12, uint64_t n13, uint64_t n14, uint64_t n15, uint64_t n16, uint64_t n17, uint64_t n18, uint64_t n19, uint64_t n20, uint64_t n21, uint64_t n22, uint64_t n23, uint64_t n24, uint64_t n25, uint64_t n26, uint64_t n27, uint64_t n28, uint64_t n29, uint64_t n30, uint64_t n31, uint64_t n32, uint64_t n33, uint64_t n34, uint64_t n35, uint64_t n36, uint64_t n37, uint64_t n38, uint64_t n39, uint64_t n40, uint64_t n41, uint64_t n42, uint64_t n43, uint64_t n44, uint64_t n45, uint64_t n46, uint64_t n47, uint64_t n48, uint64_t n49, uint64_t n50, uint64_t n51, uint64_t n52, uint64_t n53, uint64_t n54, uint64_t n55, uint64_t n56, uint64_t n57, uint64_t n58, uint64_t n59, uint64_t n60, uint64_t n61, uint64_t n62, uint64_t n63, uint64_t n64, uint64_t n65, uint64_t n66, uint64_t n67, uint64_t n68, uint64_t n69, uint64_t n70, uint64_t n71, uint64_t n72, uint64_t n73, uint64_t n74, uint64_t n75, uint64_t n76, uint64_t n77, uint64_t n78, uint64_t n79, uint64_t n80, uint64_t n81, uint64_t n82, uint64_t n83, uint64_t n84, uint64_t n85, uint64_t n86, uint64_t n87, uint64_t n88, uint64_t n89, uint64_t n90, uint64_t n91, uint64_t n92, uint64_t n93, uint64_t n94, uint64_t n95, uint64_t n96, uint64_t n97, uint64_t n98, uint64_t n99, uint64_t n100, uint64_t n101, uint64_t n102, uint64_t n103, uint64_t n104, uint64_t n105, uint64_t n106, uint64_t n107, uint64_t n108, uint64_t n109, uint64_t n110, uint64_t n111, uint64_t n112, uint64_t n113, uint64_t n114, uint64_t n115, uint64_t n116, uint64_t n117, uint64_t n118); +uint64_t api_crammed(api_Moment a, api_Moment b, uint64_t n0, uint64_t n1, uint64_t n2, uint64_t n3, uint64_t n4, uint64_t n5, uint64_t n6, uint64_t n7, uint64_t n8, uint64_t n9, uint64_t n10, uint64_t n11, uint64_t n12, uint64_t n13, uint64_t n14, uint64_t n15, uint64_t n16, uint64_t n17, uint64_t n18, uint64_t n19, uint64_t n20, uint64_t n21, uint64_t n22, uint64_t n23, uint64_t n24, uint64_t n25, uint64_t n26, uint64_t n27, uint64_t n28, uint64_t n29, uint64_t n30, uint64_t n31, uint64_t n32, uint64_t n33, uint64_t n34, uint64_t n35, uint64_t n36, uint64_t n37, uint64_t n38, uint64_t n39, uint64_t n40, uint64_t n41, uint64_t n42, uint64_t n43, uint64_t n44, uint64_t n45, uint64_t n46, uint64_t n47, uint64_t n48, uint64_t n49, uint64_t n50, uint64_t n51, uint64_t n52, uint64_t n53, uint64_t n54, uint64_t n55, uint64_t n56, uint64_t n57, uint64_t n58, uint64_t n59, uint64_t n60, uint64_t n61, uint64_t n62, uint64_t n63, uint64_t n64, uint64_t n65, uint64_t n66, uint64_t n67, uint64_t n68, uint64_t n69, uint64_t n70, uint64_t n71, uint64_t n72, uint64_t n73, uint64_t n74, uint64_t n75, uint64_t n76, uint64_t n77, uint64_t n78, uint64_t n79, uint64_t n80, uint64_t n81, uint64_t n82, uint64_t n83, uint64_t n84, uint64_t n85, uint64_t n86, uint64_t n87, uint64_t n88, uint64_t n89, uint64_t n90, uint64_t n91, uint64_t n92, uint64_t n93, uint64_t n94, uint64_t n95, uint64_t n96, uint64_t n97, uint64_t n98, uint64_t n99, uint64_t n100, uint64_t n101, uint64_t n102, uint64_t n103, uint64_t n104, uint64_t n105, uint64_t n106, uint64_t n107, uint64_t n108, uint64_t n109, uint64_t n110, uint64_t n111, uint64_t n112, uint64_t n113, uint64_t n114, uint64_t n115, uint64_t n116, uint64_t n117, uint64_t n118, uint64_t n119, uint64_t n120, uint64_t n121, uint64_t n122, uint64_t n123); +uint32_t api_jni_one(void); +api_option_polar_Point api_polar_point(uint32_t distance); +bool api_clash_audible(api_clash_Tone tone, api_clash_Tone *out, api_vec_clash_Tone *err); +uint32_t api_clash_nested(api_option_tuple_tuple_u8_u16_u32 a, api_option_tuple_tuple_u8_u16_u32_ b); +uint8_t api_clash_audio_encoder_finish(void); +uint8_t api_clash_audio_encoder_finish_(void); +uint32_t api_emit_from_thread(api_Log log, api_buf lines); +typedef struct api_emit_later_future api_emit_later_future; +api_emit_later_future *api_emit_later(api_Log log, api_buf lines); +api_poll api_emit_later_start(api_Log log, api_buf lines, uint32_t *out, api_emit_later_future **future); +api_poll api_emit_later_poll(api_emit_later_future *future, api_waker waker, uint32_t *out); +void api_emit_later_future_free(api_emit_later_future *future); +typedef struct api_log_on_drop_future api_log_on_drop_future; +api_log_on_drop_future *api_log_on_drop(api_Log log); +api_poll api_log_on_drop_start(api_Log log, api_log_on_drop_future **future); +api_poll api_log_on_drop_poll(api_log_on_drop_future *future, api_waker waker); +void api_log_on_drop_future_free(api_log_on_drop_future *future); +api_waker api_log_waker(api_Log log); +#ifdef __cplusplus +} +#endif +#endif diff --git a/ffi/surface/api/cpp.hpp b/ffi/surface/api/cpp.hpp new file mode 100644 index 000000000..ae0fbaf55 --- /dev/null +++ b/ffi/surface/api/cpp.hpp @@ -0,0 +1,1918 @@ +// api.hpp +#ifndef API_HPP_CRATE7 +#define API_HPP_CRATE7 +#include "rt.hpp" +#include "core.hpp" +#include "dep.hpp" +#include "serdejson.hpp" +#include "std.hpp" +#include "tls.hpp" +#include "tracingcore.hpp" +#include "url.hpp" +namespace api { + enum class Shape { + circle = 1, + square = 4, + }; + enum class Status_ { + moved = 0, + kept = 1, + }; + enum class Family { + native = 0, + wasm = 1, + }; + enum class VecClashTone { + error = 0, + }; + inline constexpr ::std::uint64_t LIMIT = API_LIMIT; + inline constexpr ::std::int64_t FAR = API_FAR; + class RUST2_FFI_CONSUMABLE Board { + RUST2_FFI_UNCONSUMED Board(Board &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Board &operator=(Board &&other) noexcept = default; + static ::api::Board new_(::api::taken<::std::tuple<::api::view, ::api::Counter>> counters); + RUST2_FFI_CONSUMES ::std::vector<::std::tuple<::api::buf, ::api::Counter>> into_counters() &&; + RUST2_FFI_CALLABLE ::std::vector<::std::tuple<::api::buf, ::api::Counter>> ranked() const; + RUST2_FFI_CALLABLE ::api::Counter best() const; + }; + class RUST2_FFI_CONSUMABLE Receipt { + RUST2_FFI_UNCONSUMED Receipt(Receipt &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Receipt &operator=(Receipt &&other) noexcept = default; + RUST2_FFI_CALLABLE Receipt clone() const; + RUST2_FFI_CALLABLE ::std::uint32_t count() const; + }; + class RUST2_FFI_CONSUMABLE Draft { + RUST2_FFI_UNCONSUMED Draft(Draft &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Draft &operator=(Draft &&other) noexcept = default; + RUST2_FFI_CALLABLE bool edited() const; + RUST2_FFI_CALLABLE ::api::buf describe() const; + RUST2_FFI_CONSUMES ::std::uint32_t commit() &&; + RUST2_FFI_CALLABLE ::api::buf title_get() const; + RUST2_FFI_CALLABLE void title_set(::api::input value); + RUST2_FFI_CALLABLE ::std::uint32_t lines() const; + RUST2_FFI_CALLABLE void write(::api::input line); + }; + class RUST2_FFI_CONSUMABLE Filed_Receipt { + RUST2_FFI_UNCONSUMED Filed_Receipt(Filed_Receipt &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Filed_Receipt &operator=(Filed_Receipt &&other) noexcept = default; + RUST2_FFI_CALLABLE Filed_Receipt clone() const; + RUST2_FFI_CALLABLE ::std::uint32_t count() const; + }; + class RUST2_FFI_CONSUMABLE Pad_u16 { + RUST2_FFI_UNCONSUMED Pad_u16(Pad_u16 &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Pad_u16 &operator=(Pad_u16 &&other) noexcept = default; + static ::api::Pad_u16 wide(); + RUST2_FFI_CALLABLE ::std::uint16_t tag() const; + RUST2_FFI_CALLABLE ::std::uint16_t title() const; + RUST2_FFI_CALLABLE ::api::buf describe() const; + }; + class RUST2_FFI_CONSUMABLE Pad_u8 { + RUST2_FFI_UNCONSUMED Pad_u8(Pad_u8 &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Pad_u8 &operator=(Pad_u8 &&other) noexcept = default; + static ::api::Pad_u8 small(); + RUST2_FFI_CALLABLE ::api::buf describe() const; + RUST2_FFI_CALLABLE ::api::buf title_get() const; + RUST2_FFI_CALLABLE ::std::uint32_t lines() const; + }; + class RUST2_FFI_CONSUMABLE Layered { + RUST2_FFI_UNCONSUMED Layered(Layered &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Layered &operator=(Layered &&other) noexcept = default; + static ::api::Layered new_(); + RUST2_FFI_CALLABLE ::api::buf title_get() const; + RUST2_FFI_CALLABLE ::std::uint32_t lines() const; + }; + class RUST2_FFI_CONSUMABLE Marker { + RUST2_FFI_UNCONSUMED Marker(Marker &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Marker &operator=(Marker &&other) noexcept = default; + static ::api::Marker new_(::api::input label, ::std::int32_t x, ::std::int32_t y); + RUST2_FFI_CALLABLE ::api::buf label() const; + RUST2_FFI_CALLABLE ::std::int32_t x_get() const; + RUST2_FFI_CALLABLE void x_set(::std::int32_t value); + RUST2_FFI_CALLABLE ::std::int32_t y_get() const; + RUST2_FFI_CALLABLE void y_set(::std::int32_t value); + RUST2_FFI_CALLABLE ::api::Point offset(::std::int32_t dx, ::std::int32_t dy) const; + }; + class RUST2_FFI_CONSUMABLE Batch { + RUST2_FFI_UNCONSUMED Batch(Batch &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Batch &operator=(Batch &&other) noexcept = default; + static ::api::Batch new_(); + RUST2_FFI_CALLABLE bool push(::std::uint32_t v); + RUST2_FFI_CALLABLE ::std::size_t capacity() const; + }; + class RUST2_FFI_CONSUMABLE Batch_2 { + RUST2_FFI_UNCONSUMED Batch_2(Batch_2 &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Batch_2 &operator=(Batch_2 &&other) noexcept = default; + static ::api::Batch_2 new_(); + RUST2_FFI_CALLABLE bool push(::std::uint32_t v); + RUST2_FFI_CALLABLE ::std::size_t capacity() const; + }; + class RUST2_FFI_CONSUMABLE Waiter { + RUST2_FFI_UNCONSUMED Waiter(Waiter &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Waiter &operator=(Waiter &&other) noexcept = default; + static ::api::Waiter new_(const ::api::waker &waker_); + RUST2_FFI_CALLABLE ::api::waker waker() const; + RUST2_FFI_CALLABLE ::api::waker context() const; + template static ::api::Waiter_poll_future_future poll_future(F0 future_); + }; + class RUST2_FFI_CONSUMABLE Logger { + RUST2_FFI_UNCONSUMED Logger(Logger &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Logger &operator=(Logger &&other) noexcept = default; + static ::api::Logger new_(::std::unique_ptr<::api::Log> sink); + RUST2_FFI_CALLABLE bool write(::api::input line) const; + RUST2_FFI_CALLABLE bool write_from_thread(::api::input line) const; + }; + class RUST2_FFI_CONSUMABLE Journal { + RUST2_FFI_UNCONSUMED Journal(Journal &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Journal &operator=(Journal &&other) noexcept = default; + static ::api::Journal new_(::std::unique_ptr<::api::Log> sink); + RUST2_FFI_CALLABLE void redirect(::std::unique_ptr<::api::Log> sink); + RUST2_FFI_CALLABLE bool write(::api::input line) const; + }; + class RUST2_FFI_CONSUMABLE Local { + RUST2_FFI_UNCONSUMED Local(Local &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Local &operator=(Local &&other) noexcept = default; + RUST2_FFI_CALLABLE ::std::uint64_t hash() const; + static Local default_(); + static ::api::Local new_(); + RUST2_FFI_CALLABLE ::std::uint32_t bump() const; + RUST2_FFI_CALLABLE ::api::Local share() const; + RUST2_FFI_CALLABLE ::api::Local_later_future later() const; + template RUST2_FFI_CALLABLE ::std::uint32_t visit(F0 &&f) const; + RUST2_FFI_CALLABLE ::api::Local_poll_count_future poll_count() const; + RUST2_FFI_CALLABLE ::std::uint64_t thread_number() const; + RUST2_FFI_CALLABLE bool on_own_thread() const; + }; + class RUST2_FFI_CONSUMABLE LocalWaiter { + RUST2_FFI_UNCONSUMED LocalWaiter(LocalWaiter &&other RUST2_FFI_MOVED_FROM) noexcept = default; + LocalWaiter &operator=(LocalWaiter &&other) noexcept = default; + static ::api::LocalWaiter new_(const ::api::waker &waker_); + static ::api::LocalWaiter_poll_ready_future poll_ready(::std::uint32_t n); + }; + class RUST2_FFI_CONSUMABLE Retry { + RUST2_FFI_UNCONSUMED Retry(Retry &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Retry &operator=(Retry &&other) noexcept = default; + RUST2_FFI_CALLABLE ::std::optional<::std::uint32_t> limit_get() const; + RUST2_FFI_CALLABLE void limit_set(const ::std::optional<::std::uint32_t> &value); + static ::api::Retry new_(const ::std::optional<::std::uint32_t> &limit); + RUST2_FFI_CALLABLE ::std::uint32_t limit() const; + RUST2_FFI_CALLABLE ::std::uint32_t delay() const; + RUST2_FFI_CALLABLE void set_limit(::std::uint32_t limit); + }; + class RUST2_FFI_CONSUMABLE Digest { + RUST2_FFI_UNCONSUMED Digest(Digest &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Digest &operator=(Digest &&other) noexcept = default; + RUST2_FFI_CALLABLE ::std::array<::std::uint8_t, 4> sum_get() const; + RUST2_FFI_CALLABLE void sum_set(const ::std::array<::std::uint8_t, 4> &value); + static ::api::Digest new_(); + RUST2_FFI_CALLABLE ::std::array<::std::uint8_t, 4> flipped(const ::std::array<::std::uint8_t, 4> &mask) const; + }; + class RUST2_FFI_CONSUMABLE Cursor { + RUST2_FFI_UNCONSUMED Cursor(Cursor &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Cursor &operator=(Cursor &&other) noexcept = default; + RUST2_FFI_CALLABLE ::std::uint64_t at() const; + }; + class RUST2_FFI_CONSUMABLE Outer_Inner_u8 { + RUST2_FFI_UNCONSUMED Outer_Inner_u8(Outer_Inner_u8 &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Outer_Inner_u8 &operator=(Outer_Inner_u8 &&other) noexcept = default; + static ::api::Outer_Inner_u8 new_(::std::uint8_t value); + RUST2_FFI_CALLABLE ::std::uint8_t get() const; + }; + class RUST2_FFI_CONSUMABLE Slot_u32 { + RUST2_FFI_UNCONSUMED Slot_u32(Slot_u32 &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Slot_u32 &operator=(Slot_u32 &&other) noexcept = default; + static ::api::Slot_u32 new_(::std::uint32_t value); + }; + class RUST2_FFI_CONSUMABLE Slot_u8 { + RUST2_FFI_UNCONSUMED Slot_u8(Slot_u8 &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Slot_u8 &operator=(Slot_u8 &&other) noexcept = default; + static ::api::Slot_u8 new_(::std::uint8_t value); + RUST2_FFI_CALLABLE ::std::uint16_t value() const; + }; + class RUST2_FFI_CONSUMABLE Resolving { + RUST2_FFI_UNCONSUMED Resolving(Resolving &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Resolving &operator=(Resolving &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::tls_Resolver _0_get() const; + RUST2_FFI_CALLABLE void _0_set(::api::tls_Resolver value); + static ::api::Resolving new_(::api::input name); + }; + class RUST2_FFI_CONSUMABLE Codecs { + RUST2_FFI_UNCONSUMED Codecs(Codecs &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Codecs &operator=(Codecs &&other) noexcept = default; + static Codecs default_(); + RUST2_FFI_CALLABLE ::std::vector<::api::tls_Codec> list_get() const; + RUST2_FFI_CALLABLE void list_set(::std::vector<::api::tls_Codec> value); + static ::api::Codecs new_(); + RUST2_FFI_CALLABLE ::std::uint32_t ids(); + }; + class RUST2_FFI_CONSUMABLE Der { + RUST2_FFI_UNCONSUMED Der(Der &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Der &operator=(Der &&other) noexcept = default; + static ::api::Der from_slice(::api::input bytes); + RUST2_FFI_CALLABLE ::api::buf bytes() const; + }; + class RUST2_FFI_CONSUMABLE Verbosity { + RUST2_FFI_UNCONSUMED Verbosity(Verbosity &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Verbosity &operator=(Verbosity &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::Level level_get() const; + RUST2_FFI_CALLABLE void level_set(::api::Level value); + static ::api::Verbosity new_(::api::Level level); + RUST2_FFI_CALLABLE ::std::optional<::api::Level> filter() const; + }; + class RUST2_FFI_CONSUMABLE Site { + RUST2_FFI_UNCONSUMED Site(Site &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Site &operator=(Site &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::Url home_get() const; + RUST2_FFI_CALLABLE void home_set(::api::Url value); + static ::api::Site new_(::api::Url home); + }; + class RUST2_FFI_CONSUMABLE Trail { + RUST2_FFI_UNCONSUMED Trail(Trail &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Trail &operator=(Trail &&other) noexcept = default; + static ::api::Trail new_(const ::std::vector<::api::Point> &points, const ::api::items<::api::view> &names); + RUST2_FFI_CALLABLE ::std::vector<::api::Point> points() const; + RUST2_FFI_CALLABLE ::std::vector<::api::Label> labels() const; + RUST2_FFI_CALLABLE ::std::vector<::api::Point> iter() const; + RUST2_FFI_CALLABLE ::std::vector<::api::buf> names() const; + RUST2_FFI_CALLABLE ::std::vector<::api::Point> beyond(::std::int32_t x) const; + RUST2_FFI_CALLABLE ::api::buf bytes() const; + RUST2_FFI_CALLABLE ::std::vector<::api::Label> drain(); + }; + class RUST2_FFI_CONSUMABLE Worker { + RUST2_FFI_UNCONSUMED Worker(Worker &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Worker &operator=(Worker &&other) noexcept = default; + static ::api::Worker new_(::std::uint32_t id); + RUST2_FFI_CALLABLE ::std::uint32_t id() const; + }; + class RUST2_FFI_CONSUMABLE Handle { + RUST2_FFI_UNCONSUMED Handle(Handle &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Handle &operator=(Handle &&other) noexcept = default; + static ::api::Handle new_(::std::uint32_t count); + RUST2_FFI_CALLABLE ::std::uint32_t count() const; + static ::api::Handle_later_future later(::std::uint32_t count); + }; + class RUST2_FFI_CONSUMABLE Counter { + RUST2_FFI_UNCONSUMED Counter(Counter &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Counter &operator=(Counter &&other) noexcept = default; + RUST2_FFI_CALLABLE Counter clone() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static Counter default_(); + static ::api::Counter new_(::api::input name, ::std::uint64_t start); + RUST2_FFI_CALLABLE ::std::uint64_t get() const; + RUST2_FFI_CALLABLE ::std::uint64_t offset(::std::uint64_t handle, ::std::uint64_t h) const; + RUST2_FFI_CONSUMES ::std::uint64_t into_sum(::std::uint64_t close) &&; + RUST2_FFI_CALLABLE ::api::buf name() const; + RUST2_FFI_CALLABLE ::api::result<::std::uint64_t, ::api::Error> add(::std::uint64_t n); + RUST2_FFI_CALLABLE ::api::result<::std::uint64_t, ::api::Error> sub(::std::uint64_t n); + RUST2_FFI_CALLABLE bool edited() const; + RUST2_FFI_CALLABLE ::std::uint64_t plus(const ::api::Counter *other) const; + RUST2_FFI_CALLABLE ::std::uint64_t clamped(const ::api::Counter *low, const ::api::Counter *high) const; + RUST2_FFI_CALLABLE ::api::Counter_plus_later_future plus_later(const ::api::Counter *other) const; + RUST2_FFI_CALLABLE bool add_to(::api::Counter *other) const; + RUST2_FFI_CONSUMES ::api::Label into_label(const ::std::optional<::api::Point> &at) &&; + RUST2_FFI_CALLABLE void rename(::api::input name); + RUST2_FFI_CONSUMES ::std::tuple<::api::Counter, ::api::Counter> split(::std::uint64_t at) &&; + RUST2_FFI_CALLABLE bool is(::api::input name) const; + static ::api::Counter seeded_Point(::api::input name, const ::api::Point &from); + static ::api::Counter seeded_Counter(::api::input name, const ::api::Counter &from); + static ::api::Counter seeded_Size(::api::input name, const ::api::Size &from); + static ::api::Counter seeded_Wrap_u32(::api::input name, const ::api::Wrap_u32 &from); + static ::api::Counter seeded_polar_Point(::api::input name, const ::api::polar_Point &from); + }; + class RUST2_FFI_CONSUMABLE Meter { + RUST2_FFI_UNCONSUMED Meter(Meter &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Meter &operator=(Meter &&other) noexcept = default; + static Meter default_(); + RUST2_FFI_CALLABLE ::std::uint64_t add(::std::uint64_t n) const; + RUST2_FFI_CALLABLE ::std::uint64_t count() const; + RUST2_FFI_CALLABLE void reset(); + }; + class RUST2_FFI_CONSUMABLE Meters { + RUST2_FFI_UNCONSUMED Meters(Meters &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Meters &operator=(Meters &&other) noexcept = default; + static Meters default_(); + RUST2_FFI_CALLABLE ::api::Meter last_get() const; + RUST2_FFI_CALLABLE void last_set(::api::Meter value); + RUST2_FFI_CALLABLE ::std::optional<::api::Meter> spare_get() const; + RUST2_FFI_CALLABLE void spare_set(::std::optional<::api::Meter> value); + static ::api::Meters new_(); + RUST2_FFI_CALLABLE ::api::Meter first() const; + RUST2_FFI_CALLABLE void clear(); + }; + class RUST2_FFI_CONSUMABLE Registry { + RUST2_FFI_UNCONSUMED Registry(Registry &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Registry &operator=(Registry &&other) noexcept = default; + static Registry default_(); + RUST2_FFI_CALLABLE ::api::Counter first_get() const; + RUST2_FFI_CALLABLE void first_set(::api::Counter value); + static ::api::Registry new_(::api::Counter first); + RUST2_FFI_CALLABLE ::std::optional<::api::Counter> last() const; + RUST2_FFI_CALLABLE void push(::api::Counter counter); + template RUST2_FFI_CALLABLE bool edit(F0 &&edit); + }; + class RUST2_FFI_CONSUMABLE Ledger { + RUST2_FFI_UNCONSUMED Ledger(Ledger &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Ledger &operator=(Ledger &&other) noexcept = default; + static Ledger default_(); + static ::api::Ledger new_(); + RUST2_FFI_CALLABLE ::api::result<::api::Draft, ::api::Error> edit(); + RUST2_FFI_CALLABLE ::std::uint32_t published() const; + RUST2_FFI_CALLABLE ::api::buf title() const; + RUST2_FFI_CALLABLE void seal(); + RUST2_FFI_CALLABLE ::api::Receipt receipt(); + RUST2_FFI_CALLABLE ::api::Receipt noted(); + RUST2_FFI_CALLABLE ::api::Filed_Receipt file_Receipt(::api::Receipt item); + RUST2_FFI_CALLABLE ::api::Slip slip(); + }; + class RUST2_FFI_CONSUMABLE Slip { + RUST2_FFI_UNCONSUMED Slip(Slip &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Slip &operator=(Slip &&other) noexcept = default; + RUST2_FFI_CALLABLE Slip clone() const; + RUST2_FFI_CALLABLE ::api::Receipt receipt_get() const; + RUST2_FFI_CALLABLE void receipt_set(::api::Receipt value); + RUST2_FFI_CALLABLE ::api::Receipt global_get() const; + RUST2_FFI_CALLABLE void global_set(::api::Receipt value); + RUST2_FFI_CALLABLE ::std::uint32_t count() const; + }; + class RUST2_FFI_CONSUMABLE Sheet { + RUST2_FFI_UNCONSUMED Sheet(Sheet &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Sheet &operator=(Sheet &&other) noexcept = default; + RUST2_FFI_CALLABLE Sheet clone() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static Sheet default_(); + RUST2_FFI_CALLABLE ::api::buf title_get() const; + RUST2_FFI_CALLABLE void title_set(::api::input value); + static ::api::Sheet new_(); + RUST2_FFI_CALLABLE ::std::uint32_t lines() const; + RUST2_FFI_CALLABLE void write(::api::input line); + RUST2_FFI_CALLABLE ::api::buf describe() const; + }; + class RUST2_FFI_CONSUMABLE Name { + RUST2_FFI_UNCONSUMED Name(Name &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Name &operator=(Name &&other) noexcept = default; + RUST2_FFI_CALLABLE Name clone() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::Name owned(::api::input text); + RUST2_FFI_CALLABLE ::api::buf as_str() const; + RUST2_FFI_CALLABLE ::api::Name join(const ::api::Name &other) const; + static ::api::Name borrowed(::api::input text); + RUST2_FFI_CALLABLE bool shares(const ::api::Name &other) const; + RUST2_FFI_CALLABLE void rename(::api::input text); + }; + class RUST2_FFI_CONSUMABLE Channel { + RUST2_FFI_UNCONSUMED Channel(Channel &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Channel &operator=(Channel &&other) noexcept = default; + RUST2_FFI_CALLABLE Channel clone() const; + static Channel default_(); + static ::api::Channel new_(); + RUST2_FFI_CALLABLE void clear(); + RUST2_FFI_CALLABLE void send(::api::input payload) const; + RUST2_FFI_CALLABLE ::api::Channel_recv_future recv() const; + RUST2_FFI_CALLABLE void notify(const ::api::waker &waker_) const; + RUST2_FFI_CALLABLE ::api::Channel_send_later_future send_later(::api::input payload) const; + RUST2_FFI_CALLABLE ::api::Channel_tagged_future tagged(::api::input tag) const; + RUST2_FFI_CALLABLE ::api::Channel_itemized_future itemized(const ::std::optional<::std::vector<::std::uint32_t>> &items_) const; + RUST2_FFI_CALLABLE ::api::Channel_poll_take_future poll_take() const; + RUST2_FFI_CALLABLE ::api::Channel_poll_measure_future poll_measure(::std::size_t extra); + RUST2_FFI_CALLABLE void listen(const ::api::waker &cx) const; + RUST2_FFI_CALLABLE ::api::Channel_recv_sized_future recv_sized() const; + RUST2_FFI_CALLABLE ::api::Channel_recv_nonempty_future recv_nonempty() const; + RUST2_FFI_CALLABLE void send_from_thread(::api::input payload) const; + }; + class RUST2_FFI_CONSUMABLE Gap { + RUST2_FFI_UNCONSUMED Gap(Gap &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Gap &operator=(Gap &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Gap(const Gap &other) = default; + Gap &operator=(const Gap &other) = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::Gap new_(::std::uint64_t wide, ::std::uint8_t narrow); + RUST2_FFI_CALLABLE ::std::uint64_t sum() const; + }; + class RUST2_FFI_CONSUMABLE Berth { + RUST2_FFI_UNCONSUMED Berth(Berth &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Berth &operator=(Berth &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Berth(const Berth &other) = default; + Berth &operator=(const Berth &other) = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::Berth new_(const ::std::optional<::std::uint32_t> &at); + RUST2_FFI_CALLABLE ::std::optional<::std::uint32_t> at() const; + }; + class RUST2_FFI_CONSUMABLE Mark { + RUST2_FFI_UNCONSUMED Mark(Mark &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Mark &operator=(Mark &&other) noexcept = default; + RUST2_FFI_CALLABLE Mark clone() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::Mark of(::std::uint64_t count); + RUST2_FFI_CALLABLE ::std::uint64_t count() const; + RUST2_FFI_CALLABLE void add(::std::uint64_t by); + }; + class RUST2_FFI_CONSUMABLE Message { + RUST2_FFI_UNCONSUMED Message(Message &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Message &operator=(Message &&other) noexcept = default; + RUST2_FFI_CALLABLE Message clone() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + RUST2_FFI_CALLABLE ::std::optional<::api::Stamp> stamp_get() const; + RUST2_FFI_CALLABLE void stamp_set(const ::std::optional<::api::Stamp> &value); + RUST2_FFI_CALLABLE ::api::buf payload_get() const; + RUST2_FFI_CALLABLE void payload_set(::api::input value); + static ::api::Message new_(const ::std::optional<::api::Stamp> &stamp, ::api::input payload); + RUST2_FFI_CALLABLE bool sent() const; + }; + class RUST2_FFI_CONSUMABLE Node { + RUST2_FFI_UNCONSUMED Node(Node &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Node &operator=(Node &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + RUST2_FFI_CALLABLE ::std::uint64_t value_get() const; + RUST2_FFI_CALLABLE void value_set(::std::uint64_t value); + static ::api::Node new_(::std::uint64_t value, ::std::optional<::api::Node> next); + RUST2_FFI_CALLABLE void push(::std::uint64_t value); + RUST2_FFI_CALLABLE ::std::uint64_t sum() const; + }; + class RUST2_FFI_CONSUMABLE Tally { + RUST2_FFI_UNCONSUMED Tally(Tally &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Tally &operator=(Tally &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static Tally default_(); + static ::api::Tally new_(); + RUST2_FFI_CALLABLE ::std::uint32_t bump() const; + RUST2_FFI_CALLABLE ::api::Tally_bump_later_future bump_later() const; + }; + class RUST2_FFI_CONSUMABLE Tallies { + RUST2_FFI_UNCONSUMED Tallies(Tallies &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Tallies &operator=(Tallies &&other) noexcept = default; + static Tallies default_(); + static ::api::Tallies new_(); + RUST2_FFI_CALLABLE ::api::Tally first() const; + }; + class RUST2_FFI_CONSUMABLE Gauge { + RUST2_FFI_UNCONSUMED Gauge(Gauge &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Gauge &operator=(Gauge &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Gauge(const Gauge &other) = default; + Gauge &operator=(const Gauge &other) = default; + static ::api::Gauge new_(::std::uint64_t level); + RUST2_FFI_CALLABLE void set(::std::uint64_t level) const; + RUST2_FFI_CALLABLE ::std::uint64_t level() const; + RUST2_FFI_CONSUMES ::std::uint64_t into_level() &&; + RUST2_FFI_CALLABLE ::api::Gauge_later_future later() const; + RUST2_FFI_CALLABLE ::api::Gauge_reaches_future reaches(::std::uint64_t this_) const; + }; + class RUST2_FFI_CONSUMABLE Latch { + RUST2_FFI_UNCONSUMED Latch(Latch &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Latch &operator=(Latch &&other) noexcept = default; + RUST2_FFI_CALLABLE Latch clone() const; + static Latch default_(); + RUST2_FFI_CALLABLE bool set(::std::uint32_t value) const; + RUST2_FFI_CALLABLE ::std::optional<::std::uint32_t> get() const; + }; + class RUST2_FFI_CONSUMABLE Token { + RUST2_FFI_UNCONSUMED Token(Token &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Token &operator=(Token &&other) noexcept = default; + RUST2_FFI_CALLABLE Token clone() const; + RUST2_FFI_CALLABLE ::std::uint32_t id_get() const; + RUST2_FFI_CALLABLE void id_set(::std::uint32_t value); + static ::api::Token new_(::std::uint32_t id); + RUST2_FFI_CALLABLE ::std::vector<::api::Token> twice() const; + }; + class RUST2_FFI_CONSUMABLE Stack { + RUST2_FFI_UNCONSUMED Stack(Stack &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Stack &operator=(Stack &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static Stack default_(); + static ::api::Stack new_(); + RUST2_FFI_CALLABLE void push(::api::Counter item); + RUST2_FFI_CALLABLE ::std::optional<::api::Counter> pop(); + RUST2_FFI_CALLABLE ::std::size_t depth() const; + RUST2_FFI_CALLABLE ::std::uint64_t depth_past_Point(const ::api::Point &from) const; + RUST2_FFI_CALLABLE ::std::uint64_t depth_past_Counter(const ::api::Counter &from) const; + RUST2_FFI_CALLABLE ::std::uint64_t depth_past_Size(const ::api::Size &from) const; + RUST2_FFI_CALLABLE ::std::uint64_t depth_past_Wrap_u32(const ::api::Wrap_u32 &from) const; + }; + class RUST2_FFI_CONSUMABLE Refusal { + RUST2_FFI_UNCONSUMED Refusal(Refusal &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Refusal &operator=(Refusal &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::buf to_string() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + }; + class RUST2_FFI_CONSUMABLE c { + RUST2_FFI_UNCONSUMED c(c &&other RUST2_FFI_MOVED_FROM) noexcept = default; + c &operator=(c &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::c new_(::std::uint8_t value); + }; + class RUST2_FFI_CONSUMABLE Key { + RUST2_FFI_UNCONSUMED Key(Key &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Key &operator=(Key &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Key(const Key &other) = default; + Key &operator=(const Key &other) = default; + RUST2_FFI_CALLABLE ::std::uint64_t hash() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::Key new_(::api::input name); + RUST2_FFI_CALLABLE ::std::uint64_t hash_of() const; + }; + class RUST2_FFI_CONSUMABLE clash_Store { + RUST2_FFI_UNCONSUMED clash_Store(clash_Store &&other RUST2_FFI_MOVED_FROM) noexcept = default; + clash_Store &operator=(clash_Store &&other) noexcept = default; + static ::api::clash_Store new_(::std::uint32_t count); + RUST2_FFI_CALLABLE ::std::uint32_t free_() const; + RUST2_FFI_CALLABLE ::std::uint32_t close() const; + }; + class RUST2_FFI_CONSUMABLE Spawned { + RUST2_FFI_UNCONSUMED Spawned(Spawned &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Spawned &operator=(Spawned &&other) noexcept = default; + template static ::api::Spawned new_(F0 &&task_); + RUST2_FFI_CONSUMES ::std::uint32_t join() &&; + }; + class RUST2_FFI_CONSUMABLE LogThread { + RUST2_FFI_UNCONSUMED LogThread(LogThread &&other RUST2_FFI_MOVED_FROM) noexcept = default; + LogThread &operator=(LogThread &&other) noexcept = default; + static ::api::LogThread new_(::std::unique_ptr<::api::Log> log, ::api::input line); + RUST2_FFI_CONSUMES bool join() &&; + }; + class Log { + virtual ~Log() = default; + virtual bool log(::std::uint8_t level, ::api::view line) const = 0; + }; + class Beat { + virtual ~Beat() = default; + virtual ::std::uint32_t beat() const = 0; + }; + struct Parcel { + ::api::Mark mark; + ::api::buf payload; + }; + class Score { + ::api::buf debug() const; + static ::api::Score of(::std::uint64_t count); + ::std::uint64_t count() const; + void add(const ::api::Score &other); + ::api::Score doubled() const; + ::std::uint64_t take(); + ::std::uint64_t note(const ::api::Mark &mark); + ::std::tuple<::std::uint64_t, ::std::uint64_t> absorb(::api::Score &other); + }; + struct Weighted { + ::api::Score score; + ::std::uint32_t weight; + ::std::uint64_t total() const; + }; + class Stamp { + ::api::buf debug() const; + static ::api::Stamp from_millis(::std::uint64_t millis); + ::std::uint64_t secs() const; + ::api::Stamp whole() const; + bool later(const ::api::Stamp &other) const; + }; + struct Stamped { + ::api::Stamp at; + ::std::uint32_t count; + ::std::uint64_t total() const; + }; + struct CancellationError { + ::std::uint32_t code; + }; + struct Packet { + ::std::uint32_t seq; + ::api::buf payload; + }; + struct Hasher { + ::std::uint8_t seed; + }; + struct Point { + ::std::int32_t x; + ::std::int32_t y; + ::api::buf debug() const; + static Point default_(); + ::api::Point offset(::std::int32_t dx, ::std::int32_t dy) const; + }; + struct Label { + ::api::buf name; + ::std::optional<::api::Point> at; + ::std::optional<::api::duration> ttl; + ::api::buf debug() const; + }; + struct Note { + ::std::optional<::api::buf> text; + ::api::buf debug() const; + static Note default_(); + }; + struct Reading { + bool ok; + float level; + double ratio; + char32_t mark; + ::api::Shape shape; + ::api::Point at; + ::api::buf note; + ::std::uint64_t count; + ::std::int8_t offset; + ::std::size_t len; + ::std::uint16_t tag; + ::api::buf debug() const; + ::std::optional<::api::Reading> next() const; + }; + struct Packaged { + ::std::uint32_t api; + ::api::buf debug() const; + ::api::Point point() const; + ::api::Shape shape() const; + }; + struct Atlas { + ::std::vector<::std::tuple<::api::buf, ::api::Point>> points; + ::std::vector<::std::uint32_t> ids; + ::api::buf debug() const; + ::api::Atlas with(::api::input name, const ::api::Point &at) const; + }; + struct Span { + ::std::tuple<::std::uint32_t, ::std::uint32_t> bounds; + ::std::optional<::std::tuple<::api::buf, ::api::Shape>> named; + ::api::buf debug() const; + }; + struct Window { + ::api::range_u64 range; + ::api::bound_u64 end; + ::api::buf debug() const; + bool contains(::std::uint64_t n) const; + }; + class Ticket { + ::api::buf debug() const; + static ::api::Ticket new_(::std::uint32_t number); + ::std::uint32_t number() const; + static ::std::uint32_t clones(); + }; + struct Seat { + ::api::Mark mark; + ::std::uint32_t row; + ::api::buf debug() const; + ::std::uint64_t count() const; + }; + class Moment { + ::api::buf debug() const; + static ::std::optional<::api::Moment> new_(::std::uint64_t ticks, ::std::uint64_t rate); + ::std::uint64_t millis() const; + ::api::Moment after(::std::uint64_t ticks) const; + }; + class LongArray { + ::api::buf debug() const; + static ::api::LongArray new_(::std::uint64_t low, ::std::uint64_t high); + ::std::uint64_t c__() const; + template void also(F0 &&f) const; + }; + struct JvmField { + ::std::uint32_t n; + ::api::buf debug() const; + }; + struct JvmStatic { + ::std::uint32_t n; + ::api::buf debug() const; + }; + struct OptIn { + ::std::uint32_t n; + ::api::buf debug() const; + }; + class Wide { + ::api::buf debug() const; + static ::api::Wide new_(::std::uint64_t seed); + ::std::uint64_t sum() const; + }; + struct Clocked { + ::api::Moment at; + ::std::uint32_t count; + ::api::buf debug() const; + }; + class Hits { + ::api::buf debug() const; + static Hits default_(); + ::std::uint64_t hits_get() const; + void hits_set(::std::uint64_t value); + ::std::uint64_t misses_get() const; + void misses_set(::std::uint64_t value); + static ::api::Hits of(::std::uint64_t hits, ::std::uint64_t misses); + void add(const ::api::Hits &other); + bool eq_(const ::api::Hits &other); + }; + class Extent { + ::api::buf debug() const; + ::std::uint64_t start_get() const; + void start_set(::std::uint64_t value); + static ::api::Extent new_(::std::uint64_t start, ::std::uint64_t len); + ::std::uint64_t end() const; + ::std::uint64_t slide(::std::uint64_t by); + }; + struct Pair_Size_u8 { + ::api::Size left; + ::std::uint8_t right; + ::api::buf debug() const; + ::api::Pair_u8_Size swap() const; + }; + struct Pair_non_zero_u16 { + ::std::uint16_t left; + ::std::uint16_t right; + ::api::buf debug() const; + ::api::Pair_non_zero_u16 swap() const; + bool even() const; + }; + struct Pair_u32 { + ::std::uint32_t left; + ::std::uint32_t right; + ::api::buf debug() const; + ::api::Pair_u32 swap() const; + bool even() const; + ::std::uint32_t sum() const; + ::api::Pair_u8_Size beside_Size(const ::api::Size &right_) const; + }; + struct Pair_u8_Size { + ::std::uint8_t left; + ::api::Size right; + ::api::buf debug() const; + }; + struct Right_u8 { + ::std::uint8_t value; + ::api::buf debug() const; + }; + struct Left_Right_u8 { + ::api::Right_u8 value; + ::api::buf debug() const; + }; + struct Left_u8 { + ::std::uint8_t value; + ::api::buf debug() const; + }; + struct Right_Left_u8 { + ::api::Left_u8 value; + ::api::buf debug() const; + }; + struct Inner_u8 { + ::std::uint8_t value; + ::api::buf debug() const; + }; + struct Boxed_u16 { + ::std::uint16_t value; + ::api::buf debug() const; + }; + struct Boxed_u8 { + ::std::uint8_t value; + ::api::buf debug() const; + }; + struct LogCount { + ::std::uint32_t kept; + ::api::buf debug() const; + }; + struct Wrap_u32 { + ::std::uint32_t value; + ::api::buf debug() const; + }; + struct PolarTurn { + ::std::uint8_t whole; + ::api::buf debug() const; + }; + struct Peer { + ::api::socket_addr addr; + ::std::vector<::api::buf> names; + ::api::buf debug() const; + ::std::vector<::api::buf> aliases() const; + ::api::Peer next(::api::input name) const; + }; + struct Shadowed { + ::std::vector<::std::int32_t> other; + ::std::uint8_t a; + ::std::uint8_t b; + ::api::buf debug() const; + }; + struct Numbers { + ::std::vector<::std::uint16_t> u16s; + ::std::vector<::std::uint32_t> u32s; + ::std::vector<::std::uint64_t> u64s; + ::std::vector<::std::int8_t> i8s; + ::std::vector<::std::int16_t> i16s; + ::std::vector<::std::int32_t> i32s; + ::std::vector<::std::int64_t> i64s; + ::std::vector f32s; + ::std::vector f64s; + ::std::optional<::std::vector<::std::int32_t>> some; + ::api::buf debug() const; + static ::api::Numbers edges(); + static ::api::Numbers zero(bool negative); + ::api::Numbers reversed() const; + }; + struct Measure { + double value; + ::api::Numbers numbers; + ::api::buf debug() const; + static ::api::Measure new_(double value_, bool negative); + }; + struct Limits_bytes { + ::api::buf low; + ::api::buf high; + ::api::buf debug() const; + }; + struct Limits_duration { + ::api::duration low; + ::api::duration high; + ::api::buf debug() const; + }; + struct Page { + ::std::uint32_t size; + ::api::buf debug() const; + static Page default_(); + }; + struct Booth { + ::api::Mark mark; + ::api::buf debug() const; + }; + struct Cancelled { + ::std::uint8_t step; + ::api::buf debug() const; + }; + struct StartSeekable { + ::std::uint64_t at; + ::api::buf debug() const; + }; + struct DoubleArray { + ::std::uint32_t len; + ::api::buf debug() const; + }; + struct NonZeros { + ::std::uint8_t u8; + ::std::uint16_t u16; + ::std::uint32_t u32; + ::std::uint64_t u64; + ::std::size_t usize; + ::std::int8_t i8; + ::std::int16_t i16; + ::std::int32_t i32; + ::std::int64_t i64; + ::std::ptrdiff_t isize; + ::api::buf debug() const; + }; + struct a { + ::std::uint8_t b; + ::api::buf debug() const; + }; + struct Qualifiers { + double api; + double kotlin; + }; + struct polar_Point { + ::std::uint8_t turns; + ::std::uint32_t distance; + ::api::buf debug() const; + }; + struct polar_Turn { + ::std::uint8_t part; + ::api::buf debug() const; + }; + struct clash_Tone { + ::std::uint16_t hz; + ::api::buf debug() const; + }; + struct clash_TONE { + ::std::uint8_t db; + ::api::buf debug() const; + }; + struct clash_Span { + ::std::uint32_t width; + ::api::buf to_string() const; + ::api::buf debug() const; + ::std::uint32_t width_() const; + ::api::buf to_string_() const; + }; + struct Core { + ::std::uint32_t id; + }; + struct Choice_Empty { + }; + struct Choice_Picked { + ::api::Mark _0; + }; + struct Array_U8x4 { + ::std::uint8_t _0; + }; + struct Platform_Wasm { + ::std::uint32_t bits; + }; + struct Platform_Native { + ::std::uint32_t _0; + }; + struct Placement_Anywhere { + }; + struct Placement_Pinned { + ::api::Core _0; + }; + struct Event_Moved { + ::api::Point _0; + }; + struct Event_Named { + ::api::buf name; + }; + struct Event_Done { + }; + struct Clash_Point { + ::api::Point _0; + }; + struct Clash_Shape { + ::api::Shape _0; + }; + struct Clash_Event { + ::api::Event _0; + }; + struct Clash_Double { + double _0; + }; + struct Clash_Float { + float _0; + }; + struct Clash_String { + ::api::buf _0; + }; + struct Clash_Int { + ::std::int32_t _0; + }; + struct Clash_Boolean { + bool _0; + }; + struct Clash_Native { + ::std::uint32_t _0; + }; + struct Clash_Bytes { + ::api::buf _0; + }; + struct Clash_Any { + }; + struct Clash_Unit { + }; + struct Clash_Waker { + }; + struct Clash_Mut { + }; + struct Clash_Pair { + ::std::uint8_t _0; + ::std::uint8_t _1; + }; + struct Clash_Stamp { + ::std::int64_t _0; + }; + struct Clash_Moment { + ::api::Moment _0; + }; + struct Stage_Init { + ::std::uint32_t _0; + }; + struct Stage_Done { + }; + struct Error_Underflow { + ::std::uint64_t by; + }; + struct Error_Overflow { + }; + struct Labelled_Tagged { + ::std::uint32_t tag; + }; + struct Labelled_Bare { + }; + struct b_One { + }; + struct b_Two { + ::std::uint8_t _0; + }; + struct Builtin_Any { + ::std::vector<::std::int32_t> _0; + }; + struct Builtin_Boolean { + double _0; + }; + struct Builtin_Int { + double _0; + }; + struct Builtin_Native { + double _0; + }; + inline bool operator==(const Stamp &a__, const Stamp &b_); + inline bool operator==(const Point &a__, const Point &b_); + inline bool operator==(const Label &a__, const Label &b_); + inline bool operator==(const Note &a__, const Note &b_); + inline bool operator==(const Reading &a__, const Reading &b_); + inline bool operator==(const Packaged &a__, const Packaged &b_); + inline bool operator==(const Atlas &a__, const Atlas &b_); + inline bool operator==(const Span &a__, const Span &b_); + inline bool operator==(const Window &a__, const Window &b_); + inline bool operator==(const Ticket &a__, const Ticket &b_); + inline bool operator==(const Seat &a__, const Seat &b_); + inline bool operator==(const Moment &a__, const Moment &b_); + inline bool operator==(const LongArray &a__, const LongArray &b_); + inline bool operator==(const JvmField &a__, const JvmField &b_); + inline bool operator==(const JvmStatic &a__, const JvmStatic &b_); + inline bool operator==(const OptIn &a__, const OptIn &b_); + inline bool operator==(const Wide &a__, const Wide &b_); + inline bool operator==(const Clocked &a__, const Clocked &b_); + inline bool operator==(const Hits &a__, const Hits &b_); + inline bool operator==(const Extent &a__, const Extent &b_); + inline bool operator==(const Pair_Size_u8 &a__, const Pair_Size_u8 &b_); + inline bool operator==(const Pair_non_zero_u16 &a__, const Pair_non_zero_u16 &b_); + inline bool operator==(const Pair_u32 &a__, const Pair_u32 &b_); + inline bool operator==(const Pair_u8_Size &a__, const Pair_u8_Size &b_); + inline bool operator==(const Right_u8 &a__, const Right_u8 &b_); + inline bool operator==(const Left_Right_u8 &a__, const Left_Right_u8 &b_); + inline bool operator==(const Left_u8 &a__, const Left_u8 &b_); + inline bool operator==(const Right_Left_u8 &a__, const Right_Left_u8 &b_); + inline bool operator==(const Inner_u8 &a__, const Inner_u8 &b_); + inline bool operator==(const Boxed_u16 &a__, const Boxed_u16 &b_); + inline bool operator==(const Boxed_u8 &a__, const Boxed_u8 &b_); + inline bool operator==(const LogCount &a__, const LogCount &b_); + inline bool operator==(const Wrap_u32 &a__, const Wrap_u32 &b_); + inline bool operator==(const PolarTurn &a__, const PolarTurn &b_); + inline bool operator==(const Peer &a__, const Peer &b_); + inline bool operator==(const Shadowed &a__, const Shadowed &b_); + inline bool operator==(const Numbers &a__, const Numbers &b_); + inline bool operator==(const Measure &a__, const Measure &b_); + inline bool operator==(const Limits_bytes &a__, const Limits_bytes &b_); + inline bool operator==(const Limits_duration &a__, const Limits_duration &b_); + inline bool operator==(const Page &a__, const Page &b_); + inline bool operator==(const Booth &a__, const Booth &b_); + inline bool operator==(const Cancelled &a__, const Cancelled &b_); + inline bool operator==(const StartSeekable &a__, const StartSeekable &b_); + inline bool operator==(const DoubleArray &a__, const DoubleArray &b_); + inline bool operator==(const a &a__, const a &b_); + inline bool operator==(const Qualifiers &a__, const Qualifiers &b_); + inline bool operator==(const polar_Point &a__, const polar_Point &b_); + inline bool operator==(const polar_Turn &a__, const polar_Turn &b_); + inline bool operator==(const clash_Tone &a__, const clash_Tone &b_); + inline bool operator==(const clash_TONE &a__, const clash_TONE &b_); + inline bool operator==(const clash_Span &a__, const clash_Span &b_); + inline bool operator==(::api::Shape a__, ::api::Shape b_); + inline bool operator!=(::api::Shape a__, ::api::Shape b_); + inline ::api::buf Shape_debug(::api::Shape self); + inline ::std::vector<::api::Shape> Shape_ALL(); + inline ::std::vector<::api::Shape> Shape_BOTH(); + inline bool operator==(const ::api::Event &a__, const ::api::Event &b_); + inline bool operator!=(const ::api::Event &a__, const ::api::Event &b_); + inline ::api::buf Event_debug(const ::api::Event &self); + inline bool operator==(const ::api::Clash &a__, const ::api::Clash &b_); + inline bool operator!=(const ::api::Clash &a__, const ::api::Clash &b_); + inline ::api::buf Clash_debug(const ::api::Clash &self); + inline ::std::optional<::api::Point> Clash_point(const ::api::Clash &self); + inline ::api::Clash Clash_of(double value); + inline ::api::buf Clash_bytes(const ::api::Clash &self); + inline ::api::Reading Clash_reading(const ::api::Clash &self, ::std::uint32_t kotlin); + inline ::std::vector<::std::vector<::std::uint32_t>> Clash_listed(const ::std::vector<::std::uint32_t> &java, ::std::uint32_t &kotlin); + template inline ::api::Clash_after_future Clash_after(F0 first, double kotlin); + inline ::api::buf Clash_joined(const ::api::Clash &self, ::api::input lent, ::api::input owned, ::std::optional<::api::input> maybe); + inline ::api::Clash_tagged_future Clash_tagged(const ::api::Clash &self, ::api::input tag); + inline ::api::Stamp Clash_stamp(const ::api::Clash &self, ::std::uint64_t kotlin); + inline ::api::Moment Clash_moment(const ::api::Clash &self, ::std::uint64_t kotlin); + inline ::api::Clash Clash_at(const ::api::Point &api); + inline ::api::buf Clash_describe(const ::api::Clash &self, ::api::input text, ::std::uint32_t n, ::api::Shape shape, ::std::uint32_t &out); + inline bool operator==(const ::api::Stage &a__, const ::api::Stage &b_); + inline bool operator!=(const ::api::Stage &a__, const ::api::Stage &b_); + inline ::api::buf Stage_debug(const ::api::Stage &self); + inline bool operator==(const ::api::Error &a__, const ::api::Error &b_); + inline bool operator!=(const ::api::Error &a__, const ::api::Error &b_); + inline ::api::buf Error_to_string(const ::api::Error &self); + inline ::api::buf Error_debug(const ::api::Error &self); + inline bool operator==(::api::Status_ a__, ::api::Status_ b_); + inline bool operator!=(::api::Status_ a__, ::api::Status_ b_); + inline ::api::buf Status__debug(::api::Status_ self); + inline bool operator==(const ::api::Labelled &a__, const ::api::Labelled &b_); + inline bool operator!=(const ::api::Labelled &a__, const ::api::Labelled &b_); + inline ::api::buf Labelled_debug(const ::api::Labelled &self); + inline bool operator==(::api::Family a__, ::api::Family b_); + inline bool operator!=(::api::Family a__, ::api::Family b_); + inline ::api::buf Family_debug(::api::Family self); + inline bool operator==(::api::VecClashTone a__, ::api::VecClashTone b_); + inline bool operator!=(::api::VecClashTone a__, ::api::VecClashTone b_); + inline ::api::buf VecClashTone_debug(::api::VecClashTone self); + inline bool operator==(const ::api::b &a__, const ::api::b &b_); + inline bool operator!=(const ::api::b &a__, const ::api::b &b_); + inline ::api::buf b_debug(const ::api::b &self); + inline bool operator==(const ::api::Builtin &a__, const ::api::Builtin &b_); + inline bool operator!=(const ::api::Builtin &a__, const ::api::Builtin &b_); + inline bool has_text(const ::api::Note ¬e); + inline ::std::uint64_t marked(const ::api::Mark &api_marked); + inline ::std::optional<::api::Reading> reading(::std::uint32_t n); + inline ::api::buf reading_debug(::std::uint32_t n); + inline ::std::optional<::api::Reading> reading_echo(const ::std::optional<::api::Reading> &reading); + inline void reading_bump(::std::optional<::api::Reading> &reading); + inline ::api::Stage advance(const ::api::Stage &stage); + inline ::std::tuple<::api::Counter> only(::api::Counter counter); + inline ::std::tuple<::std::uint8_t, ::std::int16_t, ::std::uint32_t, ::std::uint64_t> widths(::std::uint64_t n); + inline ::api::result<::std::tuple<::std::uint64_t, ::std::uint64_t>, ::api::Error> divide(::std::uint64_t a__, ::std::uint64_t b_); + inline ::api::result<::std::tuple<::std::uint32_t, ::std::uint32_t>, ::api::Error> corner(bool unit); + inline ::api::corner_later_future corner_later(); + inline ::std::optional<::std::tuple<::std::uint8_t, ::std::int16_t, ::std::uint32_t, ::std::uint64_t>> spread(::std::uint64_t n); + inline ::std::optional<::std::tuple<::std::size_t, ::std::size_t>> find(::api::input haystack, ::api::input needle); + inline ::std::vector<::std::tuple<::api::buf, ::api::Shape, ::api::Point>> rows(const ::std::vector<::api::Point> &points); + inline ::api::result<::std::uint16_t, ::api::buf> port(::api::input text); + inline ::std::uint32_t span(::std::uint32_t start, ::std::uint32_t end); + inline ::std::tuple<::std::tuple<::std::uint32_t, ::std::uint32_t>, ::std::tuple<::std::uint32_t, ::std::uint32_t>> halves(const ::api::Span &span); + inline ::std::optional<::std::tuple<::std::optional<::std::uint32_t>>> doubled(const ::std::optional<::std::tuple<::std::optional<::std::uint32_t>>> &value); + inline ::std::optional<::std::tuple<::api::buf>> title(bool formal); + inline ::std::optional<::std::tuple<::api::buf>> named(::api::input name); + inline ::std::tuple<::api::buf> lent_back(const ::std::tuple<::api::view> &value); + inline ::std::tuple<::api::buf> boxed_tuple(::api::input bytes); + inline ::std::tuple<::std::uint32_t, ::api::buf> swapped(const ::std::tuple<::api::view, ::std::uint32_t> &pair); + inline bool lasting(const ::api::Draft &draft); + inline ::std::uint32_t stored(::api::Receipt receipt); + inline ::std::uint32_t tallied(::api::Receipt receipt); + inline ::std::uint32_t summed_up_Receipt(::api::Receipt totaled); + inline ::std::uint32_t erased(::api::Receipt receipt); + inline ::api::Name longer(::api::Name a__, const ::api::Name &b_); + inline ::api::Name unnamed(); + inline ::std::uint64_t total(const ::api::range_u64 &range); + inline ::std::uint32_t reach(::std::uint32_t start, ::std::uint32_t end); + inline ::std::optional<::api::u128> scaled(::api::u128 v, ::std::uint64_t by); + inline ::api::Batch_2 pair(); + inline ::std::uint64_t drain_4(::api::Batch &batch); + inline ::std::uint64_t drain_2(::api::Batch_2 &batch); + inline ::std::size_t capacities_4_4(const ::api::Batch &a__, const ::api::Batch &b_); + inline ::std::size_t capacities_4_2(const ::api::Batch &a__, const ::api::Batch_2 &b_); + inline ::std::size_t capacities_2_4(const ::api::Batch_2 &a__, const ::api::Batch &b_); + inline ::std::size_t capacities_2_2(const ::api::Batch_2 &a__, const ::api::Batch_2 &b_); + inline ::api::fill_4_future fill_4(::api::Batch &batch, ::std::uint32_t v); + inline ::api::fill_2_future fill_2(::api::Batch_2 &batch, ::std::uint32_t v); + inline ::api::range_u64 widen(const ::api::range_u64 &range, ::std::uint64_t by); + inline ::std::size_t count(const ::api::bounds_u64 &range); + inline ::api::bound_u64 end(::std::uint64_t limit); + inline ::std::tuple<::api::bound_u64, ::api::bound_u64> ends(::std::uint64_t limit); + inline ::api::result<::std::uint64_t, ::api::bounds_u64> below(::std::uint64_t n, ::std::uint64_t limit); + template inline ::api::drive_future drive(const ::api::Moment &start, F0 &&poll); + template inline ::api::buf made(::std::uint32_t n, F0 &&make); + inline ::std::vector<::std::tuple<::api::buf, ::api::Ticket>> tickets(const ::api::items<::std::tuple<::api::view, ::api::Ticket>> &entries); + template inline ::api::Ticket reissue(const ::api::Ticket &ticket, F0 &&swap); + template inline ::api::Ticket reissue_lent(const ::api::Ticket &ticket, F0 &&swap); + inline ::api::Seat seat(const ::api::Mark &mark, ::std::uint32_t row); + inline ::std::uint64_t admit(::std::tuple<::api::Counter, ::api::Mark, ::api::Seat, ::api::Choice> entry); + inline ::std::uint64_t choose(const ::api::Choice &choice); + inline ::std::uint64_t heft(const ::std::tuple<::api::Mark, ::api::view> &marked, const ::api::Parcel &lent, ::std::tuple<::api::Counter, ::api::view> moved); + inline ::api::result<::std::uint64_t, ::api::buf> spend(::api::Counter e, ::api::Counter it); + inline bool is_kept(::api::Status_ status); + template inline ::api::result attempt(F0 &&check); + template inline ::api::result<::std::tuple<::api::buf, ::std::uint64_t>, ::api::buf> tail(F0 &file, ::std::uint64_t len); + template inline ::api::result<::std::uint64_t, ::api::buf> seek_to(F0 &file, ::std::uint64_t at); + inline ::api::halved_future halved(::std::uint32_t n); + inline ::api::yielded_future yielded(::std::uint32_t value); + template inline ::api::after_future after(F0 first, ::std::uint32_t value); + template inline ::api::within_future within(::std::uint32_t polls, F0 future_); + inline ::api::result<::api::Moment, ::api::buf> moment_at(::std::uint64_t ticks, ::std::uint64_t rate); + inline ::api::result<::api::Stamp, ::api::buf> stamp_at(::std::uint64_t millis); + template inline ::api::Moment shifted(const ::api::Moment &moment, F0 &&shift); + inline ::std::uint32_t jvm_sum(const ::api::JvmField &field, const ::api::JvmStatic &method, const ::api::OptIn &opt); + inline ::api::Clocked clocked_after(const ::api::Clocked &clocked, ::std::uint64_t ticks); + inline ::std::uint32_t emit(::std::unique_ptr<::api::Log> log, ::api::input lines); + template inline ::api::counted_future counted(::std::uint32_t n, F0 &&count); + template inline ::std::uint32_t filter(::api::input lines, F0 &&keep); + inline ::api::log_later_future log_later(::std::unique_ptr<::api::Log> log); + inline ::std::uint32_t log_counts(::std::unique_ptr<::api::Log> log, ::std::uint8_t level, const ::api::Counter &counter, ::std::vector<::api::Counter> more); + inline bool on_first_thread(); + inline ::std::uint32_t locals_dropped(); + inline ::api::Local local_or_new(const ::api::Local *local); + inline ::api::local_or_new_later_future local_or_new_later(const ::api::Local *local); + inline ::std::uint32_t bump_either(const ::api::Local *first, const ::api::Local &second); + inline ::api::local_after_future local_after(); + inline ::api::local_later_future local_later(::std::uint32_t n); + inline ::api::poll_tripled_future poll_tripled(::std::uint32_t n); + template inline ::std::uint64_t watch(const ::api::Gauge &gauge, F0 &&watch); + inline ::api::buf token_bytes(::std::uint32_t id, ::std::uint32_t len); + inline ::api::buf token_slice(::std::uint32_t id, ::std::uint32_t len, ::std::uint32_t of); + inline ::api::Packet next_packet(const ::api::Packet &packet); + inline ::api::result<::std::array<::std::uint8_t, 4>, ::api::buf> fingerprint(::api::input hex); + inline ::std::uint32_t dropped(); + inline ::std::uint32_t bump_both(const ::api::Tally &a__, const ::api::Tally &b_); + template inline ::std::uint32_t offset(F0 &&by, ::std::uint32_t by_data); + template inline ::std::uint32_t shift(F0 &&by_, ::std::uint32_t c_by__); + template inline ::std::uint64_t walk(::std::uint64_t steps, F0 &&visit); + template inline ::std::uint32_t each(::std::uint32_t steps, F0 &&visit); + template inline ::std::uint32_t peek(const ::api::Tally &tally, F0 &&peek); + inline ::std::size_t len(::api::input payload); + inline ::api::buf hex(::api::input payload); + inline ::api::buf timed_hex(::api::input payload); + inline ::api::buf timed_text(const ::api::Json &value); + inline ::api::buf sample_hex(::api::input sample); + inline ::api::buf queued_hex(::api::input queued); + inline ::api::buf tick_name(const ::api::Label &tick); + inline ::api::buf rooted_name(const ::api::Label &rooted); + inline ::api::buf stored_text(::api::input stored); + inline ::api::buf layer_name(const ::api::Label &layer); + inline ::api::buf greet(::api::input name, ::api::Shape shape); + inline ::api::buf describe(const ::api::Event &event); + inline ::api::Pair_Size_u8 tag(const ::api::Size &size, ::std::uint8_t tag); + inline ::std::uint8_t cross(const ::api::Left_Right_u8 &left, const ::api::Right_Left_u8 &right); + inline ::std::uint64_t kept_Point(const ::api::Point &from); + inline ::std::uint64_t kept_Counter(::api::Counter from); + inline ::std::uint64_t kept_Size(const ::api::Size &from); + inline ::std::uint64_t kept_Wrap_u32(const ::api::Wrap_u32 &from); + inline ::std::uint64_t kept_polar_Point(const ::api::polar_Point &from); + inline ::std::int32_t keep_Point(const ::api::Point &kept); + inline ::std::int32_t kept_or_Point(const ::std::optional<::api::Point> &kept); + inline ::std::int32_t keeper_Point(const ::api::Point &keeper); + inline ::api::Boxed_u16 BOXED(); + inline ::api::Boxed_u8 keeps(::std::unique_ptr<::api::Log> log); + inline ::std::uint32_t weigh_Point(const ::api::Point &from); + template inline ::std::uint32_t apply_non_zero_u16(const ::api::Pair_non_zero_u16 &pair, F0 &&f); + template inline ::std::uint32_t apply_u32(const ::api::Pair_u32 &pair, F0 &&f); + inline ::std::uint32_t report_non_zero_u16(const ::api::Pair_non_zero_u16 &pair, ::std::unique_ptr<::api::Log> log); + inline ::std::uint32_t report_u32(const ::api::Pair_u32 &pair, ::std::unique_ptr<::api::Log> log); + inline ::std::uint32_t tally_LogCount(::std::unique_ptr<::api::Log> log); + inline ::std::uint32_t wind(const ::api::PolarTurn &whole, const ::api::polar_Turn &part); + inline ::std::uint64_t area(const ::api::Size &size); + inline ::std::uint64_t seeds_Point_Point(const ::api::Point &from); + inline ::std::uint64_t seeds_Point_Counter(const ::api::Counter &from); + inline ::std::uint64_t seeds_Point_Size(const ::api::Size &from); + inline ::std::uint64_t seeds_Point_Wrap_u32(const ::api::Wrap_u32 &from); + inline ::std::uint64_t seeds_Point_polar_Point(const ::api::polar_Point &from); + inline ::std::uint64_t seeds_Counter_Point(const ::api::Point &from); + inline ::std::uint64_t seeds_Counter_Counter(const ::api::Counter &from); + inline ::std::uint64_t seeds_Counter_Size(const ::api::Size &from); + inline ::std::uint64_t seeds_Counter_Wrap_u32(const ::api::Wrap_u32 &from); + inline ::std::uint64_t seeds_Counter_polar_Point(const ::api::polar_Point &from); + inline ::api::Area grow(const ::api::Area &area, ::std::uint32_t by); + inline ::api::Slot_u32 wide(::std::uint32_t value); + inline ::std::optional<::api::buf> host(const ::api::Url &url); + inline ::api::result<::api::Url, ::api::buf> resolve(::api::Url base, ::api::input path); + inline ::std::vector<::std::uint16_t> ports(const ::std::vector<::api::socket_addr> &addrs); + inline ::api::duration doubled_ttl(::api::duration ttl); + inline ::api::buf file(::api::input dir, ::api::input name); + inline ::api::buf stray(); + template inline void visit_stray(F0 &&visit); + inline ::std::optional next_char(char32_t c_); + inline ::std::optional<::api::duration> extended(::api::duration duration_, ::api::duration by); + inline ::std::vector<::std::optional<::api::buf>> parents(const ::api::items<::api::view> &paths); + inline ::std::vector<::api::buf> words(::api::input text); + inline ::api::buf sentence(const ::std::optional<::api::items<::api::view>> &words); + inline void put_number(::std::uint32_t value, ::api::buf &buf_); + inline ::api::duration second_later(::api::duration w235); + inline ::api::result<::std::uint8_t, ::api::Error> digit(::api::buf &r); + inline ::std::uint32_t push_counted(::std::tuple<::api::buf, ::std::uint32_t> &entry, ::std::uint8_t byte); + inline void nudge(::api::Point &point, ::std::int32_t by); + inline void nudge_by(::api::Point &point, const ::api::Refusal &refusal); + inline ::api::tls_Config secure(::api::input alpn); + inline ::api::buf alpn(::api::tls_Config config); + inline ::api::buf alpn_lent(const ::api::tls_Config &config); + inline ::api::tls_Cert certify(::api::input der); + inline ::api::byte_len_future byte_len(::api::input bytes); + inline ::std::size_t cert_len(const ::api::tls_Cert &cert); + inline ::api::buf cert_der(::api::tls_Cert cert); + inline ::std::size_t chain_len(::std::vector<::api::tls_Cert> chain); + inline ::api::result<::std::uint32_t, ::api::buf> verify(const ::api::tls_Cert &cert); + inline ::api::result<::std::uint32_t, ::api::buf> parse_cert(::api::input text); + inline ::api::parse_later_future parse_later(::api::input text); + inline ::api::tls_Resolver resolver(::api::input name); + inline ::api::buf resolved(::api::tls_Resolver resolver); + inline ::api::std_io_Error failure(::api::input message); + inline ::api::buf failure_message(const ::api::std_io_Error &error); + inline ::api::buf failure_kind(::api::std_io_Error error); + inline ::std::uint32_t sum_all(const ::std::vector<::std::uint32_t> &items_); + inline ::std::uint64_t weigh_all_Counter(::std::vector<::api::Counter> items_); + inline ::std::size_t offered_len(const ::api::items<::api::view> &alpns); + inline ::api::buf join_words(const ::api::items<::api::view> &words); + inline ::api::result<::api::tls_Session, ::api::buf> resume(::api::input alpn, ::std::uint32_t seconds); + inline ::std::size_t either(::std::optional<::api::input> text); + inline ::api::either_later_future either_later(::std::optional<::api::input> text); + inline ::api::buf prefixed(::api::input payload, ::std::optional<::api::input> prefix); + inline ::std::int32_t sum_lists(const ::std::vector<::std::int32_t> &a__, const ::std::optional<::std::vector<::std::int32_t>> &b_, const ::std::optional<::std::vector<::std::int32_t>> &c_); + inline ::std::int32_t coordinates(const ::std::optional<::api::Point> &point); + inline ::std::vector<::api::buf> chunks(::api::input bytes, ::std::size_t size); + inline ::std::vector<::api::Counter> counters(const ::api::items<::api::view> &names); + inline ::std::uint64_t worth(::std::optional<::std::vector<::api::Counter>> some, ::std::vector<::api::Counter> boxed); + inline ::std::optional<::std::uint64_t> held_count(::std::optional<::std::tuple<::api::Counter>> held); + inline ::std::optional<::api::Counter> boxed_counter(::std::optional<::api::input> name); + inline ::std::optional<::api::buf> boxed_name(::std::optional<::api::Counter> boxed); + inline ::std::uint32_t less(::std::uint32_t value, ::std::uint32_t _value); + inline ::std::vector<::std::uint32_t> sums(const ::std::vector<::std::vector<::std::uint32_t>> &rows); + inline ::std::vector<::std::vector<::std::uint32_t>> least(const ::std::vector<::std::vector<::std::uint32_t>> &sets); + inline ::std::tuple<::std::vector<::std::int32_t>, ::std::uint32_t> split_last(const ::std::vector<::std::int32_t> &items_); + inline ::std::uint64_t sum_u32(const ::std::vector<::std::uint32_t> &items_); + inline ::std::vector<::std::int64_t> doubled_i64(const ::std::vector<::std::int64_t> &items_); + inline ::std::vector boxed_floats(const ::std::vector &items_); + inline ::api::Point summed(const ::std::vector<::api::Point> &points); + inline ::api::duration breadth(const ::api::Limits_duration &limits); + inline ::api::Limits_bytes byte_limits(::api::input low, ::api::input high); + inline ::api::buf joined(const ::api::items<::api::view> &parts); + inline ::std::optional<::api::buf> first_of(const ::api::items<::api::view> &items_); + inline ::std::uint64_t read_len(::api::input reader); + inline ::std::size_t longest(const ::api::items<::api::view> &words); + inline ::api::buf encode(const ::api::Json &value); + inline ::api::Json tagged(::api::Json doc, ::api::input tag); + inline ::std::vector<::std::tuple<::api::buf, ::api::Json>> entries(::api::taken<::std::tuple<::api::view, ::api::Json>> entries, ::api::input tag); + inline ::std::vector<::std::tuple<::api::buf, ::api::Json>> sections(::api::taken<::std::tuple<::api::view, ::api::Json>> entries); + inline ::api::Instant now(); + inline ::api::Instant later(const ::api::Instant &at, ::api::duration by); + inline ::api::duration since(const ::api::Instant &later, const ::api::Instant &earlier); + inline bool has_instant(const ::api::Instant *at); + inline ::std::optional<::api::Level> louder(const ::std::optional<::api::Level> &filter); + inline ::api::buf spell(const ::std::optional<::api::Level> &filter); + inline ::std::vector<::api::buf> GREETINGS(); + inline ::std::vector<::std::uint32_t> PRIMES(); + inline ::std::vector<::api::Counter> numbered(const ::api::items<::api::view> &names); + inline ::std::tuple<::api::socket_addr_v4, ::api::socket_addr_v6> nexts(::api::socket_addr_v4 v4, ::api::socket_addr_v6 v6); + inline ::std::tuple<::api::ipv4_addr, ::api::ipv6_addr> next_ips(::api::ipv4_addr v4, ::api::ipv6_addr v6); + inline ::api::ip_addr flip(::api::ip_addr ip); + inline ::api::buf reasons(::std::vector<::std::tuple<::api::Counter, ::api::Refusal>> pairs, ::std::optional<::std::tuple<::api::Counter, ::api::Refusal>> last); + inline ::std::size_t excuse(::api::input note, ::std::tuple<::api::view, ::api::Refusal> entry); + inline ::std::uint32_t relay(::std::unique_ptr<::api::Log> log, ::std::vector<::api::Refusal> refusals); + inline ::api::result<::std::uint32_t, ::api::Refusal> refuse(::api::input reason); + inline ::api::Platform platform(); + inline ::std::uint32_t pointer_bits(const ::api::Platform &platform); + inline ::api::Labelled same_labelled(const ::api::Labelled &labelled); + inline ::api::Placement placement(); + inline bool is_family(::api::Family family); + inline ::std::uint32_t wasm_only(); + inline ::api::result<::std::uint64_t, ::api::Error> wasm_take(::api::Counter counter); + inline void wasm_log(::std::unique_ptr<::api::Log> log); + inline ::std::uint64_t booth_count(const ::api::Booth &booth); + inline ::api::Page page(); + inline ::std::uint32_t beats(::std::unique_ptr<::api::Beat> beat); + inline ::std::int32_t same(double a__, double b_); + inline ::api::result<::std::tuple<::api::buf, ::std::optional<::std::tuple<::std::uint8_t, ::std::int16_t, ::std::uint32_t, ::std::uint64_t>>, ::std::vector<::api::buf>>, ::api::Error> return_values(::api::Point &point, bool fail); + inline ::api::result<::api::Counter, ::api::Error> return_moved(::api::Counter counter, bool fail); + inline ::api::NonZeros non_zeros(); + inline ::api::buf describe_non_zeros(const ::api::NonZeros &non_zeros); + inline ::std::optional<::std::uint64_t> next_hop(const ::std::optional<::std::uint64_t> &hop); + inline ::std::uint16_t farther_hop(const ::api::Pair_non_zero_u16 &hops); + inline ::api::duration same_duration(::api::duration v); + inline ::std::uint64_t same_u64(::std::uint64_t v); + inline ::std::size_t same_usize(::std::size_t v); + inline ::std::ptrdiff_t same_isize(::std::ptrdiff_t v); + inline ::api::u128 same_u128(::api::u128 v); + inline char32_t same_char(char32_t v); + inline ::api::buf same_string(::api::input v); + inline ::api::buf same_path(::api::input v); + inline ::api::socket_addr same_socket_addr(::api::socket_addr v); + inline ::api::socket_addr_v4 same_socket_addr_v4(::api::socket_addr_v4 v); + inline ::api::socket_addr_v6 same_socket_addr_v6(::api::socket_addr_v6 v); + inline ::api::ip_addr same_ip_addr(::api::ip_addr v); + inline ::std::uint64_t crowded(const ::api::Reading &reading, const ::api::Stamp &a__, const ::api::Stamp &b_, ::std::uint64_t n0, ::std::uint64_t n1, ::std::uint64_t n2, ::std::uint64_t n3, ::std::uint64_t n4, ::std::uint64_t n5, ::std::uint64_t n6, ::std::uint64_t n7, ::std::uint64_t n8, ::std::uint64_t n9, ::std::uint64_t n10, ::std::uint64_t n11, ::std::uint64_t n12, ::std::uint64_t n13, ::std::uint64_t n14, ::std::uint64_t n15, ::std::uint64_t n16, ::std::uint64_t n17, ::std::uint64_t n18, ::std::uint64_t n19, ::std::uint64_t n20, ::std::uint64_t n21, ::std::uint64_t n22, ::std::uint64_t n23, ::std::uint64_t n24, ::std::uint64_t n25, ::std::uint64_t n26, ::std::uint64_t n27, ::std::uint64_t n28, ::std::uint64_t n29, ::std::uint64_t n30, ::std::uint64_t n31, ::std::uint64_t n32, ::std::uint64_t n33, ::std::uint64_t n34, ::std::uint64_t n35, ::std::uint64_t n36, ::std::uint64_t n37, ::std::uint64_t n38, ::std::uint64_t n39, ::std::uint64_t n40, ::std::uint64_t n41, ::std::uint64_t n42, ::std::uint64_t n43, ::std::uint64_t n44, ::std::uint64_t n45, ::std::uint64_t n46, ::std::uint64_t n47, ::std::uint64_t n48, ::std::uint64_t n49, ::std::uint64_t n50, ::std::uint64_t n51, ::std::uint64_t n52, ::std::uint64_t n53, ::std::uint64_t n54, ::std::uint64_t n55, ::std::uint64_t n56, ::std::uint64_t n57, ::std::uint64_t n58, ::std::uint64_t n59, ::std::uint64_t n60, ::std::uint64_t n61, ::std::uint64_t n62, ::std::uint64_t n63, ::std::uint64_t n64, ::std::uint64_t n65, ::std::uint64_t n66, ::std::uint64_t n67, ::std::uint64_t n68, ::std::uint64_t n69, ::std::uint64_t n70, ::std::uint64_t n71, ::std::uint64_t n72, ::std::uint64_t n73, ::std::uint64_t n74, ::std::uint64_t n75, ::std::uint64_t n76, ::std::uint64_t n77, ::std::uint64_t n78, ::std::uint64_t n79, ::std::uint64_t n80, ::std::uint64_t n81, ::std::uint64_t n82, ::std::uint64_t n83, ::std::uint64_t n84, ::std::uint64_t n85, ::std::uint64_t n86, ::std::uint64_t n87, ::std::uint64_t n88, ::std::uint64_t n89, ::std::uint64_t n90, ::std::uint64_t n91, ::std::uint64_t n92, ::std::uint64_t n93, ::std::uint64_t n94, ::std::uint64_t n95, ::std::uint64_t n96, ::std::uint64_t n97, ::std::uint64_t n98, ::std::uint64_t n99, ::std::uint64_t n100, ::std::uint64_t n101, ::std::uint64_t n102, ::std::uint64_t n103, ::std::uint64_t n104, ::std::uint64_t n105, ::std::uint64_t n106, ::std::uint64_t n107, ::std::uint64_t n108, ::std::uint64_t n109, ::std::uint64_t n110, ::std::uint64_t n111, ::std::uint64_t n112, ::std::uint64_t n113, ::std::uint64_t n114, ::std::uint64_t n115, ::std::uint64_t n116, ::std::uint64_t n117, ::std::uint64_t n118); + inline ::std::uint64_t crammed(const ::api::Moment &a__, const ::api::Moment &b_, ::std::uint64_t n0, ::std::uint64_t n1, ::std::uint64_t n2, ::std::uint64_t n3, ::std::uint64_t n4, ::std::uint64_t n5, ::std::uint64_t n6, ::std::uint64_t n7, ::std::uint64_t n8, ::std::uint64_t n9, ::std::uint64_t n10, ::std::uint64_t n11, ::std::uint64_t n12, ::std::uint64_t n13, ::std::uint64_t n14, ::std::uint64_t n15, ::std::uint64_t n16, ::std::uint64_t n17, ::std::uint64_t n18, ::std::uint64_t n19, ::std::uint64_t n20, ::std::uint64_t n21, ::std::uint64_t n22, ::std::uint64_t n23, ::std::uint64_t n24, ::std::uint64_t n25, ::std::uint64_t n26, ::std::uint64_t n27, ::std::uint64_t n28, ::std::uint64_t n29, ::std::uint64_t n30, ::std::uint64_t n31, ::std::uint64_t n32, ::std::uint64_t n33, ::std::uint64_t n34, ::std::uint64_t n35, ::std::uint64_t n36, ::std::uint64_t n37, ::std::uint64_t n38, ::std::uint64_t n39, ::std::uint64_t n40, ::std::uint64_t n41, ::std::uint64_t n42, ::std::uint64_t n43, ::std::uint64_t n44, ::std::uint64_t n45, ::std::uint64_t n46, ::std::uint64_t n47, ::std::uint64_t n48, ::std::uint64_t n49, ::std::uint64_t n50, ::std::uint64_t n51, ::std::uint64_t n52, ::std::uint64_t n53, ::std::uint64_t n54, ::std::uint64_t n55, ::std::uint64_t n56, ::std::uint64_t n57, ::std::uint64_t n58, ::std::uint64_t n59, ::std::uint64_t n60, ::std::uint64_t n61, ::std::uint64_t n62, ::std::uint64_t n63, ::std::uint64_t n64, ::std::uint64_t n65, ::std::uint64_t n66, ::std::uint64_t n67, ::std::uint64_t n68, ::std::uint64_t n69, ::std::uint64_t n70, ::std::uint64_t n71, ::std::uint64_t n72, ::std::uint64_t n73, ::std::uint64_t n74, ::std::uint64_t n75, ::std::uint64_t n76, ::std::uint64_t n77, ::std::uint64_t n78, ::std::uint64_t n79, ::std::uint64_t n80, ::std::uint64_t n81, ::std::uint64_t n82, ::std::uint64_t n83, ::std::uint64_t n84, ::std::uint64_t n85, ::std::uint64_t n86, ::std::uint64_t n87, ::std::uint64_t n88, ::std::uint64_t n89, ::std::uint64_t n90, ::std::uint64_t n91, ::std::uint64_t n92, ::std::uint64_t n93, ::std::uint64_t n94, ::std::uint64_t n95, ::std::uint64_t n96, ::std::uint64_t n97, ::std::uint64_t n98, ::std::uint64_t n99, ::std::uint64_t n100, ::std::uint64_t n101, ::std::uint64_t n102, ::std::uint64_t n103, ::std::uint64_t n104, ::std::uint64_t n105, ::std::uint64_t n106, ::std::uint64_t n107, ::std::uint64_t n108, ::std::uint64_t n109, ::std::uint64_t n110, ::std::uint64_t n111, ::std::uint64_t n112, ::std::uint64_t n113, ::std::uint64_t n114, ::std::uint64_t n115, ::std::uint64_t n116, ::std::uint64_t n117, ::std::uint64_t n118, ::std::uint64_t n119, ::std::uint64_t n120, ::std::uint64_t n121, ::std::uint64_t n122, ::std::uint64_t n123); + inline ::std::uint32_t jni_one(); + inline ::std::optional<::api::polar_Point> polar_point(::std::uint32_t distance); + inline ::api::result<::api::clash_Tone, ::std::vector<::api::clash_Tone>> clash_audible(const ::api::clash_Tone &tone); + inline ::std::uint32_t clash_nested(const ::std::optional<::std::tuple<::std::tuple<::std::uint8_t, ::std::uint16_t>, ::std::uint32_t>> &a__, const ::std::optional<::std::tuple<::std::tuple<::std::uint8_t, ::std::uint16_t, ::std::uint32_t>>> &b_); + inline ::std::uint8_t clash_audio_encoder_finish(); + inline ::std::uint8_t clash_audio_encoder_finish_(); + inline ::std::uint32_t emit_from_thread(::std::unique_ptr<::api::Log> log, ::api::input lines); + inline ::api::emit_later_future emit_later(::std::unique_ptr<::api::Log> log, ::api::input lines); + inline ::api::log_on_drop_future log_on_drop(::std::unique_ptr<::api::Log> log); + inline ::api::waker log_waker(::std::unique_ptr<::api::Log> log); +} +namespace std { + template <> struct hash<::api::Local> { + size_t operator()(const ::api::Local &value) const noexcept; + }; +} +namespace std { + template <> struct hash<::api::Key> { + size_t operator()(const ::api::Key &value) const noexcept; + }; +} +#endif + +// core.hpp +#ifndef API_HPP_CRATE0 +#define API_HPP_CRATE0 +#include "rt.hpp" +namespace api { + class RUST2_FFI_CONSUMABLE std_io_Error { + RUST2_FFI_UNCONSUMED std_io_Error(std_io_Error &&other RUST2_FFI_MOVED_FROM) noexcept = default; + std_io_Error &operator=(std_io_Error &&other) noexcept = default; + }; +} +#endif + +// dep.hpp +#ifndef API_HPP_CRATE2 +#define API_HPP_CRATE2 +#include "rt.hpp" +namespace api { + class RUST2_FFI_CONSUMABLE Area { + RUST2_FFI_UNCONSUMED Area(Area &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Area &operator=(Area &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Area(const Area &other) = default; + Area &operator=(const Area &other) = default; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::Area new_(const ::api::Size &size); + RUST2_FFI_CALLABLE ::api::Size size() const; + RUST2_FFI_CALLABLE ::std::uint64_t pixels() const; + RUST2_FFI_CALLABLE ::std::uint64_t scaled_Point(const ::api::Point &by) const; + }; + struct Size { + ::std::uint32_t width; + ::std::uint32_t height; + ::api::buf debug() const; + }; + inline bool operator==(const Size &a__, const Size &b_); +} +#endif + +// rt.hpp +#ifndef API_HPP_RT +#define API_HPP_RT +#include "../api.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L && __has_include() +#include +#endif +namespace api { + #if defined(__clang__) + #define RUST2_FFI_LIFETIMEBOUND [[clang::lifetimebound]] + #define RUST2_FFI_CONSUMABLE [[clang::consumable(unconsumed)]] + #define RUST2_FFI_CALLABLE [[clang::callable_when("unconsumed", "unknown")]] + #define RUST2_FFI_CONSUMES [[clang::callable_when("unconsumed", "unknown"), clang::set_typestate(consumed)]] + #define RUST2_FFI_UNCONSUMED [[clang::return_typestate(unconsumed)]] + #define RUST2_FFI_MOVED_FROM [[clang::return_typestate(consumed)]] + #else + #define RUST2_FFI_LIFETIMEBOUND + #define RUST2_FFI_CONSUMABLE + #define RUST2_FFI_CALLABLE + #define RUST2_FFI_CONSUMES + #define RUST2_FFI_UNCONSUMED + #define RUST2_FFI_MOVED_FROM + #endif + class buf; + class input; + template class borrow { + explicit borrow(T &object) noexcept : object_(object); + borrow(const borrow &) = delete; + borrow &operator=(const borrow &) = delete; + T *operator->() const noexcept; + }; + class view { + view() noexcept : data_(detail::bytes(nullptr, 0)), size_(0); + view(const void *data, ::std::size_t size) noexcept : data_(detail::bytes(data, size)), size_(size); + view(const char *text) noexcept : view(text, ::std::strlen(text)); + template ().data()) == 1 && !::std::is_pointer_v<::std::decay_t>>, class = decltype(::std::declval().size())> view(const R &range RUST2_FFI_LIFETIMEBOUND) noexcept : view(range.data(), range.size()); + const ::std::uint8_t *data() const noexcept; + ::std::size_t size() const noexcept; + bool empty() const noexcept; + const ::std::uint8_t *begin() const noexcept; + const ::std::uint8_t *end() const noexcept; + ::std::string_view str() const noexcept; + }; + class buf { + buf() noexcept; + explicit buf(view bytes) : buf(); + buf(const buf &other) : buf(); + buf(buf &&other) noexcept : raw_(::std::exchange(other.raw_, detail::c_buf{nullptr, 0, nullptr})); + buf &operator=(const buf &other); + buf &operator=(buf &&other) noexcept; + ~buf(); + const ::std::uint8_t *data() const noexcept RUST2_FFI_LIFETIMEBOUND; + ::std::size_t size() const noexcept; + bool empty() const noexcept; + const ::std::uint8_t *begin() const noexcept; + const ::std::uint8_t *end() const noexcept; + ::std::string_view str() const noexcept RUST2_FFI_LIFETIMEBOUND; + }; + class input { + input(const char *text) noexcept : input(view(text)); + template && !::std::is_pointer_v<::std::decay_t>>> input(const R &range RUST2_FFI_LIFETIMEBOUND) noexcept; + input(buf &&bytes) noexcept; + input(input &&other) noexcept : raw_(::std::exchange(other.raw_, detail::c_buf{nullptr, 0, nullptr})), held_(::std::move(other.held_)); + input(const input &) = delete; + input &operator=(const input &) = delete; + input &operator=(input &&) = delete; + ~input(); + }; + template class items { + items(const ::std::vector &vector RUST2_FFI_LIFETIMEBOUND) noexcept : data_(vector.data()), size_(vector.size()); + items(::std::initializer_list list) : converted_(list), data_(converted_.data()), size_(converted_.size()); + template , ::std::vector> && !::std::is_same_v<::std::decay_t, items> && detail::lasting && ::std::is_convertible_v())), T>>> items(const R &range RUST2_FFI_LIFETIMEBOUND); + template && ::std::is_convertible_v>> items(::std::vector &&vector RUST2_FFI_LIFETIMEBOUND); + items(const items &) = delete; + items &operator=(const items &) = delete; + items(items &&other) noexcept = default; + const T *begin() const noexcept; + const T *end() const noexcept; + ::std::size_t size() const noexcept; + bool empty() const noexcept; + }; + template class taken { + taken() noexcept = default; + taken(::std::vector &&vector) noexcept : items_(::std::move(vector)); + template && !::std::is_same_v> && !::std::is_same_v && detail::lasting && ::std::is_convertible_v()))), T>>> taken(R &&range RUST2_FFI_LIFETIMEBOUND); + T *begin() noexcept; + T *end() noexcept; + ::std::size_t size() const noexcept; + bool empty() const noexcept; + }; + template class result { + static result ok(T value); + static result err(E error); + bool has_value() const noexcept; + explicit operator bool() const noexcept; + T &value() &; + const T &value() const &; + T &&value() &&; + T &operator*() &; + const T &operator*() const &; + T &&operator*() &&; + T *operator->(); + const T *operator->() const; + E &error() &; + const E &error() const &; + E &&error() &&; + }; + template class result { + static result ok(); + static result err(E error); + bool has_value() const noexcept; + explicit operator bool() const noexcept; + void value() const noexcept; + E &error() &; + const E &error() const &; + E &&error() &&; + }; + class waker { + template , waker>>> explicit waker(F f) : node_(new callable(::std::move(f))); + waker(const waker &other) noexcept : node_(other.node_); + waker &operator=(const waker &other) noexcept; + ~waker(); + void wake() const noexcept; + }; + template using poll_t; + class task; + class task { + task() noexcept = default; + task(task &&other) noexcept : node_(::std::exchange(other.node_, nullptr)); + task &operator=(task &&other) noexcept; + ~task(); + template friend void detail::spawn(task &, typename Op::raw *, Exec, F); + }; + template class future { + using output; + future(future &&other) noexcept : raw_(::std::exchange(other.raw_, nullptr)), last_(::std::exchange(other.last_, nullptr)); + future &operator=(future &&other) noexcept; + ~future(); + poll_t poll(const waker &w); + output get() &&; + template task then(Exec exec, F f) &&; + template auto via(Exec exec) &&; + }; + using u128; + using duration; + using socket_addr; + using socket_addr_v4; + using socket_addr_v6; + using ip_addr; + using ipv4_addr; + using ipv6_addr; + using bound; + using bound_u64; + using bounds_u64; + using range_u64; + enum class Shape; + enum class Status_; + enum class Family; + enum class VecClashTone; + enum class Level; + struct Parcel; + struct Weighted; + struct Stamped; + struct CancellationError; + struct Packet; + struct Hasher; + struct Size; + struct Point; + struct Label; + struct Note; + struct Reading; + struct Packaged; + struct Atlas; + struct Span; + struct Window; + class Ticket; + struct Seat; + class Stamp; + class Moment; + class LongArray; + struct JvmField; + struct JvmStatic; + struct OptIn; + class Wide; + struct Clocked; + class Score; + class Hits; + class Extent; + struct Pair_Size_u8; + struct Pair_non_zero_u16; + struct Pair_u32; + struct Pair_u8_Size; + struct Left_Right_u8; + struct Left_u8; + struct Right_Left_u8; + struct Right_u8; + struct Inner_u8; + struct Boxed_u16; + struct Boxed_u8; + struct LogCount; + struct Wrap_u32; + struct PolarTurn; + struct Peer; + struct Shadowed; + struct Numbers; + struct Measure; + struct Limits_bytes; + struct Limits_duration; + struct Page; + struct Booth; + struct Cancelled; + struct StartSeekable; + struct DoubleArray; + struct NonZeros; + struct a; + struct Qualifiers; + struct polar_Point; + struct polar_Turn; + struct clash_Tone; + struct clash_TONE; + struct clash_Span; + struct tls_policy_Lifetime; + struct Core; + class Board; + class Receipt; + class Draft; + class Filed_Receipt; + class Pad_u16; + class Pad_u8; + class Layered; + class Marker; + class Batch; + class Batch_2; + class Waiter; + class Logger; + class Journal; + class Local; + class LocalWaiter; + class Retry; + class Digest; + class Cursor; + class Outer_Inner_u8; + class Slot_u32; + class Slot_u8; + class Resolving; + class Codecs; + class Der; + class Verbosity; + class Site; + class Trail; + class Worker; + class Handle; + class Area; + class Counter; + class Meter; + class Meters; + class Registry; + class Ledger; + class Slip; + class Sheet; + class Name; + class Channel; + class Gap; + class Berth; + class Mark; + class Message; + class Node; + class Tally; + class Tallies; + class Gauge; + class Latch; + class Token; + class Stack; + class Refusal; + class c; + class Key; + class clash_Store; + class tls_Session; + class Url; + class Json; + class Instant; + class std_io_Error; + class tls_Config; + class tls_Cert; + class tls_Resolver; + class tls_Codec; + class Spawned; + class LogThread; + class Log; + class Beat; + struct Choice_Empty; + struct Choice_Picked; + using Choice; + struct Array_U8x4; + using Array; + struct Platform_Wasm; + struct Platform_Native; + using Platform; + struct Placement_Anywhere; + struct Placement_Pinned; + using Placement; + struct Event_Moved; + struct Event_Named; + struct Event_Done; + using Event; + struct Clash_Point; + struct Clash_Shape; + struct Clash_Event; + struct Clash_Double; + struct Clash_Float; + struct Clash_String; + struct Clash_Int; + struct Clash_Boolean; + struct Clash_Native; + struct Clash_Bytes; + struct Clash_Any; + struct Clash_Unit; + struct Clash_Waker; + struct Clash_Mut; + struct Clash_Pair; + struct Clash_Stamp; + struct Clash_Moment; + using Clash; + struct Stage_Init; + struct Stage_Done; + using Stage; + struct Error_Underflow; + struct Error_Overflow; + using Error; + struct Labelled_Tagged; + struct Labelled_Bare; + using Labelled; + struct b_One; + struct b_Two; + using b; + struct Builtin_Any; + struct Builtin_Boolean; + struct Builtin_Int; + struct Builtin_Native; + using Builtin; + using Clash_after_future; + using Clash_tagged_future; + using Waiter_poll_future_future; + using Local_later_future; + using Local_poll_count_future; + using LocalWaiter_poll_ready_future; + using Handle_later_future; + using Counter_plus_later_future; + using Channel_recv_future; + using Channel_send_later_future; + using Channel_tagged_future; + using Channel_itemized_future; + using Channel_poll_take_future; + using Channel_poll_measure_future; + using Channel_recv_sized_future; + using Channel_recv_nonempty_future; + using Tally_bump_later_future; + using Gauge_later_future; + using Gauge_reaches_future; + using corner_later_future; + using fill_4_future; + using fill_2_future; + using drive_future; + using halved_future; + using yielded_future; + using after_future; + using within_future; + using counted_future; + using log_later_future; + using local_or_new_later_future; + using local_after_future; + using local_later_future; + using poll_tripled_future; + using byte_len_future; + using parse_later_future; + using either_later_future; + using emit_later_future; + using log_on_drop_future; +} +#endif + +// serdejson.hpp +#ifndef API_HPP_CRATE4 +#define API_HPP_CRATE4 +#include "rt.hpp" +namespace api { + class RUST2_FFI_CONSUMABLE Json { + RUST2_FFI_UNCONSUMED Json(Json &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Json &operator=(Json &&other) noexcept = default; + static ::api::result<::api::Json, ::api::buf> parse(::api::input input_); + RUST2_FFI_CALLABLE ::api::buf to_text() const; + }; +} +#endif + +// std.hpp +#ifndef API_HPP_CRATE1 +#define API_HPP_CRATE1 +#include "rt.hpp" +namespace api { + class RUST2_FFI_CONSUMABLE Instant { + RUST2_FFI_UNCONSUMED Instant(Instant &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Instant &operator=(Instant &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Instant(const Instant &other) = default; + Instant &operator=(const Instant &other) = default; + RUST2_FFI_CALLABLE ::std::uint64_t hash() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + }; +} +namespace std { + template <> struct hash<::api::Instant> { + size_t operator()(const ::api::Instant &value) const noexcept; + }; +} +#endif + +// tls.hpp +#ifndef API_HPP_CRATE6 +#define API_HPP_CRATE6 +#include "rt.hpp" +namespace api { + class RUST2_FFI_CONSUMABLE tls_Session { + RUST2_FFI_UNCONSUMED tls_Session(tls_Session &&other RUST2_FFI_MOVED_FROM) noexcept = default; + tls_Session &operator=(tls_Session &&other) noexcept = default; + RUST2_FFI_CALLABLE ::api::buf alpn() const; + RUST2_FFI_CALLABLE ::api::tls_policy_Lifetime lifetime() const; + }; + class RUST2_FFI_CONSUMABLE tls_Config { + RUST2_FFI_UNCONSUMED tls_Config(tls_Config &&other RUST2_FFI_MOVED_FROM) noexcept = default; + tls_Config &operator=(tls_Config &&other) noexcept = default; + RUST2_FFI_UNCONSUMED tls_Config(const tls_Config &other) = default; + tls_Config &operator=(const tls_Config &other) = default; + }; + class RUST2_FFI_CONSUMABLE tls_Cert { + RUST2_FFI_UNCONSUMED tls_Cert(tls_Cert &&other RUST2_FFI_MOVED_FROM) noexcept = default; + tls_Cert &operator=(tls_Cert &&other) noexcept = default; + }; + class RUST2_FFI_CONSUMABLE tls_Resolver { + RUST2_FFI_UNCONSUMED tls_Resolver(tls_Resolver &&other RUST2_FFI_MOVED_FROM) noexcept = default; + tls_Resolver &operator=(tls_Resolver &&other) noexcept = default; + RUST2_FFI_UNCONSUMED tls_Resolver(const tls_Resolver &other) = default; + tls_Resolver &operator=(const tls_Resolver &other) = default; + }; + class RUST2_FFI_CONSUMABLE tls_Codec { + RUST2_FFI_UNCONSUMED tls_Codec(tls_Codec &&other RUST2_FFI_MOVED_FROM) noexcept = default; + tls_Codec &operator=(tls_Codec &&other) noexcept = default; + }; + struct tls_policy_Lifetime { + ::std::uint32_t seconds; + ::api::buf debug() const; + }; + inline bool operator==(const tls_policy_Lifetime &a__, const tls_policy_Lifetime &b_); +} +#endif + +// tracingcore.hpp +#ifndef API_HPP_CRATE3 +#define API_HPP_CRATE3 +#include "rt.hpp" +namespace api { + enum class Level { + trace = 0, + debug = 1, + info = 2, + warn = 3, + error = 4, + }; + inline bool operator==(::api::Level a__, ::api::Level b_); + inline bool operator!=(::api::Level a__, ::api::Level b_); + inline ::api::buf Level_to_string(::api::Level self); +} +#endif + +// url.hpp +#ifndef API_HPP_CRATE5 +#define API_HPP_CRATE5 +#include "rt.hpp" +namespace api { + class RUST2_FFI_CONSUMABLE Url { + RUST2_FFI_UNCONSUMED Url(Url &&other RUST2_FFI_MOVED_FROM) noexcept = default; + Url &operator=(Url &&other) noexcept = default; + RUST2_FFI_UNCONSUMED Url(const Url &other) = default; + Url &operator=(const Url &other) = default; + RUST2_FFI_CALLABLE ::std::uint64_t hash() const; + RUST2_FFI_CALLABLE ::api::buf to_string() const; + RUST2_FFI_CALLABLE ::api::buf debug() const; + static ::api::result<::api::Url, ::api::buf> parse(::api::input input_); + }; +} +namespace std { + template <> struct hash<::api::Url> { + size_t operator()(const ::api::Url &value) const noexcept; + }; +} +#endif diff --git a/ffi/surface/api/dart.dart b/ffi/surface/api/dart.dart new file mode 100644 index 000000000..5ae3f5e6c --- /dev/null +++ b/ffi/surface/api/dart.dart @@ -0,0 +1,1639 @@ +// api.dart +extension type const U64.fromBits(int bits) { + U64(int value); + int toInt(); + BigInt toBigInt(); + String toRadixString(int radix); + int compareTo(U64 other); + bool operator <(U64 other); + bool operator <=(U64 other); + bool operator >(U64 other); + bool operator >=(U64 other); +} +final class RustDuration implements Comparable { + final U64 secs; + final int nanos; + RustDuration(this.secs, [this.nanos = 0]); + static const zero = RustDuration._(U64.fromBits(0), 0); + factory RustDuration.from(Duration duration); + Duration toDuration(); + @override bool operator ==(Object other); + @override int get hashCode; + @override int compareTo(RustDuration other); + @override String toString(); +} +final class PathBuf { + PathBuf(String path); + PathBuf.fromBytes(List bytes); + typed.Uint8List get bytes; + String toFilePath(); + @override bool operator ==(Object other); + @override int get hashCode; + @override String toString(); +} +sealed class IpAddr { + factory IpAddr.from(io.InternetAddress address); + typed.Uint8List get octets; + io.InternetAddress toInternetAddress(); + @override String toString(); +} +final class Ipv4Addr extends IpAddr { + factory Ipv4Addr.fromOctets(List octets); + factory Ipv4Addr.from(io.InternetAddress address); + @override typed.Uint8List get octets; + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Ipv6Addr extends IpAddr { + factory Ipv6Addr.fromOctets(List octets); + factory Ipv6Addr.from(io.InternetAddress address); + @override typed.Uint8List get octets; + @override bool operator ==(Object other); + @override int get hashCode; +} +sealed class SocketAddr { + factory SocketAddr(IpAddr ip, int port); + IpAddr get ip; + int get port; +} +final class SocketAddrV4 extends SocketAddr { + @override final Ipv4Addr ip; + @override final int port; + SocketAddrV4(this.ip, this.port); + @override bool operator ==(Object other); + @override int get hashCode; + @override String toString(); +} +final class SocketAddrV6 extends SocketAddr { + @override final Ipv6Addr ip; + @override final int port; + final int flowinfo; + final int scopeId; + SocketAddrV6(this.ip, this.port, {this.flowinfo = 0, this.scopeId = 0}); + @override bool operator ==(Object other); + @override int get hashCode; + @override String toString(); +} +final class Mut { + T value; + Mut(this.value); +} +final class Cancelled implements Exception { + const Cancelled(); + @override String toString(); +} +extension type Cancelable._(Future _future) implements Future { + void cancel(); +} +enum SeekFrom { + start, + current, + end, +} +abstract interface class SeekableReader { + factory SeekableReader.file(io.RandomAccessFile file); + int readInto(typed.Uint8List buffer); + int seek(int offset, SeekFrom from); +} +final class Waker extends _Object { + void call(); +} +sealed class BoundU64 { + const BoundU64(); +} +final class BoundU64Unbounded extends BoundU64 { + const BoundU64Unbounded(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BoundU64Included extends BoundU64 { + final U64 value; + const BoundU64Included(this.value); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BoundU64Excluded extends BoundU64 { + final U64 value; + const BoundU64Excluded(this.value); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BoundsU64 { + final BoundU64 start; + final BoundU64 end; + const BoundsU64(this.start, this.end); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class RangeU64 { + final U64 start; + final U64 end; + const RangeU64(this.start, this.end); + @override bool operator ==(Object other); + @override int get hashCode; + @override String toString(); +} +final class ArrayU8x4 { + ArrayU8x4(List bytes); + int operator [](int index); + typed.Uint8List toBytes(); + @override bool operator ==(Object other); + @override int get hashCode; + @override String toString(); +} +final class Parcel { + final Mark mark; + final typed.Uint8List payload; + const Parcel({required this.mark, required this.payload}); +} +final class Weighted { + final Score score; + final int weight; + const Weighted({required this.score, required this.weight}); + U64 total(); +} +final class Stamped { + final Stamp at; + final int count; + const Stamped({required this.at, required this.count}); + U64 total(); +} +final class CancellationError { + final int code; + const CancellationError({required this.code}); +} +final class Packet { + final int seq; + final typed.Uint8List payload; + const Packet({required this.seq, required this.payload}); +} +final class Hasher { + final int seed; + const Hasher({required this.seed}); +} +final class Size { + final int width; + final int height; + const Size({required this.width, required this.height}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Point { + final int x; + final int y; + const Point({required this.x, required this.y}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Point.default_(); + Point offset(int dx, int dy); +} +final class Label { + final String name; + final Point? at; + final RustDuration? ttl; + const Label({required this.name, required this.at, required this.ttl}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Note { + final String? text; + const Note({required this.text}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Note.default_(); +} +final class Reading { + final bool ok; + final double level; + final double ratio; + final String mark; + final Shape shape; + final Point at; + final String note; + final U64 count; + final int offset; + final U64 len; + final int tag; + const Reading({required this.ok, required this.level, required this.ratio, required this.mark, required this.shape, required this.at, required this.note, required this.count, required this.offset, required this.len, required this.tag}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + Reading? next(); +} +final class Packaged { + final int api; + const Packaged({required this.api}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + Point point(); + Shape shape(); +} +final class Atlas { + final List<(String, Point)> points; + final List ids; + const Atlas({required this.points, required this.ids}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + Atlas with_(String name, Point at); +} +final class Span { + final (int, int) bounds; + final (String, Shape)? named; + const Span({required this.bounds, required this.named}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Window { + final RangeU64 range; + final BoundU64 end; + const Window({required this.range, required this.end}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + bool contains(U64 n); +} +final class Ticket { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Ticket(int number); + int number(); + static int clones(); +} +final class Seat { + final Mark mark; + final int row; + const Seat({required this.mark, required this.row}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + U64 count(); +} +final class Stamp { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Stamp.fromMillis(U64 millis); + U64 secs(); + Stamp whole(); + bool later(Stamp other); +} +final class Moment { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + static Moment? new_(U64 ticks, U64 rate); + U64 millis(); + Moment after(U64 ticks); +} +final class LongArray { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory LongArray(U64 low, U64 high); + U64 c(); + void also(void Function(U64) f); +} +final class JvmField { + final int n; + const JvmField({required this.n}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class JvmStatic { + final int n; + const JvmStatic({required this.n}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class OptIn { + final int n; + const OptIn({required this.n}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Wide { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Wide(U64 seed); + U64 sum(); +} +final class Clocked { + final Moment at; + final int count; + const Clocked({required this.at, required this.count}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Score { + String debug(); + factory Score.of(U64 count); + U64 count(); + Score add(Score other); + Score doubled(); + (Score, U64) take(); + (Score, U64) note(Mark mark); + (Score, U64, U64) absorb(Mut other); +} +final class Hits { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Hits.default_(); + U64 get hitsGet; + Hits hitsSet(U64 value); + U64 get missesGet; + Hits missesSet(U64 value); + factory Hits.of(U64 hits, U64 misses); + Hits add(Hits other); + (Hits, bool) eq(Hits other); +} +final class Extent { + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + U64 get startGet; + Extent startSet(U64 value); + factory Extent(U64 start, U64 len); + U64 end(); + (Extent, U64) slide(U64 by); +} +final class PairSizeU8 { + final Size left; + final int right; + const PairSizeU8({required this.left, required this.right}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + PairU8Size swap(); +} +final class PairNonZeroU16 { + final int left; + final int right; + const PairNonZeroU16({required this.left, required this.right}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + PairNonZeroU16 swap(); + bool even(); +} +final class PairU32 { + final int left; + final int right; + const PairU32({required this.left, required this.right}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + PairU32 swap(); + bool even(); + int sum(); + PairU8Size besideSize(Size right); +} +final class PairU8Size { + final int left; + final Size right; + const PairU8Size({required this.left, required this.right}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class LeftRightU8 { + final RightU8 value; + const LeftRightU8({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class LeftU8 { + final int value; + const LeftU8({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class RightLeftU8 { + final LeftU8 value; + const RightLeftU8({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class RightU8 { + final int value; + const RightU8({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class InnerU8 { + final int value; + const InnerU8({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BoxedU16 { + final int value; + const BoxedU16({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BoxedU8 { + final int value; + const BoxedU8({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class LogCount { + final int kept; + const LogCount({required this.kept}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class WrapU32 { + final int value; + const WrapU32({required this.value}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class PolarTurn { + final int whole; + const PolarTurn({required this.whole}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Peer { + final SocketAddr addr; + final List names; + const Peer({required this.addr, required this.names}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + List aliases(); + Peer next(String name); +} +final class Shadowed { + final typed.Int32List other; + final int a; + final int b; + const Shadowed({required this.other, required this.a, required this.b}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Numbers { + final typed.Uint16List u16s; + final typed.Uint32List u32s; + final List u64s; + final typed.Int8List i8s; + final typed.Int16List i16s; + final typed.Int32List i32s; + final typed.Int64List i64s; + final typed.Float32List f32s; + final typed.Float64List f64s; + final typed.Int32List? some; + const Numbers({required this.u16s, required this.u32s, required this.u64s, required this.i8s, required this.i16s, required this.i32s, required this.i64s, required this.f32s, required this.f64s, required this.some}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Numbers.edges(); + factory Numbers.zero(bool negative); + Numbers reversed(); +} +final class Measure { + final double value; + final Numbers numbers; + const Measure({required this.value, required this.numbers}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Measure.new_(double value, bool negative); +} +final class LimitsBytes { + final typed.Uint8List low; + final typed.Uint8List high; + const LimitsBytes({required this.low, required this.high}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class LimitsDuration { + final RustDuration low; + final RustDuration high; + const LimitsDuration({required this.low, required this.high}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Page { + final int size; + const Page({required this.size}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + factory Page.default_(); +} +final class Booth { + final Mark mark; + const Booth({required this.mark}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Cancelled_ { + final int step; + const Cancelled_({required this.step}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class StartSeekable { + final U64 at; + const StartSeekable({required this.at}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class DoubleArray { + final int len; + const DoubleArray({required this.len}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class NonZeros { + final int u8; + final int u16; + final int u32; + final U64 u64; + final U64 usize; + final int i8; + final int i16; + final int i32; + final int i64; + final int isize; + const NonZeros({required this.u8, required this.u16, required this.u32, required this.u64, required this.usize, required this.i8, required this.i16, required this.i32, required this.i64, required this.isize}); + String debug(); +} +final class A { + final int b; + const A({required this.b}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Qualifiers { + final double api; + final double kotlin; + const Qualifiers({required this.api, required this.kotlin}); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class PolarPoint { + final int turns; + final int distance; + const PolarPoint({required this.turns, required this.distance}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Polar_Turn { + final int part; + const Polar_Turn({required this.part}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class ClashTone { + final int hz; + const ClashTone({required this.hz}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class ClashTone_ { + final int db; + const ClashTone_({required this.db}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class ClashSpan { + final int width; + const ClashSpan({required this.width}); + @override String toString(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + int width_(); + String toString_(); +} +final class TlsPolicyLifetime { + final int seconds; + const TlsPolicyLifetime({required this.seconds}); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class Core { + final int id; + const Core({required this.id}); +} +sealed class Choice { + const Choice(); +} +final class ChoiceEmpty extends Choice { + const ChoiceEmpty(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class ChoicePicked extends Choice { + final Mark $0; + const ChoicePicked(this.$0); +} +sealed class Array { + const Array(); +} +final class ArrayU8x4_ extends Array { + final int $0; + const ArrayU8x4_(this.$0); +} +sealed class Platform { + const Platform(); +} +final class PlatformWasm extends Platform { + final int bits; + const PlatformWasm({required this.bits}); +} +final class PlatformNative extends Platform { + final int $0; + const PlatformNative(this.$0); +} +sealed class Placement { + const Placement(); +} +final class PlacementAnywhere extends Placement { + const PlacementAnywhere(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class PlacementPinned extends Placement { + final Core $0; + const PlacementPinned(this.$0); +} +enum Shape { + circle(1), + square(4), + const Shape(this._c); + String debug(); + static List get ALL; + static List get BOTH; +} +sealed class Event { + const Event(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class EventMoved extends Event { + final Point $0; + const EventMoved(this.$0); +} +final class EventNamed extends Event { + final String name; + const EventNamed({required this.name}); +} +final class EventDone extends Event { + const EventDone(); +} +sealed class Clash { + const Clash(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; + Point? point(); + factory Clash.of(double value); + typed.Uint8List bytes(); + Reading reading(int kotlin); + static List listed(typed.Uint32List java, Mut kotlin); + static Cancelable after(Future first, double kotlin); + typed.Uint8List joined(typed.Uint8List lent, typed.Uint8List owned, typed.Uint8List? maybe); + Cancelable tagged(String tag); + Stamp stamp(U64 kotlin); + Moment moment(U64 kotlin); + factory Clash.at(Point api); + String describe(String text, int n, Shape shape, Mut out); +} +final class ClashPoint extends Clash { + final Point $0; + const ClashPoint(this.$0); +} +final class ClashShape extends Clash { + final Shape $0; + const ClashShape(this.$0); +} +final class ClashEvent extends Clash { + final Event $0; + const ClashEvent(this.$0); +} +final class ClashDouble extends Clash { + final double $0; + const ClashDouble(this.$0); +} +final class ClashFloat extends Clash { + final double $0; + const ClashFloat(this.$0); +} +final class ClashString extends Clash { + final String $0; + const ClashString(this.$0); +} +final class ClashInt extends Clash { + final int $0; + const ClashInt(this.$0); +} +final class ClashBoolean extends Clash { + final bool $0; + const ClashBoolean(this.$0); +} +final class ClashNative extends Clash { + final int $0; + const ClashNative(this.$0); +} +final class ClashBytes extends Clash { + final typed.Uint8List $0; + const ClashBytes(this.$0); +} +final class ClashAny extends Clash { + const ClashAny(); +} +final class ClashUnit extends Clash { + const ClashUnit(); +} +final class ClashWaker extends Clash { + const ClashWaker(); +} +final class ClashMut extends Clash { + const ClashMut(); +} +final class ClashPair extends Clash { + final int $0; + final int $1; + const ClashPair(this.$0, this.$1); +} +final class ClashStamp extends Clash { + final int $0; + const ClashStamp(this.$0); +} +final class ClashMoment extends Clash { + final Moment $0; + const ClashMoment(this.$0); +} +sealed class Stage { + const Stage(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class StageInit extends Stage { + final int $0; + const StageInit(this.$0); +} +final class StageDone extends Stage { + const StageDone(); +} +sealed class Error implements Exception { + const Error(); + @override String toString(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class ErrorUnderflow extends Error { + final U64 by; + const ErrorUnderflow({required this.by}); +} +final class ErrorOverflow extends Error { + const ErrorOverflow(); +} +enum Status { + moved(0), + kept(1), + const Status(this._c); + String debug(); +} +sealed class Labelled { + const Labelled(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class LabelledTagged extends Labelled { + final int tag; + const LabelledTagged({required this.tag}); +} +final class LabelledBare extends Labelled { + const LabelledBare(); +} +enum Family { + native(0, 0x3, 'api_Family.Native'), + wasm(1, 0x1, 'api_Family.Wasm'), + const Family(this._value, this._targets, this._what); + String debug(); +} +enum VecClashTone { + error(0), + const VecClashTone(this._c); + String debug(); +} +sealed class B { + const B(); + String debug(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BOne extends B { + const BOne(); +} +final class BTwo extends B { + final int $0; + const BTwo(this.$0); +} +sealed class Builtin { + const Builtin(); + @override bool operator ==(Object other); + @override int get hashCode; +} +final class BuiltinAny extends Builtin { + final typed.Int32List $0; + const BuiltinAny(this.$0); +} +final class BuiltinBoolean extends Builtin { + final double $0; + const BuiltinBoolean(this.$0); +} +final class BuiltinInt extends Builtin { + final double $0; + const BuiltinInt(this.$0); +} +final class BuiltinNative extends Builtin { + final double $0; + const BuiltinNative(this.$0); +} +enum Level { + trace(0), + debug(1), + info(2), + warn(3), + error(4), + const Level(this._c); + @override String toString(); +} +final class Board extends _Object { + factory Board(List<(String, Counter)> counters); + List<(String, Counter)> intoCounters(); + List<(String, Counter)> ranked(); + Counter best(); +} +final class Receipt extends _Object { + Receipt clone(); + int count(); +} +final class Draft extends _Object { + bool edited(); + String describe(); + int commit(); + String get titleGet; + void titleSet(String value); + int lines(); + void write(String line); +} +final class FiledReceipt extends _Object { + FiledReceipt clone(); + int count(); +} +final class PadU16 extends _Object { + factory PadU16.wide(); + int tag(); + int title(); + String describe(); +} +final class PadU8 extends _Object { + factory PadU8.small(); + String describe(); + String get titleGet; + int lines(); +} +final class Layered extends _Object { + factory Layered(); + String get titleGet; + int lines(); +} +final class Marker extends _Object { + factory Marker(String label, int x, int y); + String label(); + int get xGet; + void xSet(int value); + int get yGet; + void ySet(int value); + Point offset(int dx, int dy); +} +final class Batch extends _Object { + factory Batch(); + bool push(int v); + U64 capacity(); +} +final class Batch2 extends _Object { + factory Batch2(); + bool push(int v); + U64 capacity(); +} +final class Waiter extends _Object { + factory Waiter(void Function() waker); + Waker waker(); + Waker context(); + static Cancelable pollFuture(Future future); +} +final class Logger extends _Object { + factory Logger(Log sink); + bool write(String line); + bool writeFromThread(String line); +} +final class Journal extends _Object { + factory Journal(Log sink); + void redirect(Log sink); + bool write(String line); +} +final class Local extends _Object { + @override bool operator ==(Object other); + @override int get hashCode; + factory Local.default_(); + factory Local(); + int bump(); + Local share(); + Cancelable later(); + int visit(int Function() f); + Cancelable pollCount(); + U64 threadNumber(); + bool onOwnThread(); +} +final class LocalWaiter extends _Object { + factory LocalWaiter(void Function() waker); + static Cancelable pollReady(int n); +} +final class Retry extends _Object { + int? get limitGet; + void limitSet(int? value); + factory Retry(int? limit); + int limit(); + int delay(); + void setLimit(int limit); +} +final class Digest extends _Object { + ArrayU8x4 get sumGet; + void sumSet(ArrayU8x4 value); + factory Digest(); + ArrayU8x4 flipped(ArrayU8x4 mask); +} +final class Cursor extends _Object { + U64 at(); +} +final class OuterInnerU8 extends _Object { + factory OuterInnerU8(int value); + int get(); +} +final class SlotU32 extends _Object { + factory SlotU32(int value); +} +final class SlotU8 extends _Object { + factory SlotU8(int value); + int value(); +} +final class Resolving extends _Object { + TlsResolver get $0_get; + void $0_set(TlsResolver value); + factory Resolving(String name); +} +final class Codecs extends _Object { + factory Codecs.default_(); + List get listGet; + void listSet(List value); + factory Codecs(); + int ids(); +} +final class Der extends _Object { + factory Der.fromSlice(typed.Uint8List bytes); + typed.Uint8List bytes(); +} +final class Verbosity extends _Object { + Level get levelGet; + void levelSet(Level value); + factory Verbosity(Level level); + Level? filter(); +} +final class Site extends _Object { + Url get homeGet; + void homeSet(Url value); + factory Site(Url home); +} +final class Trail extends _Object { + factory Trail(List points, List names); + List points(); + List