@leaflow/sdk 0.0.0-dev.451.gfd4baf5 → 0.0.0-dev.453.gab53eb4

package/dist/proto/leaflow/fleet/portforward/v1/portforward_pb.d.ts

@@ -0,0 +1,688 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { Duration } from "@bufbuild/protobuf/wkt";
+import type { Status } from "../../../../google/rpc/status_pb.js";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file leaflow/fleet/portforward/v1/portforward.proto.
+ */
+export declare const file_leaflow_fleet_portforward_v1_portforward: GenFile;
+/**
+ * A message from the session on the portforward channel.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.ServerMessage
+ */
+export type ServerMessage = Message<"leaflow.fleet.portforward.v1.ServerMessage"> & {
+    /**
+     * The message.
+     *
+     * @generated from oneof leaflow.fleet.portforward.v1.ServerMessage.message
+     */
+    message: {
+        /**
+         * A forward as it is now, in full.
+         *
+         * @generated from field: leaflow.fleet.portforward.v1.Forward forward = 1;
+         */
+        value: Forward;
+        case: "forward";
+    } | {
+        /**
+         * Ends the snapshot.
+         *
+         * @generated from field: leaflow.fleet.portforward.v1.SnapshotEnd snapshot_end = 2;
+         */
+        value: SnapshotEnd;
+        case: "snapshotEnd";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.ServerMessage.
+ * Use `create(ServerMessageSchema)` to create a new message.
+ */
+export declare const ServerMessageSchema: GenMessage<ServerMessage>;
+/**
+ * An IP endpoint.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.Endpoint
+ */
+export type Endpoint = Message<"leaflow.fleet.portforward.v1.Endpoint"> & {
+    /**
+     * An IPv4 or IPv6 address literal, with a zone for link-local IPv6
+     * addresses (RFC 4007), such as "127.0.0.1" or "fe80::1%eth0".
+     *
+     * @generated from field: string address = 1;
+     */
+    address: string;
+    /**
+     * The port, 1 to 65535. A listener may ask for 0 and learns the port the
+     * system chose.
+     *
+     * @generated from field: uint32 port = 2;
+     */
+    port: number;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.Endpoint.
+ * Use `create(EndpointSchema)` to create a new message.
+ */
+export declare const EndpointSchema: GenMessage<Endpoint>;
+/**
+ * What a forward does.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.ForwardSpec
+ */
+export type ForwardSpec = Message<"leaflow.fleet.portforward.v1.ForwardSpec"> & {
+    /**
+     * Which way it goes.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.ForwardDirection direction = 1;
+     */
+    direction: ForwardDirection;
+    /**
+     * Where the listening side listens.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Endpoint listen_endpoint = 2;
+     */
+    listenEndpoint?: Endpoint | undefined;
+    /**
+     * Where the other side connects.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Endpoint target_endpoint = 3;
+     */
+    targetEndpoint?: Endpoint | undefined;
+    /**
+     * TCP or UDP.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.ForwardProtocol protocol = 4;
+     */
+    protocol: ForwardProtocol;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.ForwardSpec.
+ * Use `create(ForwardSpecSchema)` to create a new message.
+ */
+export declare const ForwardSpecSchema: GenMessage<ForwardSpec>;
+/**
+ * A forward of this connection.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.Forward
+ */
+export type Forward = Message<"leaflow.fleet.portforward.v1.Forward"> & {
+    /**
+     * Chosen by the session, never 0 and never reused in the session.
+     *
+     * @generated from field: uint64 forward_id = 1;
+     */
+    forwardId: bigint;
+    /**
+     * What it does.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.ForwardSpec spec = 2;
+     */
+    spec?: ForwardSpec | undefined;
+    /**
+     * Its state.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.ForwardState state = 3;
+     */
+    state: ForwardState;
+    /**
+     * Where the listening side actually listens, with the port it got.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Endpoint bound_endpoint = 4;
+     */
+    boundEndpoint?: Endpoint | undefined;
+    /**
+     * Its open connections and associations.
+     *
+     * @generated from field: uint32 connection_count = 5;
+     */
+    connectionCount: number;
+    /**
+     * Why it failed. Unset otherwise.
+     *
+     * @generated from field: google.rpc.Status error = 6;
+     */
+    error?: Status | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.Forward.
+ * Use `create(ForwardSchema)` to create a new message.
+ */
+export declare const ForwardSchema: GenMessage<Forward>;
+/**
+ * Ends the snapshot.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.SnapshotEnd
+ */
+export type SnapshotEnd = Message<"leaflow.fleet.portforward.v1.SnapshotEnd"> & {};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.SnapshotEnd.
+ * Use `create(SnapshotEndSchema)` to create a new message.
+ */
+export declare const SnapshotEndSchema: GenMessage<SnapshotEnd>;
+/**
+ * The request of CreateForward.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.CreateForwardRequest
+ */
+export type CreateForwardRequest = Message<"leaflow.fleet.portforward.v1.CreateForwardRequest"> & {
+    /**
+     * What the forward does.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.ForwardSpec spec = 1;
+     */
+    spec?: ForwardSpec | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.CreateForwardRequest.
+ * Use `create(CreateForwardRequestSchema)` to create a new message.
+ */
+export declare const CreateForwardRequestSchema: GenMessage<CreateForwardRequest>;
+/**
+ * The response of CreateForward.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.CreateForwardResponse
+ */
+export type CreateForwardResponse = Message<"leaflow.fleet.portforward.v1.CreateForwardResponse"> & {
+    /**
+     * The forward.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Forward forward = 1;
+     */
+    forward?: Forward | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.CreateForwardResponse.
+ * Use `create(CreateForwardResponseSchema)` to create a new message.
+ */
+export declare const CreateForwardResponseSchema: GenMessage<CreateForwardResponse>;
+/**
+ * The request of ReportListenerReady.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.ReportListenerReadyRequest
+ */
+export type ReportListenerReadyRequest = Message<"leaflow.fleet.portforward.v1.ReportListenerReadyRequest"> & {
+    /**
+     * The forward.
+     *
+     * @generated from field: uint64 forward_id = 1;
+     */
+    forwardId: bigint;
+    /**
+     * Where the participant listens.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Endpoint bound_endpoint = 2;
+     */
+    boundEndpoint?: Endpoint | undefined;
+    /**
+     * Why the participant could not listen; the forward then fails. Unset on
+     * success.
+     *
+     * @generated from field: google.rpc.Status error = 3;
+     */
+    error?: Status | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.ReportListenerReadyRequest.
+ * Use `create(ReportListenerReadyRequestSchema)` to create a new message.
+ */
+export declare const ReportListenerReadyRequestSchema: GenMessage<ReportListenerReadyRequest>;
+/**
+ * The response of ReportListenerReady.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.ReportListenerReadyResponse
+ */
+export type ReportListenerReadyResponse = Message<"leaflow.fleet.portforward.v1.ReportListenerReadyResponse"> & {
+    /**
+     * The forward.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Forward forward = 1;
+     */
+    forward?: Forward | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.ReportListenerReadyResponse.
+ * Use `create(ReportListenerReadyResponseSchema)` to create a new message.
+ */
+export declare const ReportListenerReadyResponseSchema: GenMessage<ReportListenerReadyResponse>;
+/**
+ * The request of DeleteForward.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.DeleteForwardRequest
+ */
+export type DeleteForwardRequest = Message<"leaflow.fleet.portforward.v1.DeleteForwardRequest"> & {
+    /**
+     * The forward.
+     *
+     * @generated from field: uint64 forward_id = 1;
+     */
+    forwardId: bigint;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.DeleteForwardRequest.
+ * Use `create(DeleteForwardRequestSchema)` to create a new message.
+ */
+export declare const DeleteForwardRequestSchema: GenMessage<DeleteForwardRequest>;
+/**
+ * The response of DeleteForward.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.DeleteForwardResponse
+ */
+export type DeleteForwardResponse = Message<"leaflow.fleet.portforward.v1.DeleteForwardResponse"> & {};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.DeleteForwardResponse.
+ * Use `create(DeleteForwardResponseSchema)` to create a new message.
+ */
+export declare const DeleteForwardResponseSchema: GenMessage<DeleteForwardResponse>;
+/**
+ * The first message of a TCP channel.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.TcpOpen
+ */
+export type TcpOpen = Message<"leaflow.fleet.portforward.v1.TcpOpen"> & {
+    /**
+     * The forward whose listener accepted the connection.
+     *
+     * @generated from field: uint64 forward_id = 1;
+     */
+    forwardId: bigint;
+    /**
+     * Where the connection came from. For display only.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Endpoint originator = 2;
+     */
+    originator?: Endpoint | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.TcpOpen.
+ * Use `create(TcpOpenSchema)` to create a new message.
+ */
+export declare const TcpOpenSchema: GenMessage<TcpOpen>;
+/**
+ * A message of a TCP channel after TcpOpen, from either end.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.TcpMessage
+ */
+export type TcpMessage = Message<"leaflow.fleet.portforward.v1.TcpMessage"> & {
+    /**
+     * The message.
+     *
+     * @generated from oneof leaflow.fleet.portforward.v1.TcpMessage.message
+     */
+    message: {
+        /**
+         * The next bytes of the connection, at most 64 KiB.
+         *
+         * @generated from field: bytes data = 1;
+         */
+        value: Uint8Array;
+        case: "data";
+    } | {
+        /**
+         * The sender sends nothing more (TCP half-close; RFC 4254 §5.3 "eof").
+         * Once all earlier data reached the socket, the receiver shuts down its
+         * writing; the other direction stays open. The channel closes once both
+         * ends have shut down.
+         *
+         * @generated from field: leaflow.fleet.portforward.v1.TcpShutdown shutdown = 2;
+         */
+        value: TcpShutdown;
+        case: "shutdown";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.TcpMessage.
+ * Use `create(TcpMessageSchema)` to create a new message.
+ */
+export declare const TcpMessageSchema: GenMessage<TcpMessage>;
+/**
+ * The sender sends nothing more on the connection.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.TcpShutdown
+ */
+export type TcpShutdown = Message<"leaflow.fleet.portforward.v1.TcpShutdown"> & {};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.TcpShutdown.
+ * Use `create(TcpShutdownSchema)` to create a new message.
+ */
+export declare const TcpShutdownSchema: GenMessage<TcpShutdown>;
+/**
+ * The first message of a UDP channel.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.UdpOpen
+ */
+export type UdpOpen = Message<"leaflow.fleet.portforward.v1.UdpOpen"> & {
+    /**
+     * The forward whose listener received the first packet.
+     *
+     * @generated from field: uint64 forward_id = 1;
+     */
+    forwardId: bigint;
+    /**
+     * The peer the packets come from. For display only.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.Endpoint originator = 2;
+     */
+    originator?: Endpoint | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.UdpOpen.
+ * Use `create(UdpOpenSchema)` to create a new message.
+ */
+export declare const UdpOpenSchema: GenMessage<UdpOpen>;
+/**
+ * One UDP packet, sent as a Datagram of a UDP channel.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.UdpPacket
+ */
+export type UdpPacket = Message<"leaflow.fleet.portforward.v1.UdpPacket"> & {
+    /**
+     * The payload; empty is a valid empty packet. At most
+     * PortForwardPolicy.max_udp_datagram_bytes and what the transport allows.
+     *
+     * @generated from field: bytes data = 1;
+     */
+    data: Uint8Array;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.UdpPacket.
+ * Use `create(UdpPacketSchema)` to create a new message.
+ */
+export declare const UdpPacketSchema: GenMessage<UdpPacket>;
+/**
+ * What a participant may forward. Carried in the participant's signed
+ * authorization; without it the participant forwards nothing.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.PortForwardPolicy
+ */
+export type PortForwardPolicy = Message<"leaflow.fleet.portforward.v1.PortForwardPolicy"> & {
+    /**
+     * LOCAL_TO_REMOTE forwards are allowed.
+     *
+     * @generated from field: bool local_to_remote_allowed = 1;
+     */
+    localToRemoteAllowed: boolean;
+    /**
+     * REMOTE_TO_LOCAL forwards are allowed.
+     *
+     * @generated from field: bool remote_to_local_allowed = 2;
+     */
+    remoteToLocalAllowed: boolean;
+    /**
+     * Where the participant may listen for LOCAL_TO_REMOTE.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.EndpointPolicy local_listeners = 3;
+     */
+    localListeners?: EndpointPolicy | undefined;
+    /**
+     * Where the session may connect for LOCAL_TO_REMOTE.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.EndpointPolicy remote_targets = 4;
+     */
+    remoteTargets?: EndpointPolicy | undefined;
+    /**
+     * Where the session may listen for REMOTE_TO_LOCAL.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.EndpointPolicy remote_listeners = 5;
+     */
+    remoteListeners?: EndpointPolicy | undefined;
+    /**
+     * Where the participant may connect for REMOTE_TO_LOCAL.
+     *
+     * @generated from field: leaflow.fleet.portforward.v1.EndpointPolicy local_targets = 6;
+     */
+    localTargets?: EndpointPolicy | undefined;
+    /**
+     * The most forwards at once, at most 32. 0: 8.
+     *
+     * @generated from field: uint32 max_forwards = 7;
+     */
+    maxForwards: number;
+    /**
+     * The most connections and associations at once, at most 256. 0: 32.
+     *
+     * @generated from field: uint32 max_connections = 8;
+     */
+    maxConnections: number;
+    /**
+     * The longest wait for one connection to a target, at most 60 seconds.
+     * Unset: 15 seconds.
+     *
+     * @generated from field: google.protobuf.Duration connect_timeout = 9;
+     */
+    connectTimeout?: Duration | undefined;
+    /**
+     * The longest a connection may last. Unset: until the authorization ends.
+     *
+     * @generated from field: google.protobuf.Duration max_connection_duration = 10;
+     */
+    maxConnectionDuration?: Duration | undefined;
+    /**
+     * The longest a connection may stay idle. Unset: no limit.
+     *
+     * @generated from field: google.protobuf.Duration idle_timeout = 11;
+     */
+    idleTimeout?: Duration | undefined;
+    /**
+     * UDP forwards are allowed. TCP permissions do not imply it.
+     *
+     * @generated from field: bool udp_allowed = 12;
+     */
+    udpAllowed: boolean;
+    /**
+     * The largest UDP payload, at most 65507. 0: 1100.
+     *
+     * @generated from field: uint32 max_udp_datagram_bytes = 13;
+     */
+    maxUdpDatagramBytes: number;
+    /**
+     * The longest a UDP association may stay idle, at most 5 minutes. Unset:
+     * 60 seconds.
+     *
+     * @generated from field: google.protobuf.Duration udp_idle_timeout = 14;
+     */
+    udpIdleTimeout?: Duration | undefined;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.PortForwardPolicy.
+ * Use `create(PortForwardPolicySchema)` to create a new message.
+ */
+export declare const PortForwardPolicySchema: GenMessage<PortForwardPolicy>;
+/**
+ * The addresses and ports a side may listen on or connect to. An endpoint is
+ * allowed when its address lies in one of the prefixes and its port in one
+ * of the ranges; empty lists allow nothing.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.EndpointPolicy
+ */
+export type EndpointPolicy = Message<"leaflow.fleet.portforward.v1.EndpointPolicy"> & {
+    /**
+     * IPv4 or IPv6 prefixes in CIDR notation (RFC 4632), such as "127.0.0.0/8";
+     * "0.0.0.0/0" and "::/0" allow any address.
+     *
+     * @generated from field: repeated string prefixes = 1;
+     */
+    prefixes: string[];
+    /**
+     * The ports.
+     *
+     * @generated from field: repeated leaflow.fleet.portforward.v1.PortRange ports = 2;
+     */
+    ports: PortRange[];
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.EndpointPolicy.
+ * Use `create(EndpointPolicySchema)` to create a new message.
+ */
+export declare const EndpointPolicySchema: GenMessage<EndpointPolicy>;
+/**
+ * Ports from first to last, inclusive, each 1 to 65535.
+ *
+ * @generated from message leaflow.fleet.portforward.v1.PortRange
+ */
+export type PortRange = Message<"leaflow.fleet.portforward.v1.PortRange"> & {
+    /**
+     * The first port.
+     *
+     * @generated from field: uint32 first = 1;
+     */
+    first: number;
+    /**
+     * The last port.
+     *
+     * @generated from field: uint32 last = 2;
+     */
+    last: number;
+};
+/**
+ * Describes the message leaflow.fleet.portforward.v1.PortRange.
+ * Use `create(PortRangeSchema)` to create a new message.
+ */
+export declare const PortRangeSchema: GenMessage<PortRange>;
+/**
+ * Which way a forward goes.
+ *
+ * @generated from enum leaflow.fleet.portforward.v1.ForwardDirection
+ */
+export declare enum ForwardDirection {
+    /**
+     * @generated from enum value: FORWARD_DIRECTION_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * The participant listens; the session connects (ssh -L).
+     *
+     * @generated from enum value: FORWARD_DIRECTION_LOCAL_TO_REMOTE = 1;
+     */
+    LOCAL_TO_REMOTE = 1,
+    /**
+     * The session listens; the participant connects (ssh -R).
+     *
+     * @generated from enum value: FORWARD_DIRECTION_REMOTE_TO_LOCAL = 2;
+     */
+    REMOTE_TO_LOCAL = 2
+}
+/**
+ * Describes the enum leaflow.fleet.portforward.v1.ForwardDirection.
+ */
+export declare const ForwardDirectionSchema: GenEnum<ForwardDirection>;
+/**
+ * The transport protocol of a forward.
+ *
+ * @generated from enum leaflow.fleet.portforward.v1.ForwardProtocol
+ */
+export declare enum ForwardProtocol {
+    /**
+     * @generated from enum value: FORWARD_PROTOCOL_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * TCP.
+     *
+     * @generated from enum value: FORWARD_PROTOCOL_TCP = 1;
+     */
+    TCP = 1,
+    /**
+     * UDP.
+     *
+     * @generated from enum value: FORWARD_PROTOCOL_UDP = 2;
+     */
+    UDP = 2
+}
+/**
+ * Describes the enum leaflow.fleet.portforward.v1.ForwardProtocol.
+ */
+export declare const ForwardProtocolSchema: GenEnum<ForwardProtocol>;
+/**
+ * The state of a forward.
+ *
+ * @generated from enum leaflow.fleet.portforward.v1.ForwardState
+ */
+export declare enum ForwardState {
+    /**
+     * @generated from enum value: FORWARD_STATE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Created; the participant's listener is not reported yet. Nothing is
+     * accepted.
+     *
+     * @generated from enum value: FORWARD_STATE_PREPARING = 1;
+     */
+    PREPARING = 1,
+    /**
+     * Listening and forwarding.
+     *
+     * @generated from enum value: FORWARD_STATE_ACTIVE = 2;
+     */
+    ACTIVE = 2,
+    /**
+     * Deleted.
+     *
+     * @generated from enum value: FORWARD_STATE_CLOSED = 3;
+     */
+    CLOSED = 3,
+    /**
+     * It could not listen or stopped working.
+     *
+     * @generated from enum value: FORWARD_STATE_FAILED = 4;
+     */
+    FAILED = 4
+}
+/**
+ * Describes the enum leaflow.fleet.portforward.v1.ForwardState.
+ */
+export declare const ForwardStateSchema: GenEnum<ForwardState>;
+/**
+ * Creates and deletes forwards. The session checks every request against the
+ * participant's authorization before anything listens or connects.
+ *
+ * @generated from service leaflow.fleet.portforward.v1.PortForwardService
+ */
+export declare const PortForwardService: GenService<{
+    /**
+     * Creates a forward. For REMOTE_TO_LOCAL the session listens and the forward
+     * is ACTIVE; for LOCAL_TO_REMOTE it is PREPARING until the participant
+     * listens and calls ReportListenerReady. Fails with PERMISSION_DENIED for
+     * endpoints the policy does not allow and RESOURCE_EXHAUSTED beyond its
+     * limits.
+     *
+     * @generated from rpc leaflow.fleet.portforward.v1.PortForwardService.CreateForward
+     */
+    createForward: {
+        methodKind: "unary";
+        input: typeof CreateForwardRequestSchema;
+        output: typeof CreateForwardResponseSchema;
+    };
+    /**
+     * Reports that the participant listens for a LOCAL_TO_REMOTE forward, on the
+     * endpoint it actually bound. The session checks the endpoint against the
+     * policy again and makes the forward ACTIVE; the participant accepts no
+     * connection before. When it refuses, the participant closes its listener.
+     *
+     * @generated from rpc leaflow.fleet.portforward.v1.PortForwardService.ReportListenerReady
+     */
+    reportListenerReady: {
+        methodKind: "unary";
+        input: typeof ReportListenerReadyRequestSchema;
+        output: typeof ReportListenerReadyResponseSchema;
+    };
+    /**
+     * Deletes a forward and resets all its connections. Deleting one that is
+     * gone succeeds.
+     *
+     * @generated from rpc leaflow.fleet.portforward.v1.PortForwardService.DeleteForward
+     */
+    deleteForward: {
+        methodKind: "unary";
+        input: typeof DeleteForwardRequestSchema;
+        output: typeof DeleteForwardResponseSchema;
+    };
+}>;