@useairfoil/flight 0.1.0

package/dist/src/index.d.ts

@@ -0,0 +1,749 @@
+import { CallOptions, Channel, ChannelCredentials, ChannelOptions, CompatServiceDefinition, DefaultCallOptions, Metadata, NormalizedServiceDefinition } from "nice-grpc";
+import * as apache_arrow0 from "apache-arrow";
+import { RecordBatch, Schema } from "apache-arrow";
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+//#region src/proto/Flight.d.ts
+
+/** The request that a client provides to a server on handshake. */
+interface HandshakeRequest {
+  $type: "arrow.flight.protocol.HandshakeRequest";
+  /** A defined protocol version */
+  readonly protocolVersion: bigint;
+  /** Arbitrary auth/handshake info. */
+  readonly payload: Uint8Array;
+}
+interface HandshakeResponse {
+  $type: "arrow.flight.protocol.HandshakeResponse";
+  /** A defined protocol version */
+  readonly protocolVersion: bigint;
+  /** Arbitrary auth/handshake info. */
+  readonly payload: Uint8Array;
+}
+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.
+ */
+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.
+ */
+interface Criteria {
+  $type: "arrow.flight.protocol.Criteria";
+  readonly expression: Uint8Array;
+}
+/** An opaque action specific for the service. */
+interface Action {
+  $type: "arrow.flight.protocol.Action";
+  readonly type: string;
+  readonly body: Uint8Array;
+}
+/** An opaque result returned after executing an action. */
+interface Result {
+  $type: "arrow.flight.protocol.Result";
+  readonly body: Uint8Array;
+}
+/** Wrap the result of a getSchema call */
+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.
+ */
+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. */
+declare 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,
+}
+/**
+ * The access coordinates for retrieval of a dataset. With a FlightInfo, a
+ * consumer is able to determine how to retrieve a dataset.
+ */
+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. */
+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. */
+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.
+ */
+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.
+ */
+interface Ticket {
+  $type: "arrow.flight.protocol.Ticket";
+  readonly ticket: Uint8Array;
+}
+/** A batch of Arrow data as part of a stream of batches. */
+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. */
+interface PutResult {
+  $type: "arrow.flight.protocol.PutResult";
+  readonly appMetadata: Uint8Array;
+}
+declare const HandshakeRequest: MessageFns$1<HandshakeRequest, "arrow.flight.protocol.HandshakeRequest">;
+declare const HandshakeResponse: MessageFns$1<HandshakeResponse, "arrow.flight.protocol.HandshakeResponse">;
+declare const Empty: MessageFns$1<Empty, "arrow.flight.protocol.Empty">;
+declare const ActionType: MessageFns$1<ActionType, "arrow.flight.protocol.ActionType">;
+declare const Criteria: MessageFns$1<Criteria, "arrow.flight.protocol.Criteria">;
+declare const Action: MessageFns$1<Action, "arrow.flight.protocol.Action">;
+declare const Result: MessageFns$1<Result, "arrow.flight.protocol.Result">;
+declare const SchemaResult: MessageFns$1<SchemaResult, "arrow.flight.protocol.SchemaResult">;
+declare const FlightDescriptor: MessageFns$1<FlightDescriptor, "arrow.flight.protocol.FlightDescriptor">;
+declare const FlightInfo: MessageFns$1<FlightInfo, "arrow.flight.protocol.FlightInfo">;
+declare const PollInfo: MessageFns$1<PollInfo, "arrow.flight.protocol.PollInfo">;
+declare const FlightEndpoint: MessageFns$1<FlightEndpoint, "arrow.flight.protocol.FlightEndpoint">;
+declare const Location: MessageFns$1<Location, "arrow.flight.protocol.Location">;
+declare const Ticket: MessageFns$1<Ticket, "arrow.flight.protocol.Ticket">;
+declare const FlightData: MessageFns$1<FlightData, "arrow.flight.protocol.FlightData">;
+declare const PutResult: MessageFns$1<PutResult, "arrow.flight.protocol.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.
+ */
+type FlightServiceDefinition = typeof FlightServiceDefinition;
+declare const FlightServiceDefinition: {
+  readonly name: "FlightService";
+  readonly fullName: "arrow.flight.protocol.FlightService";
+  readonly 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.
+     */
+    readonly handshake: {
+      readonly name: "Handshake";
+      readonly requestType: MessageFns$1<HandshakeRequest, "arrow.flight.protocol.HandshakeRequest">;
+      readonly requestStream: true;
+      readonly responseType: MessageFns$1<HandshakeResponse, "arrow.flight.protocol.HandshakeResponse">;
+      readonly responseStream: true;
+      readonly 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.
+     */
+    readonly listFlights: {
+      readonly name: "ListFlights";
+      readonly requestType: MessageFns$1<Criteria, "arrow.flight.protocol.Criteria">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<FlightInfo, "arrow.flight.protocol.FlightInfo">;
+      readonly responseStream: true;
+      readonly 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.
+     */
+    readonly getFlightInfo: {
+      readonly name: "GetFlightInfo";
+      readonly requestType: MessageFns$1<FlightDescriptor, "arrow.flight.protocol.FlightDescriptor">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<FlightInfo, "arrow.flight.protocol.FlightInfo">;
+      readonly responseStream: false;
+      readonly 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.
+     */
+    readonly pollFlightInfo: {
+      readonly name: "PollFlightInfo";
+      readonly requestType: MessageFns$1<FlightDescriptor, "arrow.flight.protocol.FlightDescriptor">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<PollInfo, "arrow.flight.protocol.PollInfo">;
+      readonly responseStream: false;
+      readonly 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.
+     */
+    readonly getSchema: {
+      readonly name: "GetSchema";
+      readonly requestType: MessageFns$1<FlightDescriptor, "arrow.flight.protocol.FlightDescriptor">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<SchemaResult, "arrow.flight.protocol.SchemaResult">;
+      readonly responseStream: false;
+      readonly 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.
+     */
+    readonly doGet: {
+      readonly name: "DoGet";
+      readonly requestType: MessageFns$1<Ticket, "arrow.flight.protocol.Ticket">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<FlightData, "arrow.flight.protocol.FlightData">;
+      readonly responseStream: true;
+      readonly 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.
+     */
+    readonly doPut: {
+      readonly name: "DoPut";
+      readonly requestType: MessageFns$1<FlightData, "arrow.flight.protocol.FlightData">;
+      readonly requestStream: true;
+      readonly responseType: MessageFns$1<PutResult, "arrow.flight.protocol.PutResult">;
+      readonly responseStream: true;
+      readonly 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.
+     */
+    readonly doExchange: {
+      readonly name: "DoExchange";
+      readonly requestType: MessageFns$1<FlightData, "arrow.flight.protocol.FlightData">;
+      readonly requestStream: true;
+      readonly responseType: MessageFns$1<FlightData, "arrow.flight.protocol.FlightData">;
+      readonly responseStream: true;
+      readonly 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.
+     */
+    readonly doAction: {
+      readonly name: "DoAction";
+      readonly requestType: MessageFns$1<Action, "arrow.flight.protocol.Action">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<Result, "arrow.flight.protocol.Result">;
+      readonly responseStream: true;
+      readonly 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.
+     */
+    readonly listActions: {
+      readonly name: "ListActions";
+      readonly requestType: MessageFns$1<Empty, "arrow.flight.protocol.Empty">;
+      readonly requestStream: false;
+      readonly responseType: MessageFns$1<ActionType, "arrow.flight.protocol.ActionType">;
+      readonly responseStream: true;
+      readonly options: {};
+    };
+  };
+};
+type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {
+  readonly $case: string;
+} ? { [K in keyof Omit<T, "$case">]?: DeepPartial$1<T[K]> } & {
+  readonly $case: T["$case"];
+} : T extends {} ? { [K in Exclude<keyof T, "$type">]?: DeepPartial$1<T[K]> } : Partial<T>;
+type KeysOfUnion$1<T> = T extends T ? keyof T : never;
+type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & { [K in keyof P]: Exact$1<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$1<P> | "$type">]: never };
+interface MessageFns$1<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$1<DeepPartial$1<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/proto-utils.d.ts
+type RemoveTypeUrl<T> = Omit<T, "$type">;
+type ClientOptions<S extends CompatServiceDefinition> = {
+  defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<S>>;
+};
+type HostOrChannel = {
+  host: string;
+  credentials?: ChannelCredentials;
+  channelOptions?: ChannelOptions;
+  channel?: never;
+} | {
+  host?: never;
+  channel: Channel;
+};
+declare function createChannelFromConfig(config: HostOrChannel): Channel;
+//#endregion
+//#region src/arrow-flight.d.ts
+declare class ArrowFlightClient {
+  private client;
+  constructor(config: HostOrChannel, options?: ClientOptions<FlightServiceDefinition>);
+  executeFlightInfo(info: FlightInfo, options?: CallOptions): AsyncGenerator<RecordBatch>;
+  /**
+   * 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>, options?: CallOptions): AsyncIterable<HandshakeResponse>;
+  /** Get a list of available streams given a particular criteria. */
+  getFlightInfo(request: FlightDescriptor, options?: CallOptions): Promise<FlightInfo>;
+  /**
+   * 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, options: {
+    schema: Schema;
+  } & CallOptions): AsyncIterable<RecordBatch>;
+  /**
+   * 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>, options?: CallOptions): AsyncIterable<PutResult>;
+}
+//#endregion
+//#region src/proto/FlightSql.d.ts
+
+/**
+ * Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
+ * The definition of a catalog depends on vendor/implementation. It is usually the database itself
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8 not null
+ * >
+ * The returned data should be ordered by catalog_name.
+ */
+interface CommandGetCatalogs {
+  $type: "arrow.flight.protocol.sql.CommandGetCatalogs";
+}
+/**
+ * Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
+ * The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8,
+ *  db_schema_name: utf8 not null
+ * >
+ * The returned data should be ordered by catalog_name, then db_schema_name.
+ */
+interface CommandGetDbSchemas {
+  $type: "arrow.flight.protocol.sql.CommandGetDbSchemas";
+  /**
+   * Specifies the Catalog to search for the tables.
+   * An empty string retrieves those without a catalog.
+   * If omitted the catalog name should not be used to narrow the search.
+   */
+  readonly catalog?: string | undefined;
+  /**
+   * Specifies a filter pattern for schemas to search for.
+   * When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
+   * In the pattern string, two special characters can be used to denote matching rules:
+   *    - "%" means to match any substring with 0 or more characters.
+   *    - "_" means to match any one character.
+   */
+  readonly dbSchemaFilterPattern?: string | undefined;
+}
+/**
+ * Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8,
+ *  db_schema_name: utf8,
+ *  table_name: utf8 not null,
+ *  table_type: utf8 not null,
+ *  [optional] table_schema: bytes not null (schema of the table as described in Schema.fbs::Schema,
+ *                                           it is serialized as an IPC message.)
+ * >
+ * Fields on table_schema may contain the following metadata:
+ *  - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+ *  - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+ *  - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+ *  - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+ *  - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+ *  - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+ *  - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+ * The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
+ */
+interface CommandGetTables {
+  $type: "arrow.flight.protocol.sql.CommandGetTables";
+  /**
+   * Specifies the Catalog to search for the tables.
+   * An empty string retrieves those without a catalog.
+   * If omitted the catalog name should not be used to narrow the search.
+   */
+  readonly catalog?: string | undefined;
+  /**
+   * Specifies a filter pattern for schemas to search for.
+   * When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
+   * In the pattern string, two special characters can be used to denote matching rules:
+   *    - "%" means to match any substring with 0 or more characters.
+   *    - "_" means to match any one character.
+   */
+  readonly dbSchemaFilterPattern?: string | undefined;
+  /**
+   * Specifies a filter pattern for tables to search for.
+   * When no table_name_filter_pattern is provided, all tables matching other filters are searched.
+   * In the pattern string, two special characters can be used to denote matching rules:
+   *    - "%" means to match any substring with 0 or more characters.
+   *    - "_" means to match any one character.
+   */
+  readonly tableNameFilterPattern?: string | undefined;
+  /**
+   * Specifies a filter of table types which must match.
+   * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+   * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+   */
+  readonly tableTypes: readonly string[];
+  /** Specifies if the Arrow schema should be returned for found tables. */
+  readonly includeSchema: boolean;
+}
+/**
+ * Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
+ * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+ * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  table_type: utf8 not null
+ * >
+ * The returned data should be ordered by table_type.
+ */
+interface CommandGetTableTypes {
+  $type: "arrow.flight.protocol.sql.CommandGetTableTypes";
+}
+/**
+ * Represents a SQL query. Used in the command member of FlightDescriptor
+ * for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *    Fields on this schema may contain the following metadata:
+ *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+ *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+ *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+ *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+ *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+ *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+ *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+ *  - GetFlightInfo: execute the query.
+ */
+interface CommandStatementQuery {
+  $type: "arrow.flight.protocol.sql.CommandStatementQuery";
+  /** The SQL syntax. */
+  readonly query: string;
+  /** Include the query as part of this transaction (if unset, the query is auto-committed). */
+  readonly transactionId?: Uint8Array | undefined;
+}
+declare const CommandGetCatalogs: MessageFns<CommandGetCatalogs, "arrow.flight.protocol.sql.CommandGetCatalogs">;
+declare const CommandGetDbSchemas: MessageFns<CommandGetDbSchemas, "arrow.flight.protocol.sql.CommandGetDbSchemas">;
+declare const CommandGetTables: MessageFns<CommandGetTables, "arrow.flight.protocol.sql.CommandGetTables">;
+declare const CommandGetTableTypes: MessageFns<CommandGetTableTypes, "arrow.flight.protocol.sql.CommandGetTableTypes">;
+declare const CommandStatementQuery: MessageFns<CommandStatementQuery, "arrow.flight.protocol.sql.CommandStatementQuery">;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+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;
+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 };
+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;
+}
+//#endregion
+//#region src/arrow-flight-sql.d.ts
+declare class ArrowFlightSqlClient {
+  private inner;
+  constructor(config: HostOrChannel, options?: ClientOptions<FlightServiceDefinition>);
+  executeFlightInfo(request: FlightInfo, options?: CallOptions): AsyncGenerator<apache_arrow0.RecordBatch<any>, any, any>;
+  getCatalogs(request: RemoveTypeUrl<CommandGetCatalogs>, options?: CallOptions): Promise<FlightInfo>;
+  getDbSchemas(request: RemoveTypeUrl<CommandGetDbSchemas>, options?: CallOptions): Promise<FlightInfo>;
+  getTables(request: RemoveTypeUrl<CommandGetTables>, options?: CallOptions): Promise<FlightInfo>;
+  getTableTypes(request: RemoveTypeUrl<CommandGetTableTypes>, options?: CallOptions): Promise<FlightInfo>;
+  executeQuery(request: RemoveTypeUrl<CommandStatementQuery>, options?: CallOptions): Promise<FlightInfo>;
+}
+//#endregion
+//#region src/flight-data-encoder.d.ts
+declare const FlightDataEncoder: {
+  encodeSchema(schema: Schema, {
+    flightDescriptor,
+    appMetadata
+  }: {
+    flightDescriptor: FlightDescriptor;
+    appMetadata?: Uint8Array;
+  }): FlightData;
+  encodeBatch(batch: RecordBatch, {
+    appMetadata
+  }?: {
+    appMetadata?: (args: {
+      index: number;
+      length: number;
+    }) => Uint8Array | undefined;
+  }): ReadonlyArray<FlightData>;
+};
+//#endregion
+export { ArrowFlightClient, ArrowFlightSqlClient, type ClientOptions, FlightData, FlightDataEncoder, FlightDescriptor, FlightDescriptor_DescriptorType, type HostOrChannel, Metadata, PutResult, Ticket, createChannelFromConfig };
+//# sourceMappingURL=index.d.ts.map