@leaflow/sdk 0.0.0-dev.51.g1857c7d → 0.0.0-dev.510.g8eb7f2e

package/dist/proto/leaflow/fleet/transport/v1/transport_pb.d.ts

@@ -0,0 +1,1055 @@
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { Status } from "../../../../google/rpc/status_pb.js";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file leaflow/fleet/transport/v1/transport.proto.
+ */
+export declare const file_leaflow_fleet_transport_v1_transport: GenFile;
+/**
+ * Exactly one message of a data channel.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Packet
+ */
+export type Packet = Message<"leaflow.fleet.transport.v1.Packet"> & {
+    /**
+     * The packet.
+     *
+     * @generated from oneof leaflow.fleet.transport.v1.Packet.packet
+     */
+    packet: {
+        /**
+         * Proof of identity and the limits of the sender. On "binding" only.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Hello hello = 1;
+         */
+        value: Hello;
+        case: "hello";
+    } | {
+        /**
+         * One step of a logical channel. On the lane of that channel.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Envelope envelope = 2;
+         */
+        value: Envelope;
+        case: "envelope";
+    } | {
+        /**
+         * One unreliable message. On "realtime" only.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Datagram datagram = 3;
+         */
+        value: Datagram;
+        case: "datagram";
+    } | {
+        /**
+         * What the sender has admitted so far. On "binding" only, after both
+         * Hellos verified.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Checkpoint receipt = 4;
+         */
+        value: Checkpoint;
+        case: "receipt";
+    } | {
+        /**
+         * Why the sender is about to close the PeerConnection. On "binding".
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Close close = 5;
+         */
+        value: Close;
+        case: "close";
+    } | {
+        /**
+         * A renewed PeerAuthorization of this PeerConnection that the participant
+         * received from the Fleet API. On "binding" only, from the participant,
+         * after both Hellos verified.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.SignedPeerAuthorization peer_authorization = 6;
+         */
+        value: SignedPeerAuthorization;
+        case: "peerAuthorization";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Packet.
+ * Use `create(PacketSchema)` to create a new message.
+ */
+export declare const PacketSchema: GenMessage<Packet>;
+/**
+ * Each end sends Hello twice: first with its own challenge and an empty
+ * response, then, once the peer's Hello arrived, again with response set to
+ * the peer's challenge. A Hello that names another PeerConnection, another
+ * participant, an unexpected epoch or another PeerAuthorization than the one
+ * the receiver holds ends the PeerConnection.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Hello
+ */
+export type Hello = Message<"leaflow.fleet.transport.v1.Hello"> & {
+    /**
+     * The PeerConnection (Signal.peer_connection_id).
+     *
+     * @generated from field: bytes peer_connection_id = 1;
+     */
+    peerConnectionId: Uint8Array;
+    /**
+     * The participant.
+     *
+     * @generated from field: uint64 participant_id = 2;
+     */
+    participantId: bigint;
+    /**
+     * The epoch of this path, chosen by the participant: 1 for its first
+     * PeerConnection, then one more than the committed epoch, since the session
+     * may have taken an earlier PeerConnection that the participant did not.
+     * The session accepts one more than its committed epoch, or 1 while no path
+     * has carried the connection, and greets with the same epoch.
+     *
+     * @generated from field: uint64 epoch = 3;
+     */
+    epoch: bigint;
+    /**
+     * 32 unpredictable bytes.
+     *
+     * @generated from field: bytes challenge = 4;
+     */
+    challenge: Uint8Array;
+    /**
+     * The peer's challenge. Empty in the first Hello.
+     *
+     * @generated from field: bytes response = 5;
+     */
+    response: Uint8Array;
+    /**
+     * SHA-256 of the bytes of the first PeerAuthorization the service signed
+     * for this PeerConnection (SignedPeerAuthorization.authorization). Renewed
+     * ones do not change it.
+     *
+     * @generated from field: bytes authorization_sha256 = 6;
+     */
+    authorizationSha256: Uint8Array;
+    /**
+     * The Ed25519 public key (RFC 8032) that vouches for the sender's DTLS
+     * certificate: the machine key for the Agent, the participant's own key for
+     * the participant. The participant refuses an Agent key other than the one
+     * it pinned for the machine; the session refuses a participant key other
+     * than the one in the participant's authorization.
+     *
+     * @generated from field: bytes public_key = 7;
+     */
+    publicKey: Uint8Array;
+    /**
+     * Ed25519 signature by public_key over the UTF-8 string
+     * "leaflow.fleet.transport.v1.Hello", one zero byte, peer_connection_id,
+     * participant_id as 8 big-endian bytes, one byte for the role of the
+     * sender (1 participant, 2 Agent) and the SHA-256 fingerprint of the
+     * sender's own DTLS certificate (RFC 8122).
+     *
+     * @generated from field: bytes dtls_attestation = 8;
+     */
+    dtlsAttestation: Uint8Array;
+    /**
+     * The largest message, in bytes, the sender accepts in the byte stream of
+     * one channel.
+     *
+     * @generated from field: uint32 max_message_size = 9;
+     */
+    maxMessageSize: number;
+    /**
+     * The credit, in bytes of channel data, the sender grants each new channel
+     * toward itself unless ChannelOpen or ChannelOpenConfirmation state another.
+     *
+     * @generated from field: uint64 initial_max_data = 10;
+     */
+    initialMaxData: bigint;
+    /**
+     * The largest Datagram.data, in bytes, the sender accepts. 0: none.
+     *
+     * @generated from field: uint32 max_datagram_size = 11;
+     */
+    maxDatagramSize: number;
+    /**
+     * 16 bytes that identify the process instance holding this end of the
+     * connection. It stays the same across migrations; a migration that reaches
+     * another instance ends the connection.
+     *
+     * @generated from field: bytes instance_id = 12;
+     */
+    instanceId: Uint8Array;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Hello.
+ * Use `create(HelloSchema)` to create a new message.
+ */
+export declare const HelloSchema: GenMessage<Hello>;
+/**
+ * One step of a logical channel. The sender numbers the envelopes of each
+ * channel from 1 and keeps those not yet admitted, so that it can send them
+ * again on the next path.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Envelope
+ */
+export type Envelope = Message<"leaflow.fleet.transport.v1.Envelope"> & {
+    /**
+     * The logical channel.
+     *
+     * @generated from field: uint64 channel_id = 1;
+     */
+    channelId: bigint;
+    /**
+     * 1 for the first envelope of the channel, then one more each time.
+     *
+     * @generated from field: uint64 sequence = 2;
+     */
+    sequence: bigint;
+    /**
+     * The epoch in which the envelope was first sent. A channel type that
+     * cannot resume, such as a video frame, discards envelopes whose origin
+     * epoch is older than the current one.
+     *
+     * @generated from field: uint64 origin_epoch = 3;
+     */
+    originEpoch: bigint;
+    /**
+     * The step.
+     *
+     * @generated from oneof leaflow.fleet.transport.v1.Envelope.body
+     */
+    body: {
+        /**
+         * Opens the channel. Always the first envelope.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.ChannelOpen open = 4;
+         */
+        value: ChannelOpen;
+        case: "open";
+    } | {
+        /**
+         * Accepts the channel.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.ChannelOpenConfirmation open_confirmation = 5;
+         */
+        value: ChannelOpenConfirmation;
+        case: "openConfirmation";
+    } | {
+        /**
+         * Refuses the channel.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.ChannelOpenFailure open_failure = 6;
+         */
+        value: ChannelOpenFailure;
+        case: "openFailure";
+    } | {
+        /**
+         * The next bytes of the channel's stream. They count against the credit.
+         *
+         * @generated from field: bytes data = 7;
+         */
+        value: Uint8Array;
+        case: "data";
+    } | {
+        /**
+         * Raises the peer's credit (RFC 9000 §19.10 MAX_STREAM_DATA): the total
+         * bytes of data the peer may send on the channel. A value not larger than
+         * the current credit is ignored.
+         *
+         * @generated from field: uint64 max_data = 8;
+         */
+        value: bigint;
+        case: "maxData";
+    } | {
+        /**
+         * Closes the channel.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.ChannelClose close = 9;
+         */
+        value: ChannelClose;
+        case: "close";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Envelope.
+ * Use `create(EnvelopeSchema)` to create a new message.
+ */
+export declare const EnvelopeSchema: GenMessage<Envelope>;
+/**
+ * Opens a logical channel (RFC 4254 §5.1). The opener may send data at once,
+ * within the receiver's initial_max_data.
+ *
+ * @generated from message leaflow.fleet.transport.v1.ChannelOpen
+ */
+export type ChannelOpen = Message<"leaflow.fleet.transport.v1.ChannelOpen"> & {
+    /**
+     * What the channel carries. One of:
+     *   - the full name of a package, such as "leaflow.fleet.terminal.v1";
+     *   - a package name and a channel role that package defines, such as
+     *     "leaflow.fleet.filetransfer.v1.content";
+     *   - the full name of a service, such as
+     *     "leaflow.fleet.filetransfer.v1.FileSystemService"; the channel then
+     *     carries leaflow.fleet.rpc.v1 messages and its opener calls.
+     *
+     * @generated from field: string channel_type = 1;
+     */
+    channelType: string;
+    /**
+     * The credit the opener grants the receiver on this channel. 0: the
+     * opener's initial_max_data.
+     *
+     * @generated from field: uint64 max_data = 2;
+     */
+    maxData: bigint;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.ChannelOpen.
+ * Use `create(ChannelOpenSchema)` to create a new message.
+ */
+export declare const ChannelOpenSchema: GenMessage<ChannelOpen>;
+/**
+ * Accepts a channel. Optional: the opener also counts the channel as accepted
+ * on the receiver's first envelope.
+ *
+ * @generated from message leaflow.fleet.transport.v1.ChannelOpenConfirmation
+ */
+export type ChannelOpenConfirmation = Message<"leaflow.fleet.transport.v1.ChannelOpenConfirmation"> & {
+    /**
+     * The credit the receiver grants the opener. 0: the receiver's
+     * initial_max_data.
+     *
+     * @generated from field: uint64 max_data = 1;
+     */
+    maxData: bigint;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.ChannelOpenConfirmation.
+ * Use `create(ChannelOpenConfirmationSchema)` to create a new message.
+ */
+export declare const ChannelOpenConfirmationSchema: GenMessage<ChannelOpenConfirmation>;
+/**
+ * Refuses a channel (RFC 4254 §5.1). Data already received on it is
+ * discarded.
+ *
+ * @generated from message leaflow.fleet.transport.v1.ChannelOpenFailure
+ */
+export type ChannelOpenFailure = Message<"leaflow.fleet.transport.v1.ChannelOpenFailure"> & {
+    /**
+     * Why the channel was refused.
+     *
+     * @generated from field: leaflow.fleet.transport.v1.ChannelOpenFailureReason reason = 1;
+     */
+    reason: ChannelOpenFailureReason;
+    /**
+     * Plain text for logs, at most 1024 bytes.
+     *
+     * @generated from field: string description = 2;
+     */
+    description: string;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.ChannelOpenFailure.
+ * Use `create(ChannelOpenFailureSchema)` to create a new message.
+ */
+export declare const ChannelOpenFailureSchema: GenMessage<ChannelOpenFailure>;
+/**
+ * Closes a channel. Each end sends one, and the channel is gone once both
+ * have (RFC 4254 §5.3). The sender sends nothing more on it. A receiver that
+ * sends it with CANCELLED asks the sender to stop (RFC 9000 §19.5
+ * STOP_SENDING).
+ *
+ * @generated from message leaflow.fleet.transport.v1.ChannelClose
+ */
+export type ChannelClose = Message<"leaflow.fleet.transport.v1.ChannelClose"> & {
+    /**
+     * NO_ERROR for an orderly close.
+     *
+     * @generated from field: leaflow.fleet.transport.v1.ChannelErrorCode error_code = 1;
+     */
+    errorCode: ChannelErrorCode;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.ChannelClose.
+ * Use `create(ChannelCloseSchema)` to create a new message.
+ */
+export declare const ChannelCloseSchema: GenMessage<ChannelClose>;
+/**
+ * One message of a channel that does not need reliable delivery, such as an
+ * audio packet: the channel's message itself, without a length prefix.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Datagram
+ */
+export type Datagram = Message<"leaflow.fleet.transport.v1.Datagram"> & {
+    /**
+     * The channel the message belongs to.
+     *
+     * @generated from field: uint64 channel_id = 1;
+     */
+    channelId: bigint;
+    /**
+     * The message, at most the receiver's max_datagram_size bytes.
+     *
+     * @generated from field: bytes data = 2;
+     */
+    data: Uint8Array;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Datagram.
+ * Use `create(DatagramSchema)` to create a new message.
+ */
+export declare const DatagramSchema: GenMessage<Datagram>;
+/**
+ * What one end has admitted on a connection, and the channels both ends have
+ * finished with. As a receipt it lets the peer drop what it kept for sending
+ * again; in a Migration it fixes the state the new path starts from.
+ * Admission means the envelope reached the receiving process, not that its
+ * effect happened.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Checkpoint
+ */
+export type Checkpoint = Message<"leaflow.fleet.transport.v1.Checkpoint"> & {
+    /**
+     * The epoch the checkpoint belongs to.
+     *
+     * @generated from field: uint64 epoch = 1;
+     */
+    epoch: bigint;
+    /**
+     * Hello.instance_id of the end that took it.
+     *
+     * @generated from field: bytes instance_id = 2;
+     */
+    instanceId: Uint8Array;
+    /**
+     * The last admitted envelope of every live channel, at most 4096.
+     *
+     * @generated from field: repeated leaflow.fleet.transport.v1.ChannelCursor cursors = 3;
+     */
+    cursors: ChannelCursor[];
+    /**
+     * Channels both ends have closed, compacted into ranges. Envelopes of these
+     * channels are dropped.
+     *
+     * @generated from field: repeated leaflow.fleet.transport.v1.RetiredRange retired_ranges = 4;
+     */
+    retiredRanges: RetiredRange[];
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Checkpoint.
+ * Use `create(CheckpointSchema)` to create a new message.
+ */
+export declare const CheckpointSchema: GenMessage<Checkpoint>;
+/**
+ * The last envelope admitted on a channel.
+ *
+ * @generated from message leaflow.fleet.transport.v1.ChannelCursor
+ */
+export type ChannelCursor = Message<"leaflow.fleet.transport.v1.ChannelCursor"> & {
+    /**
+     * The channel.
+     *
+     * @generated from field: uint64 channel_id = 1;
+     */
+    channelId: bigint;
+    /**
+     * Envelope.sequence of the last admitted envelope.
+     *
+     * @generated from field: uint64 sequence = 2;
+     */
+    sequence: bigint;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.ChannelCursor.
+ * Use `create(ChannelCursorSchema)` to create a new message.
+ */
+export declare const ChannelCursorSchema: GenMessage<ChannelCursor>;
+/**
+ * The channel ids from first_channel_id to last_channel_id, both included and
+ * of the same opener.
+ *
+ * @generated from message leaflow.fleet.transport.v1.RetiredRange
+ */
+export type RetiredRange = Message<"leaflow.fleet.transport.v1.RetiredRange"> & {
+    /**
+     * The first id.
+     *
+     * @generated from field: uint64 first_channel_id = 1;
+     */
+    firstChannelId: bigint;
+    /**
+     * The last id.
+     *
+     * @generated from field: uint64 last_channel_id = 2;
+     */
+    lastChannelId: bigint;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.RetiredRange.
+ * Use `create(RetiredRangeSchema)` to create a new message.
+ */
+export declare const RetiredRangeSchema: GenMessage<RetiredRange>;
+/**
+ * A two-phase migration of a connection to a new path; RFC 9000 §9 calls the
+ * same move connection migration. It does not depend on the failed path: the
+ * participant sends its steps through the Fleet API and receives the
+ * session's in the answers, and the session sends its own on its control
+ * connection. The participant coordinates: it sends prepare, the session
+ * answers prepared, the participant sends commit and the session answers
+ * committed. Both ends stop admitting envelopes of the old epoch at prepare. A
+ * repeated step is answered again and never applied twice. Only the
+ * participant starts a migration: when the session's side of the path fails,
+ * the participant's side fails too.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Migration
+ */
+export type Migration = Message<"leaflow.fleet.transport.v1.Migration"> & {
+    /**
+     * The participant.
+     *
+     * @generated from field: uint64 participant_id = 1;
+     */
+    participantId: bigint;
+    /**
+     * The step.
+     *
+     * @generated from oneof leaflow.fleet.transport.v1.Migration.step
+     */
+    step: {
+        /**
+         * The participant's checkpoint for the next epoch.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Checkpoint prepare = 2;
+         */
+        value: Checkpoint;
+        case: "prepare";
+    } | {
+        /**
+         * The session's checkpoint for the same epoch.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Checkpoint prepared = 3;
+         */
+        value: Checkpoint;
+        case: "prepared";
+    } | {
+        /**
+         * The participant commits the epoch.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Checkpoint commit = 4;
+         */
+        value: Checkpoint;
+        case: "commit";
+    } | {
+        /**
+         * The session committed it.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.Checkpoint committed = 5;
+         */
+        value: Checkpoint;
+        case: "committed";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Migration.
+ * Use `create(MigrationSchema)` to create a new message.
+ */
+export declare const MigrationSchema: GenMessage<Migration>;
+/**
+ * Why the sender closes the PeerConnection.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Close
+ */
+export type Close = Message<"leaflow.fleet.transport.v1.Close"> & {
+    /**
+     * The reason. Its details may carry a google.rpc.ErrorInfo.
+     *
+     * @generated from field: google.rpc.Status status = 1;
+     */
+    status?: Status | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Close.
+ * Use `create(CloseSchema)` to create a new message.
+ */
+export declare const CloseSchema: GenMessage<Close>;
+/**
+ * Signaling for one PeerConnection (RFC 9429 JSEP; RFC 8838 trickle ICE)
+ * between the session process and the service, which stands for the
+ * participant: the participant sends its offer, its candidates and the end of
+ * a PeerConnection through the Fleet API, and receives the session's answer
+ * and the PeerAuthorization in the answer of its request. The service keeps
+ * the session's candidates and end_of_candidates, at most 64 candidates, and
+ * the participant reads them through the Fleet API as they arrive. The session
+ * therefore sends each candidate as soon as it has it and end_of_candidates as
+ * soon as it gathered.
+ *
+ * The offer is the first signal of a PeerConnection: the service sends it
+ * before any other signal of that PeerConnection. The participant's later
+ * candidates, its end of candidates and the abort come from separate requests
+ * and may reach the session in any order; a candidate or an end of candidates
+ * of a PeerConnection that has ended is ignored.
+ *
+ * @generated from message leaflow.fleet.transport.v1.Signal
+ */
+export type Signal = Message<"leaflow.fleet.transport.v1.Signal"> & {
+    /**
+     * 16 random bytes the service chose for the PeerConnection: the id of the
+     * PeerConnection in the Fleet API, a UUID.
+     *
+     * @generated from field: bytes peer_connection_id = 1;
+     */
+    peerConnectionId: Uint8Array;
+    /**
+     * The participant.
+     *
+     * @generated from field: uint64 participant_id = 2;
+     */
+    participantId: bigint;
+    /**
+     * The ICE servers and policy for the session's end of the PeerConnection.
+     * Set by the service on the offer.
+     *
+     * @generated from field: leaflow.fleet.transport.v1.RtcConfiguration configuration = 4;
+     */
+    configuration?: RtcConfiguration | undefined;
+    /**
+     * The signal.
+     *
+     * @generated from oneof leaflow.fleet.transport.v1.Signal.signal
+     */
+    signal: {
+        /**
+         * An offer from the participant or an answer from the session.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.SessionDescription description = 5;
+         */
+        value: SessionDescription;
+        case: "description";
+    } | {
+        /**
+         * A trickled ICE candidate.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.IceCandidate candidate = 6;
+         */
+        value: IceCandidate;
+        case: "candidate";
+    } | {
+        /**
+         * No more candidates from the sender (RFC 8838).
+         *
+         * @generated from field: bool end_of_candidates = 7;
+         */
+        value: boolean;
+        case: "endOfCandidates";
+    } | {
+        /**
+         * The sender gave up the PeerConnection: the participant ended it through
+         * the Fleet API, or the session could not take it. The participant starts
+         * another one.
+         *
+         * @generated from field: bool abort = 8;
+         */
+        value: boolean;
+        case: "abort";
+    } | {
+        /**
+         * The service's authorization of the PeerConnection, sent to the session
+         * this way and to the participant with the answer, before either may send
+         * application data. Renewed ones reach the session this way too, and the
+         * participant in the answer of its renewal through the Fleet API.
+         *
+         * @generated from field: leaflow.fleet.transport.v1.SignedPeerAuthorization authorization = 9;
+         */
+        value: SignedPeerAuthorization;
+        case: "authorization";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.Signal.
+ * Use `create(SignalSchema)` to create a new message.
+ */
+export declare const SignalSchema: GenMessage<Signal>;
+/**
+ * An SDP offer or answer (RFC 8866), as in W3C RTCSessionDescriptionInit.
+ *
+ * @generated from message leaflow.fleet.transport.v1.SessionDescription
+ */
+export type SessionDescription = Message<"leaflow.fleet.transport.v1.SessionDescription"> & {
+    /**
+     * Offer or answer.
+     *
+     * @generated from field: leaflow.fleet.transport.v1.SdpType type = 1;
+     */
+    type: SdpType;
+    /**
+     * The SDP, at most 65536 bytes. It contains ICE credentials and is never
+     * logged.
+     *
+     * @generated from field: string sdp = 2;
+     */
+    sdp: string;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.SessionDescription.
+ * Use `create(SessionDescriptionSchema)` to create a new message.
+ */
+export declare const SessionDescriptionSchema: GenMessage<SessionDescription>;
+/**
+ * An ICE candidate (RFC 8445), as in W3C RTCIceCandidateInit.
+ *
+ * @generated from message leaflow.fleet.transport.v1.IceCandidate
+ */
+export type IceCandidate = Message<"leaflow.fleet.transport.v1.IceCandidate"> & {
+    /**
+     * The candidate attribute, at most 4096 bytes. At most 64 per end and
+     * PeerConnection.
+     *
+     * @generated from field: string candidate = 1;
+     */
+    candidate: string;
+    /**
+     * The media stream identification tag of the candidate (RFC 5888).
+     *
+     * @generated from field: string sdp_mid = 2;
+     */
+    sdpMid: string;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.IceCandidate.
+ * Use `create(IceCandidateSchema)` to create a new message.
+ */
+export declare const IceCandidateSchema: GenMessage<IceCandidate>;
+/**
+ * The ICE servers a PeerConnection may use, as in W3C RTCConfiguration.
+ *
+ * @generated from message leaflow.fleet.transport.v1.RtcConfiguration
+ */
+export type RtcConfiguration = Message<"leaflow.fleet.transport.v1.RtcConfiguration"> & {
+    /**
+     * At most 8.
+     *
+     * @generated from field: repeated leaflow.fleet.transport.v1.IceServer ice_servers = 1;
+     */
+    iceServers: IceServer[];
+    /**
+     * Which candidates ICE may use.
+     *
+     * @generated from field: leaflow.fleet.transport.v1.IceTransportPolicy ice_transport_policy = 2;
+     */
+    iceTransportPolicy: IceTransportPolicy;
+    /**
+     * After this time no PeerConnection starts with these servers. The TURN
+     * credentials themselves last longer, so a relayed path outlives it.
+     *
+     * @generated from field: google.protobuf.Timestamp expires_at = 3;
+     */
+    expiresAt?: Timestamp | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.RtcConfiguration.
+ * Use `create(RtcConfigurationSchema)` to create a new message.
+ */
+export declare const RtcConfigurationSchema: GenMessage<RtcConfiguration>;
+/**
+ * A STUN or TURN server (RFC 8489, RFC 8656), as in W3C RTCIceServer.
+ *
+ * @generated from message leaflow.fleet.transport.v1.IceServer
+ */
+export type IceServer = Message<"leaflow.fleet.transport.v1.IceServer"> & {
+    /**
+     * stun:, turn: or turns: URIs (RFC 7064, RFC 7065).
+     *
+     * @generated from field: repeated string urls = 1;
+     */
+    urls: string[];
+    /**
+     * The TURN username. Empty for STUN.
+     *
+     * @generated from field: string username = 2;
+     */
+    username: string;
+    /**
+     * The TURN password. Empty for STUN. Never logged.
+     *
+     * @generated from field: string credential = 3;
+     */
+    credential: string;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.IceServer.
+ * Use `create(IceServerSchema)` to create a new message.
+ */
+export declare const IceServerSchema: GenMessage<IceServer>;
+/**
+ * A PeerAuthorization signed by the service.
+ *
+ * @generated from message leaflow.fleet.transport.v1.SignedPeerAuthorization
+ */
+export type SignedPeerAuthorization = Message<"leaflow.fleet.transport.v1.SignedPeerAuthorization"> & {
+    /**
+     * The signing key that signed it.
+     *
+     * @generated from field: string key_id = 1;
+     */
+    keyId: string;
+    /**
+     * A serialized PeerAuthorization.
+     *
+     * @generated from field: bytes authorization = 2;
+     */
+    authorization: Uint8Array;
+    /**
+     * Ed25519 signature over the UTF-8 string
+     * "leaflow.fleet.transport.v1.PeerAuthorization", one zero byte
+     * and authorization.
+     *
+     * @generated from field: bytes signature = 3;
+     */
+    signature: Uint8Array;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.SignedPeerAuthorization.
+ * Use `create(SignedPeerAuthorizationSchema)` to create a new message.
+ */
+export declare const SignedPeerAuthorizationSchema: GenMessage<SignedPeerAuthorization>;
+/**
+ * The service's statement that one PeerConnection joins this participant to
+ * this session with these two DTLS certificates. Both ends check the signature,
+ * every field and the lifetime before sending application data; DTLS alone does
+ * not authorize.
+ *
+ * @generated from message leaflow.fleet.transport.v1.PeerAuthorization
+ */
+export type PeerAuthorization = Message<"leaflow.fleet.transport.v1.PeerAuthorization"> & {
+    /**
+     * The HTTPS origin of the service that signed it.
+     *
+     * @generated from field: string issuer = 1;
+     */
+    issuer: string;
+    /**
+     * The machine of the session.
+     *
+     * @generated from field: string machine_id = 2;
+     */
+    machineId: string;
+    /**
+     * The session.
+     *
+     * @generated from field: string session_id = 3;
+     */
+    sessionId: string;
+    /**
+     * The participant.
+     *
+     * @generated from field: uint64 participant_id = 4;
+     */
+    participantId: bigint;
+    /**
+     * The PeerConnection.
+     *
+     * @generated from field: bytes peer_connection_id = 5;
+     */
+    peerConnectionId: Uint8Array;
+    /**
+     * SHA-256 fingerprint of the participant's DTLS certificate, from its offer.
+     *
+     * @generated from field: bytes participant_fingerprint_sha256 = 6;
+     */
+    participantFingerprintSha256: Uint8Array;
+    /**
+     * SHA-256 fingerprint of the Agent's DTLS certificate, from its answer.
+     *
+     * @generated from field: bytes agent_fingerprint_sha256 = 7;
+     */
+    agentFingerprintSha256: Uint8Array;
+    /**
+     * SHA-256 of the participant's authorization that both ends hold: the exact
+     * serialized bytes the service signed. A renewal
+     * names the participant's current authorization, which may be a renewed one
+     * through the Fleet API.
+     *
+     * @generated from field: bytes participant_authorization_sha256 = 8;
+     */
+    participantAuthorizationSha256: Uint8Array;
+    /**
+     * When the service signed it.
+     *
+     * @generated from field: google.protobuf.Timestamp issued_at = 9;
+     */
+    issuedAt?: Timestamp | undefined;
+    /**
+     * The end of the PeerConnection's authorization: the end of the
+     * participant's current authorization.
+     *
+     * @generated from field: google.protobuf.Timestamp expires_at = 10;
+     */
+    expiresAt?: Timestamp | undefined;
+    /**
+     * The end of the current lease, at most 30 seconds after issued_at and no
+     * later than expires_at. The participant renews it through the Fleet API with
+     * the PeerAuthorization it holds, and passes each renewed one to the session
+     * on "binding" (Packet.peer_authorization); the service also sends it on the
+     * session's control connection, so that either path keeps the lease while
+     * the other is down. The session takes whichever arrives first and ignores
+     * one whose lease does not end later than the one it holds. It takes one
+     * that the service signed with a key of its SigningKeys, that names the
+     * same PeerConnection, participant, fingerprints and session, and whose
+     * participant_authorization_sha256 names the participant's authorization it
+     * holds or, while that one has not expired, the authorization it replaced.
+     * Each end stops sending application data when the lease runs out, and goes
+     * on once it holds a later one.
+     *
+     * @generated from field: google.protobuf.Timestamp lease_expires_at = 11;
+     */
+    leaseExpiresAt?: Timestamp | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.transport.v1.PeerAuthorization.
+ * Use `create(PeerAuthorizationSchema)` to create a new message.
+ */
+export declare const PeerAuthorizationSchema: GenMessage<PeerAuthorization>;
+/**
+ * Why a channel was refused. Values follow RFC 4254 §5.1.
+ *
+ * @generated from enum leaflow.fleet.transport.v1.ChannelOpenFailureReason
+ */
+export declare enum ChannelOpenFailureReason {
+    /**
+     * @generated from enum value: CHANNEL_OPEN_FAILURE_REASON_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * The participant's authorization or the session's policy does not allow it,
+     * or the channel type allows one channel and one is open.
+     *
+     * @generated from enum value: CHANNEL_OPEN_FAILURE_REASON_ADMINISTRATIVELY_PROHIBITED = 1;
+     */
+    ADMINISTRATIVELY_PROHIBITED = 1,
+    /**
+     * What the channel leads to cannot be reached, such as a TCP endpoint.
+     *
+     * @generated from enum value: CHANNEL_OPEN_FAILURE_REASON_CONNECT_FAILED = 2;
+     */
+    CONNECT_FAILED = 2,
+    /**
+     * The receiver does not know the channel type.
+     *
+     * @generated from enum value: CHANNEL_OPEN_FAILURE_REASON_UNKNOWN_CHANNEL_TYPE = 3;
+     */
+    UNKNOWN_CHANNEL_TYPE = 3,
+    /**
+     * Too many channels, or no memory.
+     *
+     * @generated from enum value: CHANNEL_OPEN_FAILURE_REASON_RESOURCE_SHORTAGE = 4;
+     */
+    RESOURCE_SHORTAGE = 4
+}
+/**
+ * Describes the enum leaflow.fleet.transport.v1.ChannelOpenFailureReason.
+ */
+export declare const ChannelOpenFailureReasonSchema: GenEnum<ChannelOpenFailureReason>;
+/**
+ * Why a channel was closed. Values follow RFC 9000 §20.1.
+ *
+ * @generated from enum leaflow.fleet.transport.v1.ChannelErrorCode
+ */
+export declare enum ChannelErrorCode {
+    /**
+     * @generated from enum value: CHANNEL_ERROR_CODE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * An orderly close.
+     *
+     * @generated from enum value: CHANNEL_ERROR_CODE_NO_ERROR = 1;
+     */
+    NO_ERROR = 1,
+    /**
+     * The channel is no longer wanted, such as a frame overtaken by a newer
+     * one. An incomplete message of the channel is discarded.
+     *
+     * @generated from enum value: CHANNEL_ERROR_CODE_CANCELLED = 2;
+     */
+    CANCELLED = 2,
+    /**
+     * The peer sent more than its credit allowed.
+     *
+     * @generated from enum value: CHANNEL_ERROR_CODE_FLOW_CONTROL_ERROR = 3;
+     */
+    FLOW_CONTROL_ERROR = 3,
+    /**
+     * The channel carried a malformed or unexpected message, or one larger than
+     * max_message_size.
+     *
+     * @generated from enum value: CHANNEL_ERROR_CODE_PROTOCOL_VIOLATION = 4;
+     */
+    PROTOCOL_VIOLATION = 4,
+    /**
+     * The sender failed.
+     *
+     * @generated from enum value: CHANNEL_ERROR_CODE_INTERNAL_ERROR = 5;
+     */
+    INTERNAL_ERROR = 5
+}
+/**
+ * Describes the enum leaflow.fleet.transport.v1.ChannelErrorCode.
+ */
+export declare const ChannelErrorCodeSchema: GenEnum<ChannelErrorCode>;
+/**
+ * The type of a SessionDescription (W3C RTCSdpType).
+ *
+ * @generated from enum leaflow.fleet.transport.v1.SdpType
+ */
+export declare enum SdpType {
+    /**
+     * @generated from enum value: SDP_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: SDP_TYPE_OFFER = 1;
+     */
+    OFFER = 1,
+    /**
+     * @generated from enum value: SDP_TYPE_ANSWER = 2;
+     */
+    ANSWER = 2
+}
+/**
+ * Describes the enum leaflow.fleet.transport.v1.SdpType.
+ */
+export declare const SdpTypeSchema: GenEnum<SdpType>;
+/**
+ * Which ICE candidates may be used (W3C RTCIceTransportPolicy).
+ *
+ * @generated from enum leaflow.fleet.transport.v1.IceTransportPolicy
+ */
+export declare enum IceTransportPolicy {
+    /**
+     * @generated from enum value: ICE_TRANSPORT_POLICY_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * All candidates.
+     *
+     * @generated from enum value: ICE_TRANSPORT_POLICY_ALL = 1;
+     */
+    ALL = 1,
+    /**
+     * Only TURN relay candidates.
+     *
+     * @generated from enum value: ICE_TRANSPORT_POLICY_RELAY = 2;
+     */
+    RELAY = 2
+}
+/**
+ * Describes the enum leaflow.fleet.transport.v1.IceTransportPolicy.
+ */
+export declare const IceTransportPolicySchema: GenEnum<IceTransportPolicy>;