import { Config, Context, Effect, Layer, Scope, Stream } from "effect";
import { CallOptions, CallOptions as CallOptions$1, Channel, ChannelCredentials, ChannelOptions, CompatServiceDefinition, DefaultCallOptions, NormalizedServiceDefinition } from "nice-grpc";
import { RecordBatch, RecordBatch as RecordBatch$1, Schema, TypeMap } from "apache-arrow";
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import * as effect_Types0 from "effect/Types";
import * as effect_Cause0 from "effect/Cause";

//#region src/record-batch-with-metadata.d.ts
type RecordBatchWithMetadata<T extends TypeMap = any> = {
  readonly batch: RecordBatch<T>;
  readonly appMetadata: Uint8Array;
};
declare namespace flight_client_error_d_exports {
  export { FlightClientError, FlightClientErrorLike, FlightDecodeError, FlightProtocolError, FlightTransportError };
}
declare const FlightClientError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
  readonly _tag: "FlightClientError";
} & Readonly<A>;
declare class FlightClientError extends FlightClientError_base<{
  readonly message: string;
  readonly cause?: unknown;
}> {}
declare const FlightTransportError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
  readonly _tag: "FlightTransportError";
} & Readonly<A>;
declare class FlightTransportError extends FlightTransportError_base<{
  readonly message: string;
  readonly cause?: unknown;
}> {}
declare const FlightDecodeError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
  readonly _tag: "FlightDecodeError";
} & Readonly<A>;
declare class FlightDecodeError extends FlightDecodeError_base<{
  readonly message: string;
  readonly cause?: unknown;
}> {}
declare const FlightProtocolError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
  readonly _tag: "FlightProtocolError";
} & Readonly<A>;
declare class FlightProtocolError extends FlightProtocolError_base<{
  readonly message: string;
  readonly cause?: unknown;
}> {}
type FlightClientErrorLike = FlightClientError | FlightTransportError | FlightDecodeError | FlightProtocolError;
//#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/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$1, I extends P$1> = P$1 extends Builtin$1 ? P$1 : P$1 & { [K in keyof P$1]: Exact$1<P$1[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$1<P$1> | "$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;
}
declare namespace arrow_flight_client_d_exports {
  export { ArrowFlightClient, ArrowFlightClientOptions, ArrowFlightClientService, CallOptions$1 as CallOptions, ClientOptions, HostOrChannel, RecordBatch$1 as RecordBatch, RecordBatchWithMetadata, layer$1 as layer, layerConfig$1 as layerConfig, make$1 as make };
}
type ArrowFlightClientOptions = HostOrChannel & {
  readonly defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<FlightServiceDefinition>>;
};
interface ArrowFlightClientService {
  readonly handshake: (request: AsyncIterable<HandshakeRequest>, options?: CallOptions$1) => Stream.Stream<HandshakeResponse, FlightClientErrorLike>;
  readonly getFlightInfo: (request: FlightDescriptor, options?: CallOptions$1) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
  readonly doGet: (request: Ticket, options: {
    readonly schema: Schema;
  } & CallOptions$1) => Stream.Stream<RecordBatchWithMetadata, FlightClientErrorLike>;
  readonly doPut: (request: AsyncIterable<FlightData>, options?: CallOptions$1) => AsyncIterable<PutResult>;
  readonly executeFlightInfo: (info: FlightInfo, options?: CallOptions$1) => Stream.Stream<RecordBatchWithMetadata, FlightClientErrorLike>;
}
declare const ArrowFlightClient_base: Context.ServiceClass<ArrowFlightClient, "@useairfoil/flight/ArrowFlightClient", ArrowFlightClientService>;
declare class ArrowFlightClient extends ArrowFlightClient_base {}
declare const make$1: (options: ArrowFlightClientOptions) => Effect.Effect<ArrowFlightClientService, never, Scope.Scope>;
declare const layer$1: (options: ArrowFlightClientOptions) => Layer.Layer<ArrowFlightClient>;
declare const layerConfig$1: (options: Config.Wrap<ArrowFlightClientOptions>) => Layer.Layer<ArrowFlightClient, Config.ConfigError, never>;
//#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$1, I extends P$1> = P$1 extends Builtin ? P$1 : P$1 & { [K in keyof P$1]: Exact<P$1[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P$1> | "$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;
}
declare namespace arrow_flight_sql_client_d_exports {
  export { ArrowFlightSqlClient, ArrowFlightSqlClientOptions, ArrowFlightSqlClientService, CallOptions, FlightInfo, RecordBatchWithMetadata, layer, layerConfig, make };
}
type ArrowFlightSqlClientOptions = ArrowFlightClientOptions;
interface ArrowFlightSqlClientService {
  readonly executeFlightInfo: (info: FlightInfo, options?: CallOptions) => Stream.Stream<RecordBatchWithMetadata, FlightClientErrorLike>;
  readonly getCatalogs: (request: RemoveTypeUrl<CommandGetCatalogs>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
  readonly getDbSchemas: (request: RemoveTypeUrl<CommandGetDbSchemas>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
  readonly getTables: (request: RemoveTypeUrl<CommandGetTables>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
  readonly getTableTypes: (request: RemoveTypeUrl<CommandGetTableTypes>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
  readonly executeQuery: (request: RemoveTypeUrl<CommandStatementQuery>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
}
declare const ArrowFlightSqlClient_base: Context.ServiceClass<ArrowFlightSqlClient, "@useairfoil/flight/ArrowFlightSqlClient", ArrowFlightSqlClientService>;
declare class ArrowFlightSqlClient extends ArrowFlightSqlClient_base {}
declare const make: (options: ArrowFlightClientOptions) => Effect.Effect<ArrowFlightSqlClientService, never, Scope.Scope>;
declare const layer: (options: ArrowFlightSqlClientOptions) => Layer.Layer<ArrowFlightSqlClient>;
declare const layerConfig: (options: Config.Wrap<ArrowFlightSqlClientOptions>) => Layer.Layer<ArrowFlightSqlClient, Config.ConfigError, never>;
//#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 { arrow_flight_client_d_exports as ArrowFlightClient, type ArrowFlightClientOptions, type ArrowFlightClientService, arrow_flight_sql_client_d_exports as ArrowFlightSqlClient, type ArrowFlightSqlClientOptions, type ArrowFlightSqlClientService, type ClientOptions, flight_client_error_d_exports as FlightClientError, type FlightClientErrorLike, FlightData, FlightDataEncoder, FlightDescriptor, FlightDescriptor_DescriptorType, type FlightInfo, type HostOrChannel, PutResult, type RecordBatchWithMetadata, Ticket, createChannelFromConfig };
//# sourceMappingURL=index.d.ts.map