@gizmodata/gizmosql-client 1.2.0

package/dist/generated/proto/Flight_grpc_pb.d.ts

@@ -0,0 +1,184 @@
+// package: arrow.flight.protocol
+// file: proto/Flight.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "@grpc/grpc-js";
+import * as proto_Flight_pb from "../proto/Flight_pb";
+import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
+
+interface IFlightServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    handshake: IFlightServiceService_IHandshake;
+    listFlights: IFlightServiceService_IListFlights;
+    getFlightInfo: IFlightServiceService_IGetFlightInfo;
+    pollFlightInfo: IFlightServiceService_IPollFlightInfo;
+    getSchema: IFlightServiceService_IGetSchema;
+    doGet: IFlightServiceService_IDoGet;
+    doPut: IFlightServiceService_IDoPut;
+    doExchange: IFlightServiceService_IDoExchange;
+    doAction: IFlightServiceService_IDoAction;
+    listActions: IFlightServiceService_IListActions;
+}
+
+interface IFlightServiceService_IHandshake extends grpc.MethodDefinition<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse> {
+    path: "/arrow.flight.protocol.FlightService/Handshake";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.HandshakeRequest>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.HandshakeRequest>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.HandshakeResponse>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.HandshakeResponse>;
+}
+interface IFlightServiceService_IListFlights extends grpc.MethodDefinition<proto_Flight_pb.Criteria, proto_Flight_pb.FlightInfo> {
+    path: "/arrow.flight.protocol.FlightService/ListFlights";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.Criteria>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.Criteria>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.FlightInfo>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.FlightInfo>;
+}
+interface IFlightServiceService_IGetFlightInfo extends grpc.MethodDefinition<proto_Flight_pb.FlightDescriptor, proto_Flight_pb.FlightInfo> {
+    path: "/arrow.flight.protocol.FlightService/GetFlightInfo";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<proto_Flight_pb.FlightDescriptor>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.FlightDescriptor>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.FlightInfo>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.FlightInfo>;
+}
+interface IFlightServiceService_IPollFlightInfo extends grpc.MethodDefinition<proto_Flight_pb.FlightDescriptor, proto_Flight_pb.PollInfo> {
+    path: "/arrow.flight.protocol.FlightService/PollFlightInfo";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<proto_Flight_pb.FlightDescriptor>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.FlightDescriptor>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.PollInfo>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.PollInfo>;
+}
+interface IFlightServiceService_IGetSchema extends grpc.MethodDefinition<proto_Flight_pb.FlightDescriptor, proto_Flight_pb.SchemaResult> {
+    path: "/arrow.flight.protocol.FlightService/GetSchema";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<proto_Flight_pb.FlightDescriptor>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.FlightDescriptor>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.SchemaResult>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.SchemaResult>;
+}
+interface IFlightServiceService_IDoGet extends grpc.MethodDefinition<proto_Flight_pb.Ticket, proto_Flight_pb.FlightData> {
+    path: "/arrow.flight.protocol.FlightService/DoGet";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.Ticket>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.Ticket>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.FlightData>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.FlightData>;
+}
+interface IFlightServiceService_IDoPut extends grpc.MethodDefinition<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult> {
+    path: "/arrow.flight.protocol.FlightService/DoPut";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.FlightData>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.FlightData>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.PutResult>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.PutResult>;
+}
+interface IFlightServiceService_IDoExchange extends grpc.MethodDefinition<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData> {
+    path: "/arrow.flight.protocol.FlightService/DoExchange";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.FlightData>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.FlightData>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.FlightData>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.FlightData>;
+}
+interface IFlightServiceService_IDoAction extends grpc.MethodDefinition<proto_Flight_pb.Action, proto_Flight_pb.Result> {
+    path: "/arrow.flight.protocol.FlightService/DoAction";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.Action>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.Action>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.Result>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.Result>;
+}
+interface IFlightServiceService_IListActions extends grpc.MethodDefinition<proto_Flight_pb.Empty, proto_Flight_pb.ActionType> {
+    path: "/arrow.flight.protocol.FlightService/ListActions";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<proto_Flight_pb.Empty>;
+    requestDeserialize: grpc.deserialize<proto_Flight_pb.Empty>;
+    responseSerialize: grpc.serialize<proto_Flight_pb.ActionType>;
+    responseDeserialize: grpc.deserialize<proto_Flight_pb.ActionType>;
+}
+
+export const FlightServiceService: IFlightServiceService;
+
+export interface IFlightServiceServer extends grpc.UntypedServiceImplementation {
+    handshake: grpc.handleBidiStreamingCall<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse>;
+    listFlights: grpc.handleServerStreamingCall<proto_Flight_pb.Criteria, proto_Flight_pb.FlightInfo>;
+    getFlightInfo: grpc.handleUnaryCall<proto_Flight_pb.FlightDescriptor, proto_Flight_pb.FlightInfo>;
+    pollFlightInfo: grpc.handleUnaryCall<proto_Flight_pb.FlightDescriptor, proto_Flight_pb.PollInfo>;
+    getSchema: grpc.handleUnaryCall<proto_Flight_pb.FlightDescriptor, proto_Flight_pb.SchemaResult>;
+    doGet: grpc.handleServerStreamingCall<proto_Flight_pb.Ticket, proto_Flight_pb.FlightData>;
+    doPut: grpc.handleBidiStreamingCall<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult>;
+    doExchange: grpc.handleBidiStreamingCall<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData>;
+    doAction: grpc.handleServerStreamingCall<proto_Flight_pb.Action, proto_Flight_pb.Result>;
+    listActions: grpc.handleServerStreamingCall<proto_Flight_pb.Empty, proto_Flight_pb.ActionType>;
+}
+
+export interface IFlightServiceClient {
+    handshake(): grpc.ClientDuplexStream<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse>;
+    handshake(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse>;
+    handshake(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse>;
+    listFlights(request: proto_Flight_pb.Criteria, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightInfo>;
+    listFlights(request: proto_Flight_pb.Criteria, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightInfo>;
+    getFlightInfo(request: proto_Flight_pb.FlightDescriptor, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.FlightInfo) => void): grpc.ClientUnaryCall;
+    getFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.FlightInfo) => void): grpc.ClientUnaryCall;
+    getFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.FlightInfo) => void): grpc.ClientUnaryCall;
+    pollFlightInfo(request: proto_Flight_pb.FlightDescriptor, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.PollInfo) => void): grpc.ClientUnaryCall;
+    pollFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.PollInfo) => void): grpc.ClientUnaryCall;
+    pollFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.PollInfo) => void): grpc.ClientUnaryCall;
+    getSchema(request: proto_Flight_pb.FlightDescriptor, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.SchemaResult) => void): grpc.ClientUnaryCall;
+    getSchema(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.SchemaResult) => void): grpc.ClientUnaryCall;
+    getSchema(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.SchemaResult) => void): grpc.ClientUnaryCall;
+    doGet(request: proto_Flight_pb.Ticket, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightData>;
+    doGet(request: proto_Flight_pb.Ticket, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightData>;
+    doPut(): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult>;
+    doPut(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult>;
+    doPut(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult>;
+    doExchange(): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData>;
+    doExchange(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData>;
+    doExchange(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData>;
+    doAction(request: proto_Flight_pb.Action, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.Result>;
+    doAction(request: proto_Flight_pb.Action, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.Result>;
+    listActions(request: proto_Flight_pb.Empty, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.ActionType>;
+    listActions(request: proto_Flight_pb.Empty, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.ActionType>;
+}
+
+export class FlightServiceClient extends grpc.Client implements IFlightServiceClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
+    public handshake(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse>;
+    public handshake(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.HandshakeRequest, proto_Flight_pb.HandshakeResponse>;
+    public listFlights(request: proto_Flight_pb.Criteria, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightInfo>;
+    public listFlights(request: proto_Flight_pb.Criteria, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightInfo>;
+    public getFlightInfo(request: proto_Flight_pb.FlightDescriptor, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.FlightInfo) => void): grpc.ClientUnaryCall;
+    public getFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.FlightInfo) => void): grpc.ClientUnaryCall;
+    public getFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.FlightInfo) => void): grpc.ClientUnaryCall;
+    public pollFlightInfo(request: proto_Flight_pb.FlightDescriptor, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.PollInfo) => void): grpc.ClientUnaryCall;
+    public pollFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.PollInfo) => void): grpc.ClientUnaryCall;
+    public pollFlightInfo(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.PollInfo) => void): grpc.ClientUnaryCall;
+    public getSchema(request: proto_Flight_pb.FlightDescriptor, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.SchemaResult) => void): grpc.ClientUnaryCall;
+    public getSchema(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.SchemaResult) => void): grpc.ClientUnaryCall;
+    public getSchema(request: proto_Flight_pb.FlightDescriptor, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: proto_Flight_pb.SchemaResult) => void): grpc.ClientUnaryCall;
+    public doGet(request: proto_Flight_pb.Ticket, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightData>;
+    public doGet(request: proto_Flight_pb.Ticket, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.FlightData>;
+    public doPut(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult>;
+    public doPut(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.PutResult>;
+    public doExchange(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData>;
+    public doExchange(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<proto_Flight_pb.FlightData, proto_Flight_pb.FlightData>;
+    public doAction(request: proto_Flight_pb.Action, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.Result>;
+    public doAction(request: proto_Flight_pb.Action, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.Result>;
+    public listActions(request: proto_Flight_pb.Empty, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.ActionType>;
+    public listActions(request: proto_Flight_pb.Empty, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<proto_Flight_pb.ActionType>;
+}

package/dist/generated/proto/Flight_grpc_pb.js

@@ -0,0 +1,379 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// Original file comments:
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// <p>
+// http://www.apache.org/licenses/LICENSE-2.0
+// <p>
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var proto_Flight_pb = require('../proto/Flight_pb.js');
+var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js');
+
+function serialize_arrow_flight_protocol_Action(arg) {
+  if (!(arg instanceof proto_Flight_pb.Action)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.Action');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_Action(buffer_arg) {
+  return proto_Flight_pb.Action.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_ActionType(arg) {
+  if (!(arg instanceof proto_Flight_pb.ActionType)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.ActionType');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_ActionType(buffer_arg) {
+  return proto_Flight_pb.ActionType.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_Criteria(arg) {
+  if (!(arg instanceof proto_Flight_pb.Criteria)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.Criteria');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_Criteria(buffer_arg) {
+  return proto_Flight_pb.Criteria.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_Empty(arg) {
+  if (!(arg instanceof proto_Flight_pb.Empty)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.Empty');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_Empty(buffer_arg) {
+  return proto_Flight_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_FlightData(arg) {
+  if (!(arg instanceof proto_Flight_pb.FlightData)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.FlightData');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_FlightData(buffer_arg) {
+  return proto_Flight_pb.FlightData.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_FlightDescriptor(arg) {
+  if (!(arg instanceof proto_Flight_pb.FlightDescriptor)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.FlightDescriptor');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_FlightDescriptor(buffer_arg) {
+  return proto_Flight_pb.FlightDescriptor.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_FlightInfo(arg) {
+  if (!(arg instanceof proto_Flight_pb.FlightInfo)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.FlightInfo');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_FlightInfo(buffer_arg) {
+  return proto_Flight_pb.FlightInfo.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_HandshakeRequest(arg) {
+  if (!(arg instanceof proto_Flight_pb.HandshakeRequest)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.HandshakeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_HandshakeRequest(buffer_arg) {
+  return proto_Flight_pb.HandshakeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_HandshakeResponse(arg) {
+  if (!(arg instanceof proto_Flight_pb.HandshakeResponse)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.HandshakeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_HandshakeResponse(buffer_arg) {
+  return proto_Flight_pb.HandshakeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_PollInfo(arg) {
+  if (!(arg instanceof proto_Flight_pb.PollInfo)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.PollInfo');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_PollInfo(buffer_arg) {
+  return proto_Flight_pb.PollInfo.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_PutResult(arg) {
+  if (!(arg instanceof proto_Flight_pb.PutResult)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.PutResult');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_PutResult(buffer_arg) {
+  return proto_Flight_pb.PutResult.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_Result(arg) {
+  if (!(arg instanceof proto_Flight_pb.Result)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.Result');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_Result(buffer_arg) {
+  return proto_Flight_pb.Result.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_SchemaResult(arg) {
+  if (!(arg instanceof proto_Flight_pb.SchemaResult)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.SchemaResult');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_SchemaResult(buffer_arg) {
+  return proto_Flight_pb.SchemaResult.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_arrow_flight_protocol_Ticket(arg) {
+  if (!(arg instanceof proto_Flight_pb.Ticket)) {
+    throw new Error('Expected argument of type arrow.flight.protocol.Ticket');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_arrow_flight_protocol_Ticket(buffer_arg) {
+  return proto_Flight_pb.Ticket.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+//
+// 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.
+var FlightServiceService = exports.FlightServiceService = {
+  //
+// 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: {
+    path: '/arrow.flight.protocol.FlightService/Handshake',
+    requestStream: true,
+    responseStream: true,
+    requestType: proto_Flight_pb.HandshakeRequest,
+    responseType: proto_Flight_pb.HandshakeResponse,
+    requestSerialize: serialize_arrow_flight_protocol_HandshakeRequest,
+    requestDeserialize: deserialize_arrow_flight_protocol_HandshakeRequest,
+    responseSerialize: serialize_arrow_flight_protocol_HandshakeResponse,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/ListFlights',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_Flight_pb.Criteria,
+    responseType: proto_Flight_pb.FlightInfo,
+    requestSerialize: serialize_arrow_flight_protocol_Criteria,
+    requestDeserialize: deserialize_arrow_flight_protocol_Criteria,
+    responseSerialize: serialize_arrow_flight_protocol_FlightInfo,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/GetFlightInfo',
+    requestStream: false,
+    responseStream: false,
+    requestType: proto_Flight_pb.FlightDescriptor,
+    responseType: proto_Flight_pb.FlightInfo,
+    requestSerialize: serialize_arrow_flight_protocol_FlightDescriptor,
+    requestDeserialize: deserialize_arrow_flight_protocol_FlightDescriptor,
+    responseSerialize: serialize_arrow_flight_protocol_FlightInfo,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/PollFlightInfo',
+    requestStream: false,
+    responseStream: false,
+    requestType: proto_Flight_pb.FlightDescriptor,
+    responseType: proto_Flight_pb.PollInfo,
+    requestSerialize: serialize_arrow_flight_protocol_FlightDescriptor,
+    requestDeserialize: deserialize_arrow_flight_protocol_FlightDescriptor,
+    responseSerialize: serialize_arrow_flight_protocol_PollInfo,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/GetSchema',
+    requestStream: false,
+    responseStream: false,
+    requestType: proto_Flight_pb.FlightDescriptor,
+    responseType: proto_Flight_pb.SchemaResult,
+    requestSerialize: serialize_arrow_flight_protocol_FlightDescriptor,
+    requestDeserialize: deserialize_arrow_flight_protocol_FlightDescriptor,
+    responseSerialize: serialize_arrow_flight_protocol_SchemaResult,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/DoGet',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_Flight_pb.Ticket,
+    responseType: proto_Flight_pb.FlightData,
+    requestSerialize: serialize_arrow_flight_protocol_Ticket,
+    requestDeserialize: deserialize_arrow_flight_protocol_Ticket,
+    responseSerialize: serialize_arrow_flight_protocol_FlightData,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/DoPut',
+    requestStream: true,
+    responseStream: true,
+    requestType: proto_Flight_pb.FlightData,
+    responseType: proto_Flight_pb.PutResult,
+    requestSerialize: serialize_arrow_flight_protocol_FlightData,
+    requestDeserialize: deserialize_arrow_flight_protocol_FlightData,
+    responseSerialize: serialize_arrow_flight_protocol_PutResult,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/DoExchange',
+    requestStream: true,
+    responseStream: true,
+    requestType: proto_Flight_pb.FlightData,
+    responseType: proto_Flight_pb.FlightData,
+    requestSerialize: serialize_arrow_flight_protocol_FlightData,
+    requestDeserialize: deserialize_arrow_flight_protocol_FlightData,
+    responseSerialize: serialize_arrow_flight_protocol_FlightData,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/DoAction',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_Flight_pb.Action,
+    responseType: proto_Flight_pb.Result,
+    requestSerialize: serialize_arrow_flight_protocol_Action,
+    requestDeserialize: deserialize_arrow_flight_protocol_Action,
+    responseSerialize: serialize_arrow_flight_protocol_Result,
+    responseDeserialize: deserialize_arrow_flight_protocol_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: {
+    path: '/arrow.flight.protocol.FlightService/ListActions',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_Flight_pb.Empty,
+    responseType: proto_Flight_pb.ActionType,
+    requestSerialize: serialize_arrow_flight_protocol_Empty,
+    requestDeserialize: deserialize_arrow_flight_protocol_Empty,
+    responseSerialize: serialize_arrow_flight_protocol_ActionType,
+    responseDeserialize: deserialize_arrow_flight_protocol_ActionType,
+  },
+};
+
+exports.FlightServiceClient = grpc.makeGenericClientConstructor(FlightServiceService, 'FlightService');