@useairfoil/flight 0.1.0

package/src/proto/Flight.ts

@@ -0,0 +1,2627 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               unknown
+// source: Flight.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallContext, type CallOptions } from "nice-grpc-common";
+import { Timestamp } from "./google/protobuf/timestamp.js";
+import { messageTypeRegistry } from "./typeRegistry.js";
+
+export const protobufPackage = "arrow.flight.protocol";
+
+/**
+ * The result of a cancel operation.
+ *
+ * This is used by CancelFlightInfoResult.status.
+ */
+export enum CancelStatus {
+  /**
+   * UNSPECIFIED - The cancellation status is unknown. Servers should avoid using
+   * this value (send a NOT_FOUND error if the requested query is
+   * not known). Clients can retry the request.
+   */
+  UNSPECIFIED = 0,
+  /**
+   * CANCELLED - The cancellation request is complete. Subsequent requests with
+   * the same payload may return CANCELLED or a NOT_FOUND error.
+   */
+  CANCELLED = 1,
+  /**
+   * CANCELLING - The cancellation request is in progress. The client may retry
+   * the cancellation request.
+   */
+  CANCELLING = 2,
+  /**
+   * NOT_CANCELLABLE - The query is not cancellable. The client should not retry the
+   * cancellation request.
+   */
+  NOT_CANCELLABLE = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function cancelStatusFromJSON(object: any): CancelStatus {
+  switch (object) {
+    case 0:
+    case "CANCEL_STATUS_UNSPECIFIED":
+      return CancelStatus.UNSPECIFIED;
+    case 1:
+    case "CANCEL_STATUS_CANCELLED":
+      return CancelStatus.CANCELLED;
+    case 2:
+    case "CANCEL_STATUS_CANCELLING":
+      return CancelStatus.CANCELLING;
+    case 3:
+    case "CANCEL_STATUS_NOT_CANCELLABLE":
+      return CancelStatus.NOT_CANCELLABLE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return CancelStatus.UNRECOGNIZED;
+  }
+}
+
+export function cancelStatusToJSON(object: CancelStatus): string {
+  switch (object) {
+    case CancelStatus.UNSPECIFIED:
+      return "CANCEL_STATUS_UNSPECIFIED";
+    case CancelStatus.CANCELLED:
+      return "CANCEL_STATUS_CANCELLED";
+    case CancelStatus.CANCELLING:
+      return "CANCEL_STATUS_CANCELLING";
+    case CancelStatus.NOT_CANCELLABLE:
+      return "CANCEL_STATUS_NOT_CANCELLABLE";
+    case CancelStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** The request that a client provides to a server on handshake. */
+export interface HandshakeRequest {
+  $type: "arrow.flight.protocol.HandshakeRequest";
+  /** A defined protocol version */
+  readonly protocolVersion: bigint;
+  /** Arbitrary auth/handshake info. */
+  readonly payload: Uint8Array;
+}
+
+export interface HandshakeResponse {
+  $type: "arrow.flight.protocol.HandshakeResponse";
+  /** A defined protocol version */
+  readonly protocolVersion: bigint;
+  /** Arbitrary auth/handshake info. */
+  readonly payload: Uint8Array;
+}
+
+/** A message for doing simple auth. */
+export interface BasicAuth {
+  $type: "arrow.flight.protocol.BasicAuth";
+  readonly username: string;
+  readonly password: string;
+}
+
+export interface Empty {
+  $type: "arrow.flight.protocol.Empty";
+}
+
+/**
+ * Describes an available action, including both the name used for execution
+ * along with a short description of the purpose of the action.
+ */
+export interface ActionType {
+  $type: "arrow.flight.protocol.ActionType";
+  readonly type: string;
+  readonly description: string;
+}
+
+/**
+ * A service specific expression that can be used to return a limited set
+ * of available Arrow Flight streams.
+ */
+export interface Criteria {
+  $type: "arrow.flight.protocol.Criteria";
+  readonly expression: Uint8Array;
+}
+
+/** An opaque action specific for the service. */
+export interface Action {
+  $type: "arrow.flight.protocol.Action";
+  readonly type: string;
+  readonly body: Uint8Array;
+}
+
+/**
+ * The request of the CancelFlightInfo action.
+ *
+ * The request should be stored in Action.body.
+ */
+export interface CancelFlightInfoRequest {
+  $type: "arrow.flight.protocol.CancelFlightInfoRequest";
+  readonly info: FlightInfo | undefined;
+}
+
+/**
+ * The request of the RenewFlightEndpoint action.
+ *
+ * The request should be stored in Action.body.
+ */
+export interface RenewFlightEndpointRequest {
+  $type: "arrow.flight.protocol.RenewFlightEndpointRequest";
+  readonly endpoint: FlightEndpoint | undefined;
+}
+
+/** An opaque result returned after executing an action. */
+export interface Result {
+  $type: "arrow.flight.protocol.Result";
+  readonly body: Uint8Array;
+}
+
+/**
+ * The result of the CancelFlightInfo action.
+ *
+ * The result should be stored in Result.body.
+ */
+export interface CancelFlightInfoResult {
+  $type: "arrow.flight.protocol.CancelFlightInfoResult";
+  readonly status: CancelStatus;
+}
+
+/** Wrap the result of a getSchema call */
+export interface SchemaResult {
+  $type: "arrow.flight.protocol.SchemaResult";
+  /**
+   * The schema of the dataset in its IPC form:
+   *   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+   *   4 bytes - the byte length of the payload
+   *   a flatbuffer Message whose header is the Schema
+   */
+  readonly schema: Uint8Array;
+}
+
+/**
+ * The name or tag for a Flight. May be used as a way to retrieve or generate
+ * a flight or be used to expose a set of previously defined flights.
+ */
+export interface FlightDescriptor {
+  $type: "arrow.flight.protocol.FlightDescriptor";
+  readonly type: FlightDescriptor_DescriptorType;
+  /**
+   * Opaque value used to express a command. Should only be defined when
+   * type = CMD.
+   */
+  readonly cmd: Uint8Array;
+  /**
+   * List of strings identifying a particular dataset. Should only be defined
+   * when type = PATH.
+   */
+  readonly path: readonly string[];
+}
+
+/** Describes what type of descriptor is defined. */
+export enum FlightDescriptor_DescriptorType {
+  /** UNKNOWN - Protobuf pattern, not used. */
+  UNKNOWN = 0,
+  /**
+   * PATH - A named path that identifies a dataset. A path is composed of a string
+   * or list of strings describing a particular dataset. This is conceptually
+   *  similar to a path inside a filesystem.
+   */
+  PATH = 1,
+  /** CMD - An opaque command to generate a dataset. */
+  CMD = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function flightDescriptor_DescriptorTypeFromJSON(object: any): FlightDescriptor_DescriptorType {
+  switch (object) {
+    case 0:
+    case "UNKNOWN":
+      return FlightDescriptor_DescriptorType.UNKNOWN;
+    case 1:
+    case "PATH":
+      return FlightDescriptor_DescriptorType.PATH;
+    case 2:
+    case "CMD":
+      return FlightDescriptor_DescriptorType.CMD;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FlightDescriptor_DescriptorType.UNRECOGNIZED;
+  }
+}
+
+export function flightDescriptor_DescriptorTypeToJSON(object: FlightDescriptor_DescriptorType): string {
+  switch (object) {
+    case FlightDescriptor_DescriptorType.UNKNOWN:
+      return "UNKNOWN";
+    case FlightDescriptor_DescriptorType.PATH:
+      return "PATH";
+    case FlightDescriptor_DescriptorType.CMD:
+      return "CMD";
+    case FlightDescriptor_DescriptorType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * The access coordinates for retrieval of a dataset. With a FlightInfo, a
+ * consumer is able to determine how to retrieve a dataset.
+ */
+export interface FlightInfo {
+  $type: "arrow.flight.protocol.FlightInfo";
+  /**
+   * The schema of the dataset in its IPC form:
+   *   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+   *   4 bytes - the byte length of the payload
+   *   a flatbuffer Message whose header is the Schema
+   */
+  readonly schema: Uint8Array;
+  /** The descriptor associated with this info. */
+  readonly flightDescriptor:
+    | FlightDescriptor
+    | undefined;
+  /**
+   * A list of endpoints associated with the flight. To consume the
+   * whole flight, all endpoints (and hence all Tickets) must be
+   * consumed. Endpoints can be consumed in any order.
+   *
+   * In other words, an application can use multiple endpoints to
+   * represent partitioned data.
+   *
+   * If the returned data has an ordering, an application can use
+   * "FlightInfo.ordered = true" or should return the all data in a
+   * single endpoint. Otherwise, there is no ordering defined on
+   * endpoints or the data within.
+   *
+   * A client can read ordered data by reading data from returned
+   * endpoints, in order, from front to back.
+   *
+   * Note that a client may ignore "FlightInfo.ordered = true". If an
+   * ordering is important for an application, an application must
+   * choose one of them:
+   *
+   * * An application requires that all clients must read data in
+   *   returned endpoints order.
+   * * An application must return the all data in a single endpoint.
+   */
+  readonly endpoint: readonly FlightEndpoint[];
+  /** Set these to -1 if unknown. */
+  readonly totalRecords: bigint;
+  readonly totalBytes: bigint;
+  /** FlightEndpoints are in the same order as the data. */
+  readonly ordered: boolean;
+  /**
+   * Application-defined metadata.
+   *
+   * There is no inherent or required relationship between this
+   * and the app_metadata fields in the FlightEndpoints or resulting
+   * FlightData messages. Since this metadata is application-defined,
+   * a given application could define there to be a relationship,
+   * but there is none required by the spec.
+   */
+  readonly appMetadata: Uint8Array;
+}
+
+/** The information to process a long-running query. */
+export interface PollInfo {
+  $type: "arrow.flight.protocol.PollInfo";
+  /**
+   * The currently available results.
+   *
+   * If "flight_descriptor" is not specified, the query is complete
+   * and "info" specifies all results. Otherwise, "info" contains
+   * partial query results.
+   *
+   * Note that each PollInfo response contains a complete
+   * FlightInfo (not just the delta between the previous and current
+   * FlightInfo).
+   *
+   * Subsequent PollInfo responses may only append new endpoints to
+   * info.
+   *
+   * Clients can begin fetching results via DoGet(Ticket) with the
+   * ticket in the info before the query is
+   * completed. FlightInfo.ordered is also valid.
+   */
+  readonly info:
+    | FlightInfo
+    | undefined;
+  /**
+   * The descriptor the client should use on the next try.
+   * If unset, the query is complete.
+   */
+  readonly flightDescriptor:
+    | FlightDescriptor
+    | undefined;
+  /**
+   * Query progress. If known, must be in [0.0, 1.0] but need not be
+   * monotonic or nondecreasing. If unknown, do not set.
+   */
+  readonly progress?:
+    | number
+    | undefined;
+  /**
+   * Expiration time for this request. After this passes, the server
+   * might not accept the retry descriptor anymore (and the query may
+   * be cancelled). This may be updated on a call to PollFlightInfo.
+   */
+  readonly expirationTime: Date | undefined;
+}
+
+/** A particular stream or split associated with a flight. */
+export interface FlightEndpoint {
+  $type: "arrow.flight.protocol.FlightEndpoint";
+  /** Token used to retrieve this stream. */
+  readonly ticket:
+    | Ticket
+    | undefined;
+  /**
+   * A list of URIs where this ticket can be redeemed via DoGet().
+   *
+   * If the list is empty, the expectation is that the ticket can only
+   * be redeemed on the current service where the ticket was
+   * generated.
+   *
+   * If the list is not empty, the expectation is that the ticket can
+   * be redeemed at any of the locations, and that the data returned
+   * will be equivalent. In this case, the ticket may only be redeemed
+   * at one of the given locations, and not (necessarily) on the
+   * current service.
+   *
+   * In other words, an application can use multiple locations to
+   * represent redundant and/or load balanced services.
+   */
+  readonly location: readonly Location[];
+  /**
+   * Expiration time of this stream. If present, clients may assume
+   * they can retry DoGet requests. Otherwise, it is
+   * application-defined whether DoGet requests may be retried.
+   */
+  readonly expirationTime:
+    | Date
+    | undefined;
+  /**
+   * Application-defined metadata.
+   *
+   * There is no inherent or required relationship between this
+   * and the app_metadata fields in the FlightInfo or resulting
+   * FlightData messages. Since this metadata is application-defined,
+   * a given application could define there to be a relationship,
+   * but there is none required by the spec.
+   */
+  readonly appMetadata: Uint8Array;
+}
+
+/**
+ * A location where a Flight service will accept retrieval of a particular
+ * stream given a ticket.
+ */
+export interface Location {
+  $type: "arrow.flight.protocol.Location";
+  readonly uri: string;
+}
+
+/**
+ * An opaque identifier that the service can use to retrieve a particular
+ * portion of a stream.
+ *
+ * Tickets are meant to be single use. It is an error/application-defined
+ * behavior to reuse a ticket.
+ */
+export interface Ticket {
+  $type: "arrow.flight.protocol.Ticket";
+  readonly ticket: Uint8Array;
+}
+
+/** A batch of Arrow data as part of a stream of batches. */
+export interface FlightData {
+  $type: "arrow.flight.protocol.FlightData";
+  /**
+   * The descriptor of the data. This is only relevant when a client is
+   * starting a new DoPut stream.
+   */
+  readonly flightDescriptor:
+    | FlightDescriptor
+    | undefined;
+  /** Header for message data as described in Message.fbs::Message. */
+  readonly dataHeader: Uint8Array;
+  /** Application-defined metadata. */
+  readonly appMetadata: Uint8Array;
+  /**
+   * The actual batch of Arrow data. Preferably handled with minimal-copies
+   * coming last in the definition to help with sidecar patterns (it is
+   * expected that some implementations will fetch this field off the wire
+   * with specialized code to avoid extra memory copies).
+   */
+  readonly dataBody: Uint8Array;
+}
+
+/** The response message associated with the submission of a DoPut. */
+export interface PutResult {
+  $type: "arrow.flight.protocol.PutResult";
+  readonly appMetadata: Uint8Array;
+}
+
+function createBaseHandshakeRequest(): HandshakeRequest {
+  return { $type: "arrow.flight.protocol.HandshakeRequest", protocolVersion: 0n, payload: new Uint8Array(0) };
+}
+
+export const HandshakeRequest: MessageFns<HandshakeRequest, "arrow.flight.protocol.HandshakeRequest"> = {
+  $type: "arrow.flight.protocol.HandshakeRequest" as const,
+
+  encode(message: HandshakeRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.protocolVersion !== 0n) {
+      if (BigInt.asUintN(64, message.protocolVersion) !== message.protocolVersion) {
+        throw new globalThis.Error("value provided for field message.protocolVersion of type uint64 too large");
+      }
+      writer.uint32(8).uint64(message.protocolVersion);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(18).bytes(message.payload);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): HandshakeRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHandshakeRequest() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.protocolVersion = reader.uint64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.payload = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): HandshakeRequest {
+    return {
+      $type: HandshakeRequest.$type,
+      protocolVersion: isSet(object.protocolVersion) ? BigInt(object.protocolVersion) : 0n,
+      payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: HandshakeRequest): unknown {
+    const obj: any = {};
+    if (message.protocolVersion !== 0n) {
+      obj.protocolVersion = message.protocolVersion.toString();
+    }
+    if (message.payload.length !== 0) {
+      obj.payload = base64FromBytes(message.payload);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<HandshakeRequest>, I>>(base?: I): HandshakeRequest {
+    return HandshakeRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<HandshakeRequest>, I>>(object: I): HandshakeRequest {
+    const message = createBaseHandshakeRequest() as any;
+    message.protocolVersion = object.protocolVersion ?? 0n;
+    message.payload = object.payload ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(HandshakeRequest.$type, HandshakeRequest);
+
+function createBaseHandshakeResponse(): HandshakeResponse {
+  return { $type: "arrow.flight.protocol.HandshakeResponse", protocolVersion: 0n, payload: new Uint8Array(0) };
+}
+
+export const HandshakeResponse: MessageFns<HandshakeResponse, "arrow.flight.protocol.HandshakeResponse"> = {
+  $type: "arrow.flight.protocol.HandshakeResponse" as const,
+
+  encode(message: HandshakeResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.protocolVersion !== 0n) {
+      if (BigInt.asUintN(64, message.protocolVersion) !== message.protocolVersion) {
+        throw new globalThis.Error("value provided for field message.protocolVersion of type uint64 too large");
+      }
+      writer.uint32(8).uint64(message.protocolVersion);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(18).bytes(message.payload);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): HandshakeResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHandshakeResponse() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.protocolVersion = reader.uint64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.payload = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): HandshakeResponse {
+    return {
+      $type: HandshakeResponse.$type,
+      protocolVersion: isSet(object.protocolVersion) ? BigInt(object.protocolVersion) : 0n,
+      payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: HandshakeResponse): unknown {
+    const obj: any = {};
+    if (message.protocolVersion !== 0n) {
+      obj.protocolVersion = message.protocolVersion.toString();
+    }
+    if (message.payload.length !== 0) {
+      obj.payload = base64FromBytes(message.payload);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<HandshakeResponse>, I>>(base?: I): HandshakeResponse {
+    return HandshakeResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<HandshakeResponse>, I>>(object: I): HandshakeResponse {
+    const message = createBaseHandshakeResponse() as any;
+    message.protocolVersion = object.protocolVersion ?? 0n;
+    message.payload = object.payload ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(HandshakeResponse.$type, HandshakeResponse);
+
+function createBaseBasicAuth(): BasicAuth {
+  return { $type: "arrow.flight.protocol.BasicAuth", username: "", password: "" };
+}
+
+export const BasicAuth: MessageFns<BasicAuth, "arrow.flight.protocol.BasicAuth"> = {
+  $type: "arrow.flight.protocol.BasicAuth" as const,
+
+  encode(message: BasicAuth, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.username !== "") {
+      writer.uint32(18).string(message.username);
+    }
+    if (message.password !== "") {
+      writer.uint32(26).string(message.password);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): BasicAuth {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBasicAuth() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.username = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.password = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): BasicAuth {
+    return {
+      $type: BasicAuth.$type,
+      username: isSet(object.username) ? globalThis.String(object.username) : "",
+      password: isSet(object.password) ? globalThis.String(object.password) : "",
+    };
+  },
+
+  toJSON(message: BasicAuth): unknown {
+    const obj: any = {};
+    if (message.username !== "") {
+      obj.username = message.username;
+    }
+    if (message.password !== "") {
+      obj.password = message.password;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<BasicAuth>, I>>(base?: I): BasicAuth {
+    return BasicAuth.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<BasicAuth>, I>>(object: I): BasicAuth {
+    const message = createBaseBasicAuth() as any;
+    message.username = object.username ?? "";
+    message.password = object.password ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(BasicAuth.$type, BasicAuth);
+
+function createBaseEmpty(): Empty {
+  return { $type: "arrow.flight.protocol.Empty" };
+}
+
+export const Empty: MessageFns<Empty, "arrow.flight.protocol.Empty"> = {
+  $type: "arrow.flight.protocol.Empty" as const,
+
+  encode(_: Empty, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Empty {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEmpty() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): Empty {
+    return { $type: Empty.$type };
+  },
+
+  toJSON(_: Empty): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Empty>, I>>(base?: I): Empty {
+    return Empty.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Empty>, I>>(_: I): Empty {
+    const message = createBaseEmpty() as any;
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Empty.$type, Empty);
+
+function createBaseActionType(): ActionType {
+  return { $type: "arrow.flight.protocol.ActionType", type: "", description: "" };
+}
+
+export const ActionType: MessageFns<ActionType, "arrow.flight.protocol.ActionType"> = {
+  $type: "arrow.flight.protocol.ActionType" as const,
+
+  encode(message: ActionType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
+    }
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ActionType {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseActionType() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.description = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ActionType {
+    return {
+      $type: ActionType.$type,
+      type: isSet(object.type) ? globalThis.String(object.type) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+    };
+  },
+
+  toJSON(message: ActionType): unknown {
+    const obj: any = {};
+    if (message.type !== "") {
+      obj.type = message.type;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ActionType>, I>>(base?: I): ActionType {
+    return ActionType.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ActionType>, I>>(object: I): ActionType {
+    const message = createBaseActionType() as any;
+    message.type = object.type ?? "";
+    message.description = object.description ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(ActionType.$type, ActionType);
+
+function createBaseCriteria(): Criteria {
+  return { $type: "arrow.flight.protocol.Criteria", expression: new Uint8Array(0) };
+}
+
+export const Criteria: MessageFns<Criteria, "arrow.flight.protocol.Criteria"> = {
+  $type: "arrow.flight.protocol.Criteria" as const,
+
+  encode(message: Criteria, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.expression.length !== 0) {
+      writer.uint32(10).bytes(message.expression);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Criteria {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCriteria() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.expression = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Criteria {
+    return {
+      $type: Criteria.$type,
+      expression: isSet(object.expression) ? bytesFromBase64(object.expression) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: Criteria): unknown {
+    const obj: any = {};
+    if (message.expression.length !== 0) {
+      obj.expression = base64FromBytes(message.expression);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Criteria>, I>>(base?: I): Criteria {
+    return Criteria.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Criteria>, I>>(object: I): Criteria {
+    const message = createBaseCriteria() as any;
+    message.expression = object.expression ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Criteria.$type, Criteria);
+
+function createBaseAction(): Action {
+  return { $type: "arrow.flight.protocol.Action", type: "", body: new Uint8Array(0) };
+}
+
+export const Action: MessageFns<Action, "arrow.flight.protocol.Action"> = {
+  $type: "arrow.flight.protocol.Action" as const,
+
+  encode(message: Action, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
+    }
+    if (message.body.length !== 0) {
+      writer.uint32(18).bytes(message.body);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Action {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAction() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.body = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Action {
+    return {
+      $type: Action.$type,
+      type: isSet(object.type) ? globalThis.String(object.type) : "",
+      body: isSet(object.body) ? bytesFromBase64(object.body) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: Action): unknown {
+    const obj: any = {};
+    if (message.type !== "") {
+      obj.type = message.type;
+    }
+    if (message.body.length !== 0) {
+      obj.body = base64FromBytes(message.body);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Action>, I>>(base?: I): Action {
+    return Action.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Action>, I>>(object: I): Action {
+    const message = createBaseAction() as any;
+    message.type = object.type ?? "";
+    message.body = object.body ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Action.$type, Action);
+
+function createBaseCancelFlightInfoRequest(): CancelFlightInfoRequest {
+  return { $type: "arrow.flight.protocol.CancelFlightInfoRequest", info: undefined };
+}
+
+export const CancelFlightInfoRequest: MessageFns<
+  CancelFlightInfoRequest,
+  "arrow.flight.protocol.CancelFlightInfoRequest"
+> = {
+  $type: "arrow.flight.protocol.CancelFlightInfoRequest" as const,
+
+  encode(message: CancelFlightInfoRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.info !== undefined) {
+      FlightInfo.encode(message.info, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CancelFlightInfoRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCancelFlightInfoRequest() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.info = FlightInfo.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CancelFlightInfoRequest {
+    return {
+      $type: CancelFlightInfoRequest.$type,
+      info: isSet(object.info) ? FlightInfo.fromJSON(object.info) : undefined,
+    };
+  },
+
+  toJSON(message: CancelFlightInfoRequest): unknown {
+    const obj: any = {};
+    if (message.info !== undefined) {
+      obj.info = FlightInfo.toJSON(message.info);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CancelFlightInfoRequest>, I>>(base?: I): CancelFlightInfoRequest {
+    return CancelFlightInfoRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CancelFlightInfoRequest>, I>>(object: I): CancelFlightInfoRequest {
+    const message = createBaseCancelFlightInfoRequest() as any;
+    message.info = (object.info !== undefined && object.info !== null)
+      ? FlightInfo.fromPartial(object.info)
+      : undefined;
+    return message;
+  },
+};
+
+messageTypeRegistry.set(CancelFlightInfoRequest.$type, CancelFlightInfoRequest);
+
+function createBaseRenewFlightEndpointRequest(): RenewFlightEndpointRequest {
+  return { $type: "arrow.flight.protocol.RenewFlightEndpointRequest", endpoint: undefined };
+}
+
+export const RenewFlightEndpointRequest: MessageFns<
+  RenewFlightEndpointRequest,
+  "arrow.flight.protocol.RenewFlightEndpointRequest"
+> = {
+  $type: "arrow.flight.protocol.RenewFlightEndpointRequest" as const,
+
+  encode(message: RenewFlightEndpointRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.endpoint !== undefined) {
+      FlightEndpoint.encode(message.endpoint, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RenewFlightEndpointRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRenewFlightEndpointRequest() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.endpoint = FlightEndpoint.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RenewFlightEndpointRequest {
+    return {
+      $type: RenewFlightEndpointRequest.$type,
+      endpoint: isSet(object.endpoint) ? FlightEndpoint.fromJSON(object.endpoint) : undefined,
+    };
+  },
+
+  toJSON(message: RenewFlightEndpointRequest): unknown {
+    const obj: any = {};
+    if (message.endpoint !== undefined) {
+      obj.endpoint = FlightEndpoint.toJSON(message.endpoint);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RenewFlightEndpointRequest>, I>>(base?: I): RenewFlightEndpointRequest {
+    return RenewFlightEndpointRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<RenewFlightEndpointRequest>, I>>(object: I): RenewFlightEndpointRequest {
+    const message = createBaseRenewFlightEndpointRequest() as any;
+    message.endpoint = (object.endpoint !== undefined && object.endpoint !== null)
+      ? FlightEndpoint.fromPartial(object.endpoint)
+      : undefined;
+    return message;
+  },
+};
+
+messageTypeRegistry.set(RenewFlightEndpointRequest.$type, RenewFlightEndpointRequest);
+
+function createBaseResult(): Result {
+  return { $type: "arrow.flight.protocol.Result", body: new Uint8Array(0) };
+}
+
+export const Result: MessageFns<Result, "arrow.flight.protocol.Result"> = {
+  $type: "arrow.flight.protocol.Result" as const,
+
+  encode(message: Result, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.body.length !== 0) {
+      writer.uint32(10).bytes(message.body);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Result {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseResult() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.body = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Result {
+    return { $type: Result.$type, body: isSet(object.body) ? bytesFromBase64(object.body) : new Uint8Array(0) };
+  },
+
+  toJSON(message: Result): unknown {
+    const obj: any = {};
+    if (message.body.length !== 0) {
+      obj.body = base64FromBytes(message.body);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Result>, I>>(base?: I): Result {
+    return Result.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Result>, I>>(object: I): Result {
+    const message = createBaseResult() as any;
+    message.body = object.body ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Result.$type, Result);
+
+function createBaseCancelFlightInfoResult(): CancelFlightInfoResult {
+  return { $type: "arrow.flight.protocol.CancelFlightInfoResult", status: 0 };
+}
+
+export const CancelFlightInfoResult: MessageFns<
+  CancelFlightInfoResult,
+  "arrow.flight.protocol.CancelFlightInfoResult"
+> = {
+  $type: "arrow.flight.protocol.CancelFlightInfoResult" as const,
+
+  encode(message: CancelFlightInfoResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== 0) {
+      writer.uint32(8).int32(message.status);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CancelFlightInfoResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCancelFlightInfoResult() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CancelFlightInfoResult {
+    return {
+      $type: CancelFlightInfoResult.$type,
+      status: isSet(object.status) ? cancelStatusFromJSON(object.status) : 0,
+    };
+  },
+
+  toJSON(message: CancelFlightInfoResult): unknown {
+    const obj: any = {};
+    if (message.status !== 0) {
+      obj.status = cancelStatusToJSON(message.status);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CancelFlightInfoResult>, I>>(base?: I): CancelFlightInfoResult {
+    return CancelFlightInfoResult.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CancelFlightInfoResult>, I>>(object: I): CancelFlightInfoResult {
+    const message = createBaseCancelFlightInfoResult() as any;
+    message.status = object.status ?? 0;
+    return message;
+  },
+};
+
+messageTypeRegistry.set(CancelFlightInfoResult.$type, CancelFlightInfoResult);
+
+function createBaseSchemaResult(): SchemaResult {
+  return { $type: "arrow.flight.protocol.SchemaResult", schema: new Uint8Array(0) };
+}
+
+export const SchemaResult: MessageFns<SchemaResult, "arrow.flight.protocol.SchemaResult"> = {
+  $type: "arrow.flight.protocol.SchemaResult" as const,
+
+  encode(message: SchemaResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.schema.length !== 0) {
+      writer.uint32(10).bytes(message.schema);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SchemaResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSchemaResult() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.schema = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SchemaResult {
+    return {
+      $type: SchemaResult.$type,
+      schema: isSet(object.schema) ? bytesFromBase64(object.schema) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: SchemaResult): unknown {
+    const obj: any = {};
+    if (message.schema.length !== 0) {
+      obj.schema = base64FromBytes(message.schema);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SchemaResult>, I>>(base?: I): SchemaResult {
+    return SchemaResult.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SchemaResult>, I>>(object: I): SchemaResult {
+    const message = createBaseSchemaResult() as any;
+    message.schema = object.schema ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(SchemaResult.$type, SchemaResult);
+
+function createBaseFlightDescriptor(): FlightDescriptor {
+  return { $type: "arrow.flight.protocol.FlightDescriptor", type: 0, cmd: new Uint8Array(0), path: [] };
+}
+
+export const FlightDescriptor: MessageFns<FlightDescriptor, "arrow.flight.protocol.FlightDescriptor"> = {
+  $type: "arrow.flight.protocol.FlightDescriptor" as const,
+
+  encode(message: FlightDescriptor, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== 0) {
+      writer.uint32(8).int32(message.type);
+    }
+    if (message.cmd.length !== 0) {
+      writer.uint32(18).bytes(message.cmd);
+    }
+    for (const v of message.path) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FlightDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFlightDescriptor() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.type = reader.int32() as any;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.cmd = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.path.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FlightDescriptor {
+    return {
+      $type: FlightDescriptor.$type,
+      type: isSet(object.type) ? flightDescriptor_DescriptorTypeFromJSON(object.type) : 0,
+      cmd: isSet(object.cmd) ? bytesFromBase64(object.cmd) : new Uint8Array(0),
+      path: globalThis.Array.isArray(object?.path) ? object.path.map((e: any) => globalThis.String(e)) : [],
+    };
+  },
+
+  toJSON(message: FlightDescriptor): unknown {
+    const obj: any = {};
+    if (message.type !== 0) {
+      obj.type = flightDescriptor_DescriptorTypeToJSON(message.type);
+    }
+    if (message.cmd.length !== 0) {
+      obj.cmd = base64FromBytes(message.cmd);
+    }
+    if (message.path?.length) {
+      obj.path = message.path;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FlightDescriptor>, I>>(base?: I): FlightDescriptor {
+    return FlightDescriptor.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FlightDescriptor>, I>>(object: I): FlightDescriptor {
+    const message = createBaseFlightDescriptor() as any;
+    message.type = object.type ?? 0;
+    message.cmd = object.cmd ?? new Uint8Array(0);
+    message.path = object.path?.map((e) => e) || [];
+    return message;
+  },
+};
+
+messageTypeRegistry.set(FlightDescriptor.$type, FlightDescriptor);
+
+function createBaseFlightInfo(): FlightInfo {
+  return {
+    $type: "arrow.flight.protocol.FlightInfo",
+    schema: new Uint8Array(0),
+    flightDescriptor: undefined,
+    endpoint: [],
+    totalRecords: 0n,
+    totalBytes: 0n,
+    ordered: false,
+    appMetadata: new Uint8Array(0),
+  };
+}
+
+export const FlightInfo: MessageFns<FlightInfo, "arrow.flight.protocol.FlightInfo"> = {
+  $type: "arrow.flight.protocol.FlightInfo" as const,
+
+  encode(message: FlightInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.schema.length !== 0) {
+      writer.uint32(10).bytes(message.schema);
+    }
+    if (message.flightDescriptor !== undefined) {
+      FlightDescriptor.encode(message.flightDescriptor, writer.uint32(18).fork()).join();
+    }
+    for (const v of message.endpoint) {
+      FlightEndpoint.encode(v!, writer.uint32(26).fork()).join();
+    }
+    if (message.totalRecords !== 0n) {
+      if (BigInt.asIntN(64, message.totalRecords) !== message.totalRecords) {
+        throw new globalThis.Error("value provided for field message.totalRecords of type int64 too large");
+      }
+      writer.uint32(32).int64(message.totalRecords);
+    }
+    if (message.totalBytes !== 0n) {
+      if (BigInt.asIntN(64, message.totalBytes) !== message.totalBytes) {
+        throw new globalThis.Error("value provided for field message.totalBytes of type int64 too large");
+      }
+      writer.uint32(40).int64(message.totalBytes);
+    }
+    if (message.ordered !== false) {
+      writer.uint32(48).bool(message.ordered);
+    }
+    if (message.appMetadata.length !== 0) {
+      writer.uint32(58).bytes(message.appMetadata);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FlightInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFlightInfo() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.schema = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.flightDescriptor = FlightDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.endpoint.push(FlightEndpoint.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.totalRecords = reader.int64() as bigint;
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.totalBytes = reader.int64() as bigint;
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.ordered = reader.bool();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.appMetadata = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FlightInfo {
+    return {
+      $type: FlightInfo.$type,
+      schema: isSet(object.schema) ? bytesFromBase64(object.schema) : new Uint8Array(0),
+      flightDescriptor: isSet(object.flightDescriptor) ? FlightDescriptor.fromJSON(object.flightDescriptor) : undefined,
+      endpoint: globalThis.Array.isArray(object?.endpoint)
+        ? object.endpoint.map((e: any) => FlightEndpoint.fromJSON(e))
+        : [],
+      totalRecords: isSet(object.totalRecords) ? BigInt(object.totalRecords) : 0n,
+      totalBytes: isSet(object.totalBytes) ? BigInt(object.totalBytes) : 0n,
+      ordered: isSet(object.ordered) ? globalThis.Boolean(object.ordered) : false,
+      appMetadata: isSet(object.appMetadata) ? bytesFromBase64(object.appMetadata) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: FlightInfo): unknown {
+    const obj: any = {};
+    if (message.schema.length !== 0) {
+      obj.schema = base64FromBytes(message.schema);
+    }
+    if (message.flightDescriptor !== undefined) {
+      obj.flightDescriptor = FlightDescriptor.toJSON(message.flightDescriptor);
+    }
+    if (message.endpoint?.length) {
+      obj.endpoint = message.endpoint.map((e) => FlightEndpoint.toJSON(e));
+    }
+    if (message.totalRecords !== 0n) {
+      obj.totalRecords = message.totalRecords.toString();
+    }
+    if (message.totalBytes !== 0n) {
+      obj.totalBytes = message.totalBytes.toString();
+    }
+    if (message.ordered !== false) {
+      obj.ordered = message.ordered;
+    }
+    if (message.appMetadata.length !== 0) {
+      obj.appMetadata = base64FromBytes(message.appMetadata);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FlightInfo>, I>>(base?: I): FlightInfo {
+    return FlightInfo.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FlightInfo>, I>>(object: I): FlightInfo {
+    const message = createBaseFlightInfo() as any;
+    message.schema = object.schema ?? new Uint8Array(0);
+    message.flightDescriptor = (object.flightDescriptor !== undefined && object.flightDescriptor !== null)
+      ? FlightDescriptor.fromPartial(object.flightDescriptor)
+      : undefined;
+    message.endpoint = object.endpoint?.map((e) => FlightEndpoint.fromPartial(e)) || [];
+    message.totalRecords = object.totalRecords ?? 0n;
+    message.totalBytes = object.totalBytes ?? 0n;
+    message.ordered = object.ordered ?? false;
+    message.appMetadata = object.appMetadata ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(FlightInfo.$type, FlightInfo);
+
+function createBasePollInfo(): PollInfo {
+  return {
+    $type: "arrow.flight.protocol.PollInfo",
+    info: undefined,
+    flightDescriptor: undefined,
+    progress: undefined,
+    expirationTime: undefined,
+  };
+}
+
+export const PollInfo: MessageFns<PollInfo, "arrow.flight.protocol.PollInfo"> = {
+  $type: "arrow.flight.protocol.PollInfo" as const,
+
+  encode(message: PollInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.info !== undefined) {
+      FlightInfo.encode(message.info, writer.uint32(10).fork()).join();
+    }
+    if (message.flightDescriptor !== undefined) {
+      FlightDescriptor.encode(message.flightDescriptor, writer.uint32(18).fork()).join();
+    }
+    if (message.progress !== undefined) {
+      writer.uint32(25).double(message.progress);
+    }
+    if (message.expirationTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.expirationTime), writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PollInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePollInfo() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.info = FlightInfo.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.flightDescriptor = FlightDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 25) {
+            break;
+          }
+
+          message.progress = reader.double();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.expirationTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PollInfo {
+    return {
+      $type: PollInfo.$type,
+      info: isSet(object.info) ? FlightInfo.fromJSON(object.info) : undefined,
+      flightDescriptor: isSet(object.flightDescriptor) ? FlightDescriptor.fromJSON(object.flightDescriptor) : undefined,
+      progress: isSet(object.progress) ? globalThis.Number(object.progress) : undefined,
+      expirationTime: isSet(object.expirationTime) ? fromJsonTimestamp(object.expirationTime) : undefined,
+    };
+  },
+
+  toJSON(message: PollInfo): unknown {
+    const obj: any = {};
+    if (message.info !== undefined) {
+      obj.info = FlightInfo.toJSON(message.info);
+    }
+    if (message.flightDescriptor !== undefined) {
+      obj.flightDescriptor = FlightDescriptor.toJSON(message.flightDescriptor);
+    }
+    if (message.progress !== undefined) {
+      obj.progress = message.progress;
+    }
+    if (message.expirationTime !== undefined) {
+      obj.expirationTime = message.expirationTime.toISOString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PollInfo>, I>>(base?: I): PollInfo {
+    return PollInfo.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<PollInfo>, I>>(object: I): PollInfo {
+    const message = createBasePollInfo() as any;
+    message.info = (object.info !== undefined && object.info !== null)
+      ? FlightInfo.fromPartial(object.info)
+      : undefined;
+    message.flightDescriptor = (object.flightDescriptor !== undefined && object.flightDescriptor !== null)
+      ? FlightDescriptor.fromPartial(object.flightDescriptor)
+      : undefined;
+    message.progress = object.progress ?? undefined;
+    message.expirationTime = object.expirationTime ?? undefined;
+    return message;
+  },
+};
+
+messageTypeRegistry.set(PollInfo.$type, PollInfo);
+
+function createBaseFlightEndpoint(): FlightEndpoint {
+  return {
+    $type: "arrow.flight.protocol.FlightEndpoint",
+    ticket: undefined,
+    location: [],
+    expirationTime: undefined,
+    appMetadata: new Uint8Array(0),
+  };
+}
+
+export const FlightEndpoint: MessageFns<FlightEndpoint, "arrow.flight.protocol.FlightEndpoint"> = {
+  $type: "arrow.flight.protocol.FlightEndpoint" as const,
+
+  encode(message: FlightEndpoint, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.ticket !== undefined) {
+      Ticket.encode(message.ticket, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.location) {
+      Location.encode(v!, writer.uint32(18).fork()).join();
+    }
+    if (message.expirationTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.expirationTime), writer.uint32(26).fork()).join();
+    }
+    if (message.appMetadata.length !== 0) {
+      writer.uint32(34).bytes(message.appMetadata);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FlightEndpoint {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFlightEndpoint() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.ticket = Ticket.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.location.push(Location.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.expirationTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.appMetadata = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FlightEndpoint {
+    return {
+      $type: FlightEndpoint.$type,
+      ticket: isSet(object.ticket) ? Ticket.fromJSON(object.ticket) : undefined,
+      location: globalThis.Array.isArray(object?.location) ? object.location.map((e: any) => Location.fromJSON(e)) : [],
+      expirationTime: isSet(object.expirationTime) ? fromJsonTimestamp(object.expirationTime) : undefined,
+      appMetadata: isSet(object.appMetadata) ? bytesFromBase64(object.appMetadata) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: FlightEndpoint): unknown {
+    const obj: any = {};
+    if (message.ticket !== undefined) {
+      obj.ticket = Ticket.toJSON(message.ticket);
+    }
+    if (message.location?.length) {
+      obj.location = message.location.map((e) => Location.toJSON(e));
+    }
+    if (message.expirationTime !== undefined) {
+      obj.expirationTime = message.expirationTime.toISOString();
+    }
+    if (message.appMetadata.length !== 0) {
+      obj.appMetadata = base64FromBytes(message.appMetadata);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FlightEndpoint>, I>>(base?: I): FlightEndpoint {
+    return FlightEndpoint.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FlightEndpoint>, I>>(object: I): FlightEndpoint {
+    const message = createBaseFlightEndpoint() as any;
+    message.ticket = (object.ticket !== undefined && object.ticket !== null)
+      ? Ticket.fromPartial(object.ticket)
+      : undefined;
+    message.location = object.location?.map((e) => Location.fromPartial(e)) || [];
+    message.expirationTime = object.expirationTime ?? undefined;
+    message.appMetadata = object.appMetadata ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(FlightEndpoint.$type, FlightEndpoint);
+
+function createBaseLocation(): Location {
+  return { $type: "arrow.flight.protocol.Location", uri: "" };
+}
+
+export const Location: MessageFns<Location, "arrow.flight.protocol.Location"> = {
+  $type: "arrow.flight.protocol.Location" as const,
+
+  encode(message: Location, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.uri !== "") {
+      writer.uint32(10).string(message.uri);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Location {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLocation() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.uri = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Location {
+    return { $type: Location.$type, uri: isSet(object.uri) ? globalThis.String(object.uri) : "" };
+  },
+
+  toJSON(message: Location): unknown {
+    const obj: any = {};
+    if (message.uri !== "") {
+      obj.uri = message.uri;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Location>, I>>(base?: I): Location {
+    return Location.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Location>, I>>(object: I): Location {
+    const message = createBaseLocation() as any;
+    message.uri = object.uri ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Location.$type, Location);
+
+function createBaseTicket(): Ticket {
+  return { $type: "arrow.flight.protocol.Ticket", ticket: new Uint8Array(0) };
+}
+
+export const Ticket: MessageFns<Ticket, "arrow.flight.protocol.Ticket"> = {
+  $type: "arrow.flight.protocol.Ticket" as const,
+
+  encode(message: Ticket, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.ticket.length !== 0) {
+      writer.uint32(10).bytes(message.ticket);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Ticket {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTicket() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.ticket = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Ticket {
+    return { $type: Ticket.$type, ticket: isSet(object.ticket) ? bytesFromBase64(object.ticket) : new Uint8Array(0) };
+  },
+
+  toJSON(message: Ticket): unknown {
+    const obj: any = {};
+    if (message.ticket.length !== 0) {
+      obj.ticket = base64FromBytes(message.ticket);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Ticket>, I>>(base?: I): Ticket {
+    return Ticket.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Ticket>, I>>(object: I): Ticket {
+    const message = createBaseTicket() as any;
+    message.ticket = object.ticket ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Ticket.$type, Ticket);
+
+function createBaseFlightData(): FlightData {
+  return {
+    $type: "arrow.flight.protocol.FlightData",
+    flightDescriptor: undefined,
+    dataHeader: new Uint8Array(0),
+    appMetadata: new Uint8Array(0),
+    dataBody: new Uint8Array(0),
+  };
+}
+
+export const FlightData: MessageFns<FlightData, "arrow.flight.protocol.FlightData"> = {
+  $type: "arrow.flight.protocol.FlightData" as const,
+
+  encode(message: FlightData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.flightDescriptor !== undefined) {
+      FlightDescriptor.encode(message.flightDescriptor, writer.uint32(10).fork()).join();
+    }
+    if (message.dataHeader.length !== 0) {
+      writer.uint32(18).bytes(message.dataHeader);
+    }
+    if (message.appMetadata.length !== 0) {
+      writer.uint32(26).bytes(message.appMetadata);
+    }
+    if (message.dataBody.length !== 0) {
+      writer.uint32(8002).bytes(message.dataBody);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): FlightData {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFlightData() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.flightDescriptor = FlightDescriptor.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.dataHeader = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.appMetadata = reader.bytes();
+          continue;
+        }
+        case 1000: {
+          if (tag !== 8002) {
+            break;
+          }
+
+          message.dataBody = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FlightData {
+    return {
+      $type: FlightData.$type,
+      flightDescriptor: isSet(object.flightDescriptor) ? FlightDescriptor.fromJSON(object.flightDescriptor) : undefined,
+      dataHeader: isSet(object.dataHeader) ? bytesFromBase64(object.dataHeader) : new Uint8Array(0),
+      appMetadata: isSet(object.appMetadata) ? bytesFromBase64(object.appMetadata) : new Uint8Array(0),
+      dataBody: isSet(object.dataBody) ? bytesFromBase64(object.dataBody) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: FlightData): unknown {
+    const obj: any = {};
+    if (message.flightDescriptor !== undefined) {
+      obj.flightDescriptor = FlightDescriptor.toJSON(message.flightDescriptor);
+    }
+    if (message.dataHeader.length !== 0) {
+      obj.dataHeader = base64FromBytes(message.dataHeader);
+    }
+    if (message.appMetadata.length !== 0) {
+      obj.appMetadata = base64FromBytes(message.appMetadata);
+    }
+    if (message.dataBody.length !== 0) {
+      obj.dataBody = base64FromBytes(message.dataBody);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<FlightData>, I>>(base?: I): FlightData {
+    return FlightData.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<FlightData>, I>>(object: I): FlightData {
+    const message = createBaseFlightData() as any;
+    message.flightDescriptor = (object.flightDescriptor !== undefined && object.flightDescriptor !== null)
+      ? FlightDescriptor.fromPartial(object.flightDescriptor)
+      : undefined;
+    message.dataHeader = object.dataHeader ?? new Uint8Array(0);
+    message.appMetadata = object.appMetadata ?? new Uint8Array(0);
+    message.dataBody = object.dataBody ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(FlightData.$type, FlightData);
+
+function createBasePutResult(): PutResult {
+  return { $type: "arrow.flight.protocol.PutResult", appMetadata: new Uint8Array(0) };
+}
+
+export const PutResult: MessageFns<PutResult, "arrow.flight.protocol.PutResult"> = {
+  $type: "arrow.flight.protocol.PutResult" as const,
+
+  encode(message: PutResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.appMetadata.length !== 0) {
+      writer.uint32(10).bytes(message.appMetadata);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PutResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePutResult() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.appMetadata = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PutResult {
+    return {
+      $type: PutResult.$type,
+      appMetadata: isSet(object.appMetadata) ? bytesFromBase64(object.appMetadata) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: PutResult): unknown {
+    const obj: any = {};
+    if (message.appMetadata.length !== 0) {
+      obj.appMetadata = base64FromBytes(message.appMetadata);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PutResult>, I>>(base?: I): PutResult {
+    return PutResult.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<PutResult>, I>>(object: I): PutResult {
+    const message = createBasePutResult() as any;
+    message.appMetadata = object.appMetadata ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+messageTypeRegistry.set(PutResult.$type, PutResult);
+
+/**
+ * A flight service is an endpoint for retrieving or storing Arrow data. A
+ * flight service can expose one or more predefined endpoints that can be
+ * accessed using the Arrow Flight Protocol. Additionally, a flight service
+ * can expose a set of actions that are available.
+ */
+export type FlightServiceDefinition = typeof FlightServiceDefinition;
+export const FlightServiceDefinition = {
+  name: "FlightService",
+  fullName: "arrow.flight.protocol.FlightService",
+  methods: {
+    /**
+     * Handshake between client and server. Depending on the server, the
+     * handshake may be required to determine the token that should be used for
+     * future operations. Both request and response are streams to allow multiple
+     * round-trips depending on auth mechanism.
+     */
+    handshake: {
+      name: "Handshake",
+      requestType: HandshakeRequest,
+      requestStream: true,
+      responseType: HandshakeResponse,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * Get a list of available streams given a particular criteria. Most flight
+     * services will expose one or more streams that are readily available for
+     * retrieval. This api allows listing the streams available for
+     * consumption. A user can also provide a criteria. The criteria can limit
+     * the subset of streams that can be listed via this interface. Each flight
+     * service allows its own definition of how to consume criteria.
+     */
+    listFlights: {
+      name: "ListFlights",
+      requestType: Criteria,
+      requestStream: false,
+      responseType: FlightInfo,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * For a given FlightDescriptor, get information about how the flight can be
+     * consumed. This is a useful interface if the consumer of the interface
+     * already can identify the specific flight to consume. This interface can
+     * also allow a consumer to generate a flight stream through a specified
+     * descriptor. For example, a flight descriptor might be something that
+     * includes a SQL statement or a Pickled Python operation that will be
+     * executed. In those cases, the descriptor will not be previously available
+     * within the list of available streams provided by ListFlights but will be
+     * available for consumption for the duration defined by the specific flight
+     * service.
+     */
+    getFlightInfo: {
+      name: "GetFlightInfo",
+      requestType: FlightDescriptor,
+      requestStream: false,
+      responseType: FlightInfo,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * For a given FlightDescriptor, start a query and get information
+     * to poll its execution status. This is a useful interface if the
+     * query may be a long-running query. The first PollFlightInfo call
+     * should return as quickly as possible. (GetFlightInfo doesn't
+     * return until the query is complete.)
+     *
+     * A client can consume any available results before
+     * the query is completed. See PollInfo.info for details.
+     *
+     * A client can poll the updated query status by calling
+     * PollFlightInfo() with PollInfo.flight_descriptor. A server
+     * should not respond until the result would be different from last
+     * time. That way, the client can "long poll" for updates
+     * without constantly making requests. Clients can set a short timeout
+     * to avoid blocking calls if desired.
+     *
+     * A client can't use PollInfo.flight_descriptor after
+     * PollInfo.expiration_time passes. A server might not accept the
+     * retry descriptor anymore and the query may be cancelled.
+     *
+     * A client may use the CancelFlightInfo action with
+     * PollInfo.info to cancel the running query.
+     */
+    pollFlightInfo: {
+      name: "PollFlightInfo",
+      requestType: FlightDescriptor,
+      requestStream: false,
+      responseType: PollInfo,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
+     * This is used when a consumer needs the Schema of flight stream. Similar to
+     * GetFlightInfo this interface may generate a new flight that was not previously
+     * available in ListFlights.
+     */
+    getSchema: {
+      name: "GetSchema",
+      requestType: FlightDescriptor,
+      requestStream: false,
+      responseType: SchemaResult,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Retrieve a single stream associated with a particular descriptor
+     * associated with the referenced ticket. A Flight can be composed of one or
+     * more streams where each stream can be retrieved using a separate opaque
+     * ticket that the flight service uses for managing a collection of streams.
+     */
+    doGet: {
+      name: "DoGet",
+      requestType: Ticket,
+      requestStream: false,
+      responseType: FlightData,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * Push a stream to the flight service associated with a particular
+     * flight stream. This allows a client of a flight service to upload a stream
+     * of data. Depending on the particular flight service, a client consumer
+     * could be allowed to upload a single stream per descriptor or an unlimited
+     * number. In the latter, the service might implement a 'seal' action that
+     * can be applied to a descriptor once all streams are uploaded.
+     */
+    doPut: {
+      name: "DoPut",
+      requestType: FlightData,
+      requestStream: true,
+      responseType: PutResult,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * Open a bidirectional data channel for a given descriptor. This
+     * allows clients to send and receive arbitrary Arrow data and
+     * application-specific metadata in a single logical stream. In
+     * contrast to DoGet/DoPut, this is more suited for clients
+     * offloading computation (rather than storage) to a Flight service.
+     */
+    doExchange: {
+      name: "DoExchange",
+      requestType: FlightData,
+      requestStream: true,
+      responseType: FlightData,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * Flight services can support an arbitrary number of simple actions in
+     * addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
+     * operations that are potentially available. DoAction allows a flight client
+     * to do a specific action against a flight service. An action includes
+     * opaque request and response objects that are specific to the type action
+     * being undertaken.
+     */
+    doAction: {
+      name: "DoAction",
+      requestType: Action,
+      requestStream: false,
+      responseType: Result,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * A flight service exposes all of the available action types that it has
+     * along with descriptions. This allows different flight consumers to
+     * understand the capabilities of the flight service.
+     */
+    listActions: {
+      name: "ListActions",
+      requestType: Empty,
+      requestStream: false,
+      responseType: ActionType,
+      responseStream: true,
+      options: {},
+    },
+  },
+} as const;
+
+export interface FlightServiceImplementation<CallContextExt = {}> {
+  /**
+   * Handshake between client and server. Depending on the server, the
+   * handshake may be required to determine the token that should be used for
+   * future operations. Both request and response are streams to allow multiple
+   * round-trips depending on auth mechanism.
+   */
+  handshake(
+    request: AsyncIterable<HandshakeRequest>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<HandshakeResponse>>;
+  /**
+   * Get a list of available streams given a particular criteria. Most flight
+   * services will expose one or more streams that are readily available for
+   * retrieval. This api allows listing the streams available for
+   * consumption. A user can also provide a criteria. The criteria can limit
+   * the subset of streams that can be listed via this interface. Each flight
+   * service allows its own definition of how to consume criteria.
+   */
+  listFlights(
+    request: Criteria,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<FlightInfo>>;
+  /**
+   * For a given FlightDescriptor, get information about how the flight can be
+   * consumed. This is a useful interface if the consumer of the interface
+   * already can identify the specific flight to consume. This interface can
+   * also allow a consumer to generate a flight stream through a specified
+   * descriptor. For example, a flight descriptor might be something that
+   * includes a SQL statement or a Pickled Python operation that will be
+   * executed. In those cases, the descriptor will not be previously available
+   * within the list of available streams provided by ListFlights but will be
+   * available for consumption for the duration defined by the specific flight
+   * service.
+   */
+  getFlightInfo(request: FlightDescriptor, context: CallContext & CallContextExt): Promise<DeepPartial<FlightInfo>>;
+  /**
+   * For a given FlightDescriptor, start a query and get information
+   * to poll its execution status. This is a useful interface if the
+   * query may be a long-running query. The first PollFlightInfo call
+   * should return as quickly as possible. (GetFlightInfo doesn't
+   * return until the query is complete.)
+   *
+   * A client can consume any available results before
+   * the query is completed. See PollInfo.info for details.
+   *
+   * A client can poll the updated query status by calling
+   * PollFlightInfo() with PollInfo.flight_descriptor. A server
+   * should not respond until the result would be different from last
+   * time. That way, the client can "long poll" for updates
+   * without constantly making requests. Clients can set a short timeout
+   * to avoid blocking calls if desired.
+   *
+   * A client can't use PollInfo.flight_descriptor after
+   * PollInfo.expiration_time passes. A server might not accept the
+   * retry descriptor anymore and the query may be cancelled.
+   *
+   * A client may use the CancelFlightInfo action with
+   * PollInfo.info to cancel the running query.
+   */
+  pollFlightInfo(request: FlightDescriptor, context: CallContext & CallContextExt): Promise<DeepPartial<PollInfo>>;
+  /**
+   * For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
+   * This is used when a consumer needs the Schema of flight stream. Similar to
+   * GetFlightInfo this interface may generate a new flight that was not previously
+   * available in ListFlights.
+   */
+  getSchema(request: FlightDescriptor, context: CallContext & CallContextExt): Promise<DeepPartial<SchemaResult>>;
+  /**
+   * Retrieve a single stream associated with a particular descriptor
+   * associated with the referenced ticket. A Flight can be composed of one or
+   * more streams where each stream can be retrieved using a separate opaque
+   * ticket that the flight service uses for managing a collection of streams.
+   */
+  doGet(request: Ticket, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<FlightData>>;
+  /**
+   * Push a stream to the flight service associated with a particular
+   * flight stream. This allows a client of a flight service to upload a stream
+   * of data. Depending on the particular flight service, a client consumer
+   * could be allowed to upload a single stream per descriptor or an unlimited
+   * number. In the latter, the service might implement a 'seal' action that
+   * can be applied to a descriptor once all streams are uploaded.
+   */
+  doPut(
+    request: AsyncIterable<FlightData>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<PutResult>>;
+  /**
+   * Open a bidirectional data channel for a given descriptor. This
+   * allows clients to send and receive arbitrary Arrow data and
+   * application-specific metadata in a single logical stream. In
+   * contrast to DoGet/DoPut, this is more suited for clients
+   * offloading computation (rather than storage) to a Flight service.
+   */
+  doExchange(
+    request: AsyncIterable<FlightData>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<FlightData>>;
+  /**
+   * Flight services can support an arbitrary number of simple actions in
+   * addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
+   * operations that are potentially available. DoAction allows a flight client
+   * to do a specific action against a flight service. An action includes
+   * opaque request and response objects that are specific to the type action
+   * being undertaken.
+   */
+  doAction(request: Action, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Result>>;
+  /**
+   * A flight service exposes all of the available action types that it has
+   * along with descriptions. This allows different flight consumers to
+   * understand the capabilities of the flight service.
+   */
+  listActions(
+    request: Empty,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<ActionType>>;
+}
+
+export interface FlightServiceClient<CallOptionsExt = {}> {
+  /**
+   * Handshake between client and server. Depending on the server, the
+   * handshake may be required to determine the token that should be used for
+   * future operations. Both request and response are streams to allow multiple
+   * round-trips depending on auth mechanism.
+   */
+  handshake(
+    request: AsyncIterable<DeepPartial<HandshakeRequest>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<HandshakeResponse>;
+  /**
+   * Get a list of available streams given a particular criteria. Most flight
+   * services will expose one or more streams that are readily available for
+   * retrieval. This api allows listing the streams available for
+   * consumption. A user can also provide a criteria. The criteria can limit
+   * the subset of streams that can be listed via this interface. Each flight
+   * service allows its own definition of how to consume criteria.
+   */
+  listFlights(request: DeepPartial<Criteria>, options?: CallOptions & CallOptionsExt): AsyncIterable<FlightInfo>;
+  /**
+   * For a given FlightDescriptor, get information about how the flight can be
+   * consumed. This is a useful interface if the consumer of the interface
+   * already can identify the specific flight to consume. This interface can
+   * also allow a consumer to generate a flight stream through a specified
+   * descriptor. For example, a flight descriptor might be something that
+   * includes a SQL statement or a Pickled Python operation that will be
+   * executed. In those cases, the descriptor will not be previously available
+   * within the list of available streams provided by ListFlights but will be
+   * available for consumption for the duration defined by the specific flight
+   * service.
+   */
+  getFlightInfo(request: DeepPartial<FlightDescriptor>, options?: CallOptions & CallOptionsExt): Promise<FlightInfo>;
+  /**
+   * For a given FlightDescriptor, start a query and get information
+   * to poll its execution status. This is a useful interface if the
+   * query may be a long-running query. The first PollFlightInfo call
+   * should return as quickly as possible. (GetFlightInfo doesn't
+   * return until the query is complete.)
+   *
+   * A client can consume any available results before
+   * the query is completed. See PollInfo.info for details.
+   *
+   * A client can poll the updated query status by calling
+   * PollFlightInfo() with PollInfo.flight_descriptor. A server
+   * should not respond until the result would be different from last
+   * time. That way, the client can "long poll" for updates
+   * without constantly making requests. Clients can set a short timeout
+   * to avoid blocking calls if desired.
+   *
+   * A client can't use PollInfo.flight_descriptor after
+   * PollInfo.expiration_time passes. A server might not accept the
+   * retry descriptor anymore and the query may be cancelled.
+   *
+   * A client may use the CancelFlightInfo action with
+   * PollInfo.info to cancel the running query.
+   */
+  pollFlightInfo(request: DeepPartial<FlightDescriptor>, options?: CallOptions & CallOptionsExt): Promise<PollInfo>;
+  /**
+   * For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
+   * This is used when a consumer needs the Schema of flight stream. Similar to
+   * GetFlightInfo this interface may generate a new flight that was not previously
+   * available in ListFlights.
+   */
+  getSchema(request: DeepPartial<FlightDescriptor>, options?: CallOptions & CallOptionsExt): Promise<SchemaResult>;
+  /**
+   * Retrieve a single stream associated with a particular descriptor
+   * associated with the referenced ticket. A Flight can be composed of one or
+   * more streams where each stream can be retrieved using a separate opaque
+   * ticket that the flight service uses for managing a collection of streams.
+   */
+  doGet(request: DeepPartial<Ticket>, options?: CallOptions & CallOptionsExt): AsyncIterable<FlightData>;
+  /**
+   * Push a stream to the flight service associated with a particular
+   * flight stream. This allows a client of a flight service to upload a stream
+   * of data. Depending on the particular flight service, a client consumer
+   * could be allowed to upload a single stream per descriptor or an unlimited
+   * number. In the latter, the service might implement a 'seal' action that
+   * can be applied to a descriptor once all streams are uploaded.
+   */
+  doPut(
+    request: AsyncIterable<DeepPartial<FlightData>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<PutResult>;
+  /**
+   * Open a bidirectional data channel for a given descriptor. This
+   * allows clients to send and receive arbitrary Arrow data and
+   * application-specific metadata in a single logical stream. In
+   * contrast to DoGet/DoPut, this is more suited for clients
+   * offloading computation (rather than storage) to a Flight service.
+   */
+  doExchange(
+    request: AsyncIterable<DeepPartial<FlightData>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<FlightData>;
+  /**
+   * Flight services can support an arbitrary number of simple actions in
+   * addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
+   * operations that are potentially available. DoAction allows a flight client
+   * to do a specific action against a flight service. An action includes
+   * opaque request and response objects that are specific to the type action
+   * being undertaken.
+   */
+  doAction(request: DeepPartial<Action>, options?: CallOptions & CallOptionsExt): AsyncIterable<Result>;
+  /**
+   * A flight service exposes all of the available action types that it has
+   * along with descriptions. This allows different flight consumers to
+   * understand the capabilities of the flight service.
+   */
+  listActions(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): AsyncIterable<ActionType>;
+}
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if ((globalThis as any).Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if ((globalThis as any).Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { readonly $case: string }
+    ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { readonly $case: T["$case"] }
+  : T extends {} ? { [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P> | "$type">]: never };
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = BigInt(Math.trunc(date.getTime() / 1_000));
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { $type: "google.protobuf.Timestamp", seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = (globalThis.Number(t.seconds.toString()) || 0) * 1_000;
+  millis += (t.nanos || 0) / 1_000_000;
+  return new globalThis.Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };
+
+export interface MessageFns<T, V extends string> {
+  readonly $type: V;
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}